sobol techblog

Fake Snowflake Shadow

2012-01-29T17:15:00.000+01:00

Some time ago I was walking at night in a dense snow fall. I won't talk about my mood, but I was walking alone, nobody was around and I had some time to think, or rather to observe what was happening around. I was really excited about the shadows that where casted by snowflakes. They were dancing everywhere around, like small spiders running through the snow. Something beautiful, honestly. Of course, I mean shadows that are casted by something like street lamp. Now the problem is - how to simulate them? Of course we can cast each shadow accurately. But there are some obvious problems, and when I say problem I mean performance. I think I don't have to explain what problems are connected to shadowing complex particle system with multiple lights (just imagine the deferred shading with all those particles outside buffers, problems with transparency, or FR with multiple pass particle drawing, crazy). And also, there is some possibility, that you render your flakes (or even more possibly - rain) as post process. Sure! It is possible to do it in a straight way, but we wouldn't be game developers if we wouldn't look for some fakes ;) So how can we add some fancy shadows on the snow, that will look like drunk spiders? As you can expect, I'm not going to talk about any physically accurate solution. Look at the image first.

The upper part of the image is a 2D ortho projection of the world, the Source is our street lamp, green line is the ground. The lower part is meant to be the top-down view. As you can see, when the snowflake is close to the lamp (high), it's shadow is casted far from the center of the lamp cone, and it's movement dx1 is quite big. Then, when the snowflake falls and is close to the ground, it's movement dx2 decreases and position get's closer to the center. The situation shown here is utopia, because the flake falls straight down, with const speed. But, what it shows is that the shadow will be tending towards cone center with decreasing speed. This is a very important observation. Now, let's look at the right side. The snow is falling by some trajectory and in successive time periods it is located in P0, P1, P2 and P3 positions. The rule is quite the same, its shadow in time (T0-T3) tends towards cone center with decreasing speed, but we have to remember that this speed will not decrease monotonically, but will be varying. There even may be a situation, when T(n) is farther from cone center than T(n-1). When we look from top at the problem, we also have to add some variation in the other axis (due to air drag, the flake doesn't move straight), we can assume that shadow moves over some simple spline, directed towards S' (cone center) and with variably decreasing speed. The Lambda area is some small area around S', where shadows tend to dissapear (i think that making them bigger and more transparent would look good). You have to include this Lambda area if you don't want your shadows to dissapear suddenly. That's what I've observed in nature - flakes don't go towards strict cone center, but towards some area, because the light bulb isn't a point, but a volume.

Ok, I think that the idea is simple and obvious, so now - how can we simulate this? There are many possibilities, like:

Particle system used only for shadows
Post process stage shadowing
Animated textures (even on low-end hardware, but I won't call any exact names ;P) with texture projection
etc.

What you can take from this note is the general behaviour of snowflakes. Their movement is partly predictable (or at least its schema), and by reproducing it you can achieve some eye-candy scene.

2 Fast 4 GNOMZ

2011-11-23T15:46:00.000+01:00

This is the second game in Gnomia world, look at the first one. While GNOMZ was a multiplayer game, 2 Fast 4 GNOMZ is an exclusively single player game, just like the previous one - made by QubicGames for WiiWare service. This time our goal is to run through the world of Gnomia to find a woman and, of course, collect socks. There are four characters that you can morph into, that's why there is '4' in the title. The game is quite indie in style and is strongly related to Bit.Trip Runner and Super Meat Boy in a matter of difficulty. Our goal was to create a game that is really a challenge, only for hardcore, oldschool gamers. My role at 2F4G was project management and lead programming. There were 11 people working on this title development, including programming, visuals and audio.

GNOMZ on the market

2011-11-04T10:56:00.000+01:00

I can proudly say, that my youngest child - GNOMZ, was finally published on WiiWare, USA. Read more at gnomzthegame.com. You can also buy the game, visit nintendo.com

I can also say, that Gnomia is such an inquiring world, that we are allready working on another title that is going to be placed there. This has been already announced on nintendolife.com by Michał Dys, our PR fella ;)

With or without GPU, that is the question...

2011-09-16T10:19:00.000+02:00

This post just represents my thoughts about how people get into some hi-tec trap. They know how to create some eye candy effects, like fish eye or chromatic aberration with GPU shader with 5 lines of code or less - that's cool. But when it comes to a situation when people don't have those shaders for their support, they get confused and say "that's impossible, you can not create such effects without modern GPU" and that's bullshit. A good example is the platform, that I'm currently working on - Wii. I can not say anything more technical about this platform due to some legal rights, but I can say (and everybody know it) that it's rather a low-end hardware. Let's get back to those effects that I've mentioned. You can create some approximation (simple fake, but that's what graphics are all about, ain't it?) using simple linear texture filtering - just create a grid of quads with regular mapping and distort their positions in some manner. With fish eye - just create radial distortion with strength proportional to distance from center of the grid. It looks quite good and is extremely cheap both in performance and implementation.Chromatic aberration - draw red channel on such grid with horizontal distortion with some strength, then green one with 2/3 of this strength and blue one with 1/3, mix them using additive blending et voila!

As a conclusion - this can be really simple, just don't ever think that something is possible only on new GPUs or CPUs or whatever, stay open-minded :) I think that this is quite what low end hardware demoscene is all about.

Class method as template parameter

2011-08-28T19:00:00.001+02:00

I had an interesting problem that can be solved using a little bit tricky C++ code. Imagine a singleton that holds some pointer to a class that has many methods with identical params, but different purposes. Now, imagine you're creating some wrapper for this class in some other class (the first one was a ID3D11Device in my case, so I didn't modify it) and your code is also identical, despite this single method call. You can obviously copy paste this problem, creating n-times more lines of code. But this is an ugly solution, so below I paste the nice one. Class A is the ID3D11Device, class B is my wrapper. In my case fun1 was enough (i knew A type while implementing this), but because i find this useful - i paste code for case with unknown A type. Of course in practice, fun1 and fun2 would be big functions with this single call embedded somewhere deep.

struct A {
void a(int param) { std::cout << "a " << param << std::endl; }
void b(int param) { std::cout << "b " << param << std::endl; }
};

struct B {
template< void (A::*F)(int) >
void fun1() {
A* a = new A; // obtain A, this may be singleton or anything else
(a->*F)(1);
delete a;
}

template< typename T, void (T::*F)(int) >
void fun2(T* t) {
(t->*F)(2);
}
};

int main() {
B b;
b.fun1< &A::a >();
b.fun1< &A::b >();

A a;
b.fun2< A,&A::a >(&a);
b.fun2< A, &A::b >(&a);

return 0;
}

The only aspect that may need some explanation at the moment is how to pass ID3D11Device method marked with STDMETHODCALLTYPE as template parameter. Notice, that STDMETHODCALLTYPE is just a macro for __stdcall. We can pass this additional keyword using syntax like:

template< HRESULT (__stdcall ID3D11Device::*CreateShader)(const void*, SIZE_T, ID3D11ClassLinkage*, ID3D11VertexShader**) >
bool load_(const char* filename) {
...
}

Ok, now for the real example - the code will be a little bit more tricky, because we have to use derived template param as param for functions used as template params, blah, compliacted - look at the code :)

template< typename ShaderType >
class Shader {
protected:
ShaderType* shader;
public:
Shader() {
shader = NULL;
}

virtual ~Shader() {
if(shader) {
shader->Release();
}
}

template< HRESULT (__stdcall ID3D11Device::*CreateShader)(const void*, SIZE_T, ID3D11ClassLinkage*, ShaderType**) >
bool load_(const char* filename, const char* entryPoint, const char* shaderModel) {
...
}

template< void (__stdcall ID3D11DeviceContext::*SetShader)(ShaderType*, ID3D11ClassInstance* const*, UINT) >
void bind_() {
...
}
};

class VertexShader : public Shader< ID3D11VertexShader > {
public:
__forceinline bool load(const char* filename) {
return load_< &ID3D11Device::CreateVertexShader >(filename, "mainVS", "vs_4_0");
}

__forceinline void bind() {
bind_< &ID3D11DeviceContext::VSSetShader >();
}
};

class PixelShader : public Shader< ID3D11PixelShader > {
...
};

class GeometryShader : public Shader< ID3D11GeometryShader > {
...
};

class DomainShader : public Shader< ID3D11DomainShader > {
...
};

class HullShader : public Shader< ID3D11HullShader > {
...
};

class ComputeShader : public Shader< ID3D11ComputeShader > {
...
};

Of course you may decide to make load and bind virtuals, and to pack them into some kind of manager - this is just a design decision, whether you want to automate use of those classes. In such case design would get a little bit more complicated. My load is virtual, bind isn't. Additionally, VertexShader is strongly coupled with VertexLayout (ID3D11InputLayout), which is created while loading, so my structure looks something like this:

GNOMZ the game

2011-08-24T22:17:00.032+02:00

GNOMZ is a WiiWare multiplayer hot seat action platformer developed by QubicGames. I worked over this project as lead programmer and project manager since january till august 2011. You can read more about this game on GnomzTheGame.com. I also wrote some paper about implementing AI in GNOMZ, you can read it here.

Reviews:

"I would say that Gnomz is an excellent multiplayer game"
www.gev.com

Smart Traffic Signs

2011-08-06T14:54:00.000+02:00

Recently, I've been traveling more than 4k km by car, and I had some time to think about stuff not connected with gamedev. In Germany I've noticed a strange sign - speed limit depending on slipperiness of the road surface. It was strange, because there were no precautions if weather is ok, so you can go 300km/h if your car can, and in case of rain you can go only 80km/h, so it's quite discrete. And than the idea came - why not measure the state of the road and show the speed limit in electronic form. For example in dense rain - 80km/h, in snow - 50km/h, in light rain - 120km/h and so on. We kept going, and on the bridge there was a sign - in case of wind, 100km/h or something like this. The idea is even better here - just measure wind speed and show appropriate limits. The method is great because the sign can measure a lot of parameters at a time, and using some heuristics it can show the speed limit, or some other information. What other info? For example - imagine a sign showing a pedestrian crossing. If you go at night you usually can't see anything, so slowing down is the only option, but even going 50km/h is too much if someone enters the crossing. The solution is simple - show some additional info, that there is someone near the crossing, so that the driver knows that he has to stop, not only slow down. It's not easy to implement, but in my opinion it's not impossible. Smart signs can also take into consideration some other stuff, like traffic - read this. In my opinion, the method has almost no limits, and would really improve safety on roads. The only question is, will politics spend money on our safety? I don't think so, they need money for PR :)

Let's go further - the speed limit also depends on the car, for example big truck should have much bigger limits. Why not implement traffic signs... in cars? Imagine a display that shows you the limit, or in extreme it can even automatically limit your speed. The idea can be really simple - all traffic signs have some transmitters attached, that broadcast restrictions at some place (some norm would be required). Receivers collect those broadcast, and analyze them, for example taking into consideration mass of the car, state of it's tires and so on. But for now this is rather science fiction, because all cars would have to implement this. Maybe it's a good moment to start such revolution, this depends on motorization brands. Remember, that such a solution doesn't have to mean that we remove all "classic" signs - they can stay, we can just add some new features to them.

Tempy Guardian, 3rd place in IGK'2011

2011-04-07T22:51:00.002+02:00

This is our entry to IGK'2011 8 hour competition. Our - I mean my team, that is:

Michał "Sobol" Sobiecki (me) - shaders & rendering, catapult, most of the framework
Maciek "Słoń" Stefańczyk - gameplay (with Box2D), sound framework
Kacper "Szkudi" Szkudlarek - sounds, level design
Oskar Świerad - all graphics and animations

Compo theme was "Temple Guardian", and orgs ment tower defence by this. But we decided to create an anti-game, with Godzilla as Tempy Guardian (it means stupid guardian in polish). The guardian is so stupid, that he can not defend the temple, that is nuclear plant, because he prefers to dance. We have to destroy green pulsating radioactive something with blue teddybears thrown with the catapult. Simple, but fun. And that was our goal.

During the competition, we have created 90% of the code. We didn't manage to finish particle system (due to stupid bug... sic!) and stuff like this. But as I said, 90% of the game was created during the compo, including all 8 levels! We've placed 3rd, out of 12 teams.

[YouTube presentation]

[DOWNLOAD]

Remote Racers (QubicGames)

2011-02-21T17:59:00.001+01:00

Remote Racers is a 3D racing game for Nintendo DSi platform. I worked over it as a main programmer after project reactivation (September - December 2010). The game was developed and published by QubicGames. On the 21st of February, 2011, the game showed up in DSiWare market in the USA. The trailer is available on YouTube. You can also visit projects official website.

Modelling thrown powder snow phenomenon for computer animation

2011-02-08T18:08:00.003+01:00

This project is my Bachelor's Thesis on Warsaw University of Technology, Department of Electronics and Computer Science. The original title is "Modelowanie zjawiska wzbitego puchu śnieżnego dla potrzeb animacji komputerowej".

Abstract

The present thesis describes a fluid simulator based on nonlinear Navier-Stokes equations. The way of creating a stable solver is described. There is also some information on how to create vorticity confinement improvement. Next, the way of rendering solver output data using Blender 3D software is presented. Finally, the paper presents some examples and gives an insight into the implementation of the solver.

You can watch some effects on YouTube: [1], [2], [3], [4], [5]. I graduated with "5" mark (very good) on the 8th of february 2011.

Space Pirate, 3D space shooter

2010-03-20T17:46:00.024+01:00

This is a 3D game, where you can become a pilot of a space fighter. It's an oldschool shoot'em'up game, so you have to destroy dozens of enemies on several levels. You can also improve your ship, buying new weapons and abilities (like bullet time or invisibility). The game is based on Util3D game engine, that I've created from scratch in C++, OpenGL and CG for shaders. Models were created by Marcin "Karkoś" Karkowski. Music is by Combichrist (I hope they don't mind, after all it's just a small game not for sale). Idea, design and code is by me (Michał "Sobol" Sobiecki). I have to mention, that part of graphics is also by me - for example procedural backgrounds generated on the fly while game loads :)

[DOWNLOAD] (remember about VC 2008 redists)

Import archiwum GG do Pidgin

2009-12-26T19:08:00.000+01:00

Pidgin to całkiem przyjemny multikomunikator, obsługujący między innymi protokół znanego i nielubianego GG, dobra alternatywa dla oficjalnego klienta. Przy zmianie klienta nie chciałem jednak rozstać się ze swoim archiwum, do którego jestem mocno przywiązany, dlatego zacząłem googlować, i szybko dowiedziałem się, że do Pidgin "nie da się" zaimportować archiwum z GG. Skoro się nie da, to na szybko zobaczyłem jaki jest format archiwum w nowym kliencie, i napisałem konwerter. Ponieważ z braku czasu cała operacja nie mogła przekroczyć godziny, pogooglałem znowu i znalazłem fajny programik do zamiany archives.dat z GG na plik txt (i przy okazji dobry opis formatu archiwum) http://users.v-lo.krakow.pl/~anszom/ggarch/index.pl.shtml

Pomyślałem, że może konwerter się komuś przyda (może nie każdy będzie musiał pisać własny :P) więc udostępniam. Skąd wziąć archives.dat? Z "C:\Documents and Settings\NAZWA_KONTA\Gadu-Gadu\KONTO_GG". W wyniku działania konwertera wygeneruje się spora liczba plików (i mogą troszkę ważyć - mi z 18 megowego archiwum zrobiło się 30, przy czym "rozmiar na dysku" to aż 82. Ahh to wyrównanie... Gdzie je wrzucić? "C:\Documents and Settings\NAZWA_KONTA\Dane aplikacji\.purple\logs\gadu-gadu\TWOJ_NUMER_GG\". I tyle, po wrzuceniu wygenerowanych plików do tego folderu Pidgin sobie już poradzi.

[DOWNLOAD]

The kulkis

2009-12-01T17:37:00.003+01:00

This is a simple 3D shooting game, created in one week from scratch in C++, OpenGL using ODE physics engine. There are some troops of yellow spheres flying around the city. The goal is to shoot them with red ones, but... when you shoot a troop, they start to panic and escape. The red ones become yellow after some time, so you have to shoot reasonably. Red ones have also an advantage - they pursuit yellow ones :)

[DOWNLOAD]

Widmo molocha...

2009-11-30T21:59:00.001+01:00

Dzisiaj nietypowy post, mający stanowić antyreklamę firmy którą wszyscy dobrze znają - TPSA. Opowiem krótką bajkę o tym co mnie boli. Od jakiegoś czasu (będzie ze 2 miesiące) neostrada zrywa mi połączenie, średnio na 6h w ciągu dnia, w dodatku najczęściej w najmniej korzystnych godzinach (prawo Murphyego). Na początku podszedłem do sprawy bardzo spokojnie - zadzwoniłem do obsługi technicznej, przysłali technika, który stwierdził, że winę ponosi listwa antyprzepięciowa, przez którą połączony jest modem do gniazdka (bzdura, ale nvm). Odłączyłem listwę, żeby nie było, że robię coś wbrew zaleceniom. Połączenie nadal zrywało, więc kolejny telefon do obsługi. Dokładnie taka sama rozmowa - "a telefon jest połączony przez mikrofiltr? a kabel jest podłączony? a komputer to pan włączył?" No kurwa mać ;/ Zgłoszenie poszło do techników, którzy nawet nie raczyli się umówić, o przyjechaniu nie wspominam. Potem było kilka rozmów o tym "czy połączyłem telefon przez mikrofiltr" i wezwań techników którzy się nie pojawiali. W ostatniej rozmowie pan w słuchawce powiedział mi praktycznie wprost, że mogę go opieprzać jak chcę a to i tak nic nie da, bo on ma gówno do tego, i co najwyżej może wezwać do mnie techników. Technik zadzwonił w niedzielę o 9.00 przed świtem, umówił się na poniedziałek między 13 a 15. Zarezerwowałem czas, czekałem, nie pojawił się, najnormalniej w świecie, parszywie mnie olał.

Konkluzja jest taka - jeszcze nie wiem jak to załatwić, ale albo pozwolą mi przedterminowo zerwać umowę, albo ich zaskarżę, bo to co robią, to najnormalniejsze w świecie świństwo. Zapomnieli, że już nie są monopolistą, i że mogę zmienić ich denną neostradę na inny "internet".

Efekty uboczne

2009-11-13T23:34:00.000+01:00

Przy okazji robienia proceduralnego generatora teł do gry przypadkiem wygenerowałem całkiem ciekawe obrazki. Wprawdzie kompletnie bezużyteczne przy mojej aktualnej pracy, ale ruszyły moją wyobraźnię i myślę, że mogłyby mieć spore zastosowanie w demoscenie na przykład. Szczególnie, że generatorem jest zwykły atraktor pickover (kto nie zna, odsyłam do chaoscope) z drobną wariacją, ustalającą kolor na podstawie odległości od źródeł światła, czyli można to zaimplementować w "paru" bajtach dosłownie.

Takie efekty uboczne bardzo często są powodem powstawania nowych pomysłów, rozwiązań czy algorytmów.

Re: Pola i akcesory wewnątrz klas

2009-10-27T15:21:00.001+01:00

Do napisania tego posta sprowokował mnie Xion, swoją notką. Kiedyś sam o tym troszkę rozmyślałem, i doszedłem do wniosku, że zwykle wewnątrz klasy lepiej jest się odwołać bezpośrednio do składowych. Są jednak pewne wyjątki. I tutaj historia z życia wzięta, ale rozpisywać się nie będę, bo jak wiadomo jeden pseudokod znaczy więcej niż tysiąc słów :P

class Scene {

// trzy wskazniki na glowne macierze 
const Matrix4x4* modelMatrix;
const Matrix4x4* viewMatrix;
const Matrix4x4* projMatrix;

// od groma wyliczonych z nich macierzy 
Matrix4x4 modelViewMatrix, modelViewProjMatrix, invModel, (...), invModelViewProjMatrix;

bool /* w oryginale tu jest bitset */ modelChanged, (...), invModelViewProjChanged; 

public:

// tylko trzy metody set 
void setModelMatrix(const Matrix4x4* m) const;
void setViewMatrix(const Matrix4x4* m) const;
void setProjMatrix(const Matrix4x4* m) const;

// od groma metod get
const Matrix4x4& getModelMatrix() const; 
(...) 
const Matrix4x4& getInvModelViewProj() const;

};

Do tego dodajmy klasę ShaderManager, która pobiera sobie te macierze (i nie tylko, ale nie będę mieszać tutaj za bardzo, bo do puenty nie dojdę nigdy). I teraz - jak słusznie zauważył Xion użycie metod set na zewnątrz klasy Scene nie budzi (nie powinno!) wątpliwości. W tym przypadku jest to również konieczne wewnątrz. Przyczyna? Ktoś kto uważnie przeczytał pseudokod pewnie się domyśla, że liczenie (bądź co bądź kosztowne, szczególnie w przypadku inverse) macierzy jest odłożone do pierwszego get. Natomiast set aktualizuje odpowiednie wartości "changed". W przypadku nieużywania set trzeba te wartości zmienić ręcznie, co powoduje generalny syf w kodzie.

Pojawia się tutaj pytanie - co jeśli ktoś używa naszej klasy i o tym nie wie, i napisze gdzieś po prostu modelMatrix = identity4x4. Albo (o zgrozo :P) my sami mamy już tak rozdmuchaną klasę, że o tym zapominamy. Znalezienie błędu potem może być dosyć kosztowne. Moje rozwiązanie (które stosuję) polega na wywaleniu całej logiki związanej z macierzami do klasy SceneMatrix, gdzie macierze są w prywatnym obszarze a metody w publicznym, i dziedziczenie po niej. Zaleta jest taka, że w zależności od potrzeb możemy dziedziczyć publicznie lub prywatnie i w ten sposób udostępniać lub chować metody get / set na zewnątrz. Przy takim podejściu nie ma mowy o "zapomnieniu", że trzeba użyć set zamiast operatora=. Wadą jest to, że zwykle prowadzi to do wielodziedziczenia, ale moim zdaniem nie jest to ani błąd ani problem w takim przypadku.

Geometria w C++

2009-10-24T16:18:00.003+02:00

Każdy kto pisze silnik graficzny, fizyczny, lub po prostu grę, potrzebuje często używać algorytmów geometrii obliczeniowej - triangulacji, liczenia otoczek wypukłych, operacji Boolowskich na wielokątach lub geometrii 3 wymiarowej, czy choćby prostym sprawdzaniu kolizji punktu z bryłą. Są to algorytmy używane w większości dziedzin związanych z kodowaniem gier i nie tylko, również ważne w CADach, robotyce, sofcie medycznym etc. Ponieważ odkrywanie koła po raz setny jest bezsensowne, postanowiłem znaleźć bibliotekę realizującą takie zadania za nas.

CGAL (Computational Geometry Algorithms Library) wydaje się być strzałem w dziesiątkę. Jest to bardzo dojrzały projekt, rozwijany od 97 roku o ile się nie mylę. Obecnie doczekał się już wersji 3.5. Udostępnia bardzo pokaźną liczbę struktur danych i algorytmów. Poszczególne biblioteki projektu są proste w użyciu i dobrze udokumentowane. Całość napisana jest z myślą o C++, ale z tego co wyczytałem jest również wsparcie dla Pythona (co może się przydać w pisaniu skryptów do AI). Szczegółowy przegląd ficzerów można znaleźć na stronie http://www.cgal.org/

Teraz licencja - do zastosowań niekomercyjnych CGAL jest darmowy (połowicznie na licencji LGPL i QPL). Natomiast w przypadku zastosowań komercyjnych tak różowo nie jest, trzeba zakupić licencję, niestety nie znalazłem ceny na ich stronie.

Wykobi jest dużo mniej rozwiniętym (obecnie wersja 0.0.4), ale również ciekawym i dobrze zapowiadającym się projektem na licencji GNU GPL w przypadku zastosowań niekomercyjnych oraz na płatnej licencji w przeciwnym przypadku. Warto zobaczyć co oferuje, na stronie http://www.wykobi.com/

VGL jest częścią większego pakietu VXL. Nie oferuje zbyt wiele, tak na prawdę jest to zbiór struktur danych oraz kilku podstawowych algorytmów, głównie do transformacji przestrzennych. Jednak uznałem, że warto go odnotować, choćby ze względu na możliwość używania za free po spełnieniu podstawowych warunków o dołączeniu licencji, nie używaniu TM i wyraźnym zaznaczeniu modyfikacji. Cały pakiet VXL oferuje już troszkę więcej - między innymi algorytmy algebry liniowej i operacje na obrazach. http://vxl.sourceforge.net/

Na koniec zostawiłem Generic Geometry Library (GGL), która nie oferuje wprawdzie tyle co CGAL, ale jest całkowicie darmowa. Jest to kandydat do wcielenia w zestaw libów Boost. Udostępnia kilka ciekawych funkcji jak liczenie otoczki wypukłej (algorytm Grahama), clipping czy proste testy kolizyjne (a raczej bazę do takich testów). http://geometrylibrary.geodan.nl/index.html

Muszę jednak wspomnieć o dokumentacji do GGL, która jest... tragiczna. Dobrym przykładem jest opis użycia klasy graham do liczenia otoczki wypukłej. Jest on wygenerowany przez doxygena, co bardzo lubię, ale brakuje tam choćby słowa komentarza od autora.

Na koniec dodam, że jeśli ktoś zna inne ciekawe liby (najlepiej free) to zachęcam do podzielenia się linkiem :)

SSequence, 4k intro sequencer

2009-10-01T18:58:00.001+02:00

This small application purpose is to create sounds (like beat or hat) for 4k intros, that can be later composed into music. The sounds are exported directly into C++ header file (in the form of code that generates them). It was created using C++ and wxWidgets. The tool was never released due to lack of time to finish it. Anyway, it was kind of fun.

Złom jako stymulator postępu technologicznego

2009-09-28T17:09:00.003+02:00

Ponieważ zmęczyło mnie ostatnio trochę hardcorowe pisanie silnika, postanowiłem zrobić sobie małą odskocznię. Wygrzebałem ze strychu laptopa, sprzęt można by powiedzieć archaiczny, bo z prockiem 266MHz, jakąś dwumegową kartą etc. i postanowiłem napisać na nim bibliotekę fizyki 2d, taką, żeby dało się na niej oprzeć płynnie działającą prostą gierkę z fizyką. Nic niezwykłego - jakiś collision response dla convexów, jakiś tam rigid body model etc. Normalnie pewnie nie zwrócił bym na to uwagi, ale z racji sprzętu jakoś mnie tknęło, gdy w jednej z funkcji musiałem zrobić coś takiego:

// pseudokod
int k = jakies obliczenia;
T* t = new T[k];
// jakies przetwarzanie
delete[] t;

Przy czym funkcja była bardzo krótka, i jak mi się wydawało, alokacja pamięci na heapie była jej wąskim gardłem (na tym sprzęcie jest to wąskie gardło co by nie mówić :P). Mogłem zastosować opcję T t[100] i liczyć, że 100 nie będzie przekroczone, ale to nie jest ani eleganckie ani profesjonalne, w ogóle to jak rosyjska ruletka. No i wtedy mnie tknęło - dlaczego T t[100] jest właściwie szybsze niż new? Dlatego, że alokacja na stosie to tylko przesunięcie wskaźnika stosu, a na heapie to wyszukanie odpowiednio dużego spójnego obszaru, ustawienie flag w jakiejś mapie pamięci (zależnie od niskopoziomowej implementacji zarządzania pamięcią), dopiero potem faktyczne przydzielenie tego obszaru i zwrócenie wskaźnika. Tak powstał pomysł napisania funkcji salloc i sfree. W pełni świadomy problemów z "popieprzeniem stosu" pomiędzy ich wywołaniami postanowiłem zrobić te funkcje jako inline, i tu pojawił się mały problem, leżący w mojej pamięci, a raczej w odwołaniu z niej do specyfikacji C++, która to nie nakazuje aby funkcja inline była faktycznie inline. Mówiąc inaczej - funkcja inline może ale nie musi pomijać całą zabawę z ramką stosu. Tak wpadłem na użycie __forceinline i z bananem na ryju odpaliłem funkcje do testów... banan szybko znikł, segfault, ale dlaczego? Rozkmina chwilę potrwała, w końcu wykonałem taki oto test:

__forceinline int stest() {
int toRet;
__asm mov toRet, esp
return toRet;
}
int t1, t2;
__asm mov t1, esp
t2 = stest;

Po wypisaniu t1 i t2 okazało się, że o ile w trybie release są one takie same, o tyle w trybie debug wartości są różne, o zgrozo! Okazało się, że programiści z Microsoftu zrobili sobie joke, nazywając słowo kluczowe __forceinline, bo tak na prawdę ono wcale nie jest force i robi z funkcji inline kiedy chce i jak chce, czyli powiedzieli "cmoknijcie nas w pompkę my i tak lepiej wiemy kiedy inline jest potrzebne". Zresztą popatrzcie co na to MSDN
Tak więc zapadła decyzja, zrobię to jak koder ANSI C - przy pomocy makro, za co zwolennicy "idealnego C++" by mnie zabili pewnie, ale to nie moja wina, że producenci kompilatorów robią sobie jaja.

#define salloc(PTR, M_SIZE) \
__asm sub esp, M_SIZE \
__asm mov PTR, esp

#define sfree(M_SIZE) \
__asm add esp, M_SIZE

Dobra, teraz pytanie - czy było warto? Do testu odpalałem funkcje w których tylko alokowałem i zwalniałem pamięć (na 1000 intów), w pętli po 10 000 000 razy (na Athlonie XP 2400+). Wyniki przeszły moje oczekiwania, może nie najśmielsze ale zawsze :P

Tryb DEBUG:
new: 23.6571
salloc: 0.596729
Tryb RELEASE:
new: 4.29237
salloc: 0.0172891

Wyniki podane są w sekundach. Zalety są kosmiczne, ale wady też są - wspomniane mieszanie na stosie na pewno nie jest zdrowe dla początkujących koderów, metoda jest raczej przeznaczona dla tych świadomych, rozumiejących co się dzieje na stosie.

Konstruktory, konstruktory

2009-09-03T14:03:00.012+02:00

Załóżmy, że mamy klasę, w której nie ma funkcji wirtualnych (!), po niczym nie dziedziczy (w szczególności wirtualnie), i skomponowana jest tylko z niestatycznych i niestałych obiektów podstawowych. Jest to klasyczny przypadek klas typu Vector2, Vector3, Matrix3x3, Matrix4x4, oraz wielu innych matematycznych (i nie tylko) w grach. W takich klasach bardzo często wywoływany jest konstruktor kopiujący, więc warto byłoby się zastanowić jak taki konstruktor napisać optymalnie (*). Najprostszy sposób, to kopiowanie każdej wartości osobno. Inną możliwością jest wywołanie funkcji w rodzaju memcpy, żeby cały blok danych przekopiować na raz (stąd założenie o funkcjach wirtualnych etc., żeby nie nadpisać vtable pointera), co z kolei powoduje nakład na całą zabawę z ramką stosu. Teoretycznie można to jeszcze zoptymalizować przez modyfikator inline dla konstruktora. Ostatnie podejście, które sprawdziłem to... nie pisanie konstruktora ;P
Do testu przygotowałem 4 klasy - A, B, C i D, wykorzystujące wspomniane 4 podejścia. Konstruktory kopiujące dla A, B i C wyglądają następująco (dla testu drugiego, czyli symulacji macierzy 4x4, test pierwszy odpowiadał wektorowi trójelementowemu):

A(const A& a) {
x1 = a.x1; y1 = a.y1; z1 = a.z1; w1 = a.w1;
x2 = a.x2; y2 = a.y2; z2 = a.z2; w2 = a.w2;
x3 = a.x3; y3 = a.y3; z3 = a.z3; w3 = a.w3;
x4 = a.x4; y4 = a.y4; z4 = a.z4; w4 = a.w4;
}

B(const B& b) {
memcpy(this, &b, sizeof(B));
}

inline C(const C& c) {
memcpy(this, &c, sizeof(C));
}

Następnie dla każdej z 4 klas przeprowadziłem identyczny test ( testCycles = 100000000):

for(int i = 0; i < testCycles; i++) {
A acopy = A(a);
}

Jak wspomniałem, test 1 odpowiadał Vector3, test 2 - Matrix4x4.

Można się było domyślać, że narzut wywołania funkcji przewyższy zysk przy małej liczbie elementów do skopiowania. Natomiast wynik dla klasy D, z wygenerowanym automatycznie konstruktorem kopiującym jest dosyć zastanawiający, szczególnie dla przypadku 1 (aż z wrażenia dla pewności sprawdziłem, czy kompilator w ogóle kopiował obiekty :P). Więc moja odpowiedź na pytanie (*) - jak optymalnie napisać taki konstruktor brzmi: nie pisać wcale! Kompilator sobie poradzi.

Przy okazji sprawdziłem jeszcze jedną rzecz. Wielu programistów twierdzi, że lista inicjatorów konstruktora to tylko zabieg stylistyczny i nie różni się od przypisania wartości do obiektu wewnątrz konstruktora. Oczywiście mylnie, bo stosując drugie podejście wywołujemy niejawnie konstruktor obiektu tymczasowego, potem operator przypisania, a potem jeszcze destruktor. Prosty test:

class X {
std::string text;
public:
X() {
text = "text";
}
};

class Y {
std::string text;
public:
Y() : text("text") {}
};

W pętli wywoływałem tym razem zwykły konstruktor, wynik potwierdza to, co napisałem:

Mazanie po murach i inne zabawy

2009-09-01T13:11:00.004+02:00

Ostatnio sporo czasu spędzam na oglądaniu produkcji niezależnych twórców, w poszukiwaniu inspiracji / pomysłu / weny - niepotrzebne skreślić. W moje ręce wpadła gierka, która wygrała w kategorii "Best Student Game" na Independent Games Festival 2009, pod złowieszczym tytułem "Tag: The Power of Paint". Po oglądnięciu screenów stwierdziłem, że to jakaś lipa - kiepsko (wręcz obciachowo) wyglądający cel shade'owy FPS, w dodatku nie widać przeciwników. No ale przecież zajął 1 miejsce w jakiejś kategorii, więc nie może być tak źle - ściągnąłem i... zakochałem się, genialna gra. Jest to bardzo nietypowe połączenie FPSa i gry logicznej - gatunków biegunowych. Do dyspozycji mamy 3 bronie - z zieloną, czerwoną i niebieską farbą oraz czwarte psikadełko - do zamazywania, coś jak gumka do ścierania. Każda farba ma pewne właściwości, gdy wejdziemy na pomalowaną nią podłogę... ścianę lub sufit. Zielona - powoduje, że nasza postać skacze, czerwona - że biegnie, niebieska - że przykleja się do ścian (dlatego można łazić po sufitach). Ogólnie chodzi o to, żeby tak bazgrać po planszy, żeby dostać się do punktu docelowego. Momentami trzeba sporo się pogłowić, popróbować różnych rozwiązań. Dodatkowo element zręcznościowy powoduje, że choć wiemy jak przeskoczyć z dachu na dach, to musimy do tego podchodzić kilka razy. No i jeszcze to łażenie po ścianach - kto grał w AVP już to przechodził, ale tutaj jest jakoś bardziej zwariowanie, momentami naprawdę mocno gubi się orientację przestrzenną. Warto zagrać. A jeszcze co ciekawe, w assetach znajdują się nieskompilowane shadery i oskryptowanie całej gry w XMLu, więc można ją sobie troszkę pozmieniać bez grzebania w binarkach.

Przy okazji wspomnę jeszcze o 2 gierkach z tego samego festiwalu. Pierwsza to rewelacyjny pomysł na gameplay - Snapshot Możemy robić screeny różnych przedmiotów (np. słonia, drzwi), potem umieszczać te screeny w jakimś miejscu, przenosząc w ten sposób owe przedmioty - np. stawiamy screena ze słoniem przy jakimś pudle, dzięki czemu słoń je przepchnie, albo drzwi na jakiejś ścianie, dzięki czemu będziemy mogli przez nią przejść. Dodatkowo klimatem przypomina troszkę czasy ośmiobitowców. Druga - FEIST spodobała mi się po prostu pod względem artystycznym, niesamowity klimat, zazdroszczę umiejętności grafikowi i designerowi (takie przeciwieństwo wspomnianego wyżej Tag :D).

A, jeszcze może wypada wspomnieć - samo IGF jest eventem odbywającym się w trakcie GDC. Wspomniana edycja odbyła się już dość dawno, w marcu. Mając fajny projekt na pewno warto się zgłosić, bo nagrody pieniężne są całkiem pokaźne, no i ten prestiż :P

printf - based - listener

2009-08-12T19:02:00.000+02:00

Potrzebowałem zrobić listener dowolnej ilości zmiennych oparty na funkcji o prototypie podobnym do


int printf ( const char * format, ... );

wyzwalany jakąś funkcją (w szczególnym przypadku callbackiem). Na przykład wyświetlający informacje typu FPS w grze, albo jako reakcja na event czy przychodzący z sieci pakiet. Dla uproszczenia tej notki załóżmy, że ma obsługiwać jedynie inty i floaty. Można oczywiście napisać wielką funkcję, w której w zależności od jakiejś zmiennej będziemy wywoływać w switchu printf(napis, int1), printf(napis, int1. int2) etc. aż do 1000 zmiennych różnych typów, czego na pewno nikt nie przekroczy. Ale można też to zrobić inaczej. Moje rozwiązanie jest proste - podajmy parametry bezpośrednio z poziomu asma. W dokumentacjach można wyczytać jak VS (w moim przypadku, bo go używam) wywołuje funkcje (calling convention), jednak warto to sprawdzić w praktyce.

Na początek robimy sobie małą aplikację testową:


#include 
int main() {
printf("printf call %d %f\n", 1, 2.0f);
return 0;
}

Kompilujemy, odpalamy, i (o dziwo) na ekranie wyświetla się napis „printf call 1 2.000000”. Podejrzyjmy wygenerowaną binarkę w desassemblerze, np. w IDA (program jest dostępny w wersji Freeware – troszkę ograniczonej, ale dla przeciętnego człowieka oferuje i tak o wiele za dużo). Interesuje nas poniższy fragment (jeśli nie umiesz znaleźć go w swoim disasmie, warto się pouczyć podstaw RE, choćby z [1] czy [2], czasem się przydają nawet jeśli nie chcemy być RE).


.text:004113BE                 mov     esi, esp
.text:004113C0                 sub     esp, 8
.text:004113C3                 fld     ds:dbl_415758
.text:004113C9                 fstp    [esp+0D4h+var_D4]
.text:004113CC                 push    1
.text:004113CE                 push    offset aPrintfCallDF
.text:004113D3                 call    ds:printf
.text:004113D9                 add     esp, 10h

Jak widać parametry funkcji wrzucane są na stos od końca. Czyli zgodnie z opisem w dokumentacji. Jeśli chodzi o inty sprawa jest banalna - znany wszystkim push wartości. Więc np. zamiast


int i = 1;
int j = 2;
printf("printf call %d %d\n", i, j);

możemy zrobić równoważne:


int i = 1;
int j = 2;

__asm {
push j
push i
}

printf("printf call %d %d\n");

int add_ = 8;
__asm add esp, add_

Na początku wrzucamy zmienne na stos zgodnie z konwencją kompilatora, potem robimy call i na końcu zwiększamy wskaźnik stosu o tyle o ile zmniejszyliśmy go niejawnie przy pushowaniu. Jaki z tego jest zysk? Ano taki:


int tablica[5] = {1, 2, 3, 4, 5};

for(int i = 4; i >= 0; --i) {
int k = tablica[i];
__asm push k
}

printf("printf call %d %d %d %d %d\n");

int add_ = 4 * 5;
__asm add esp, add_

A co z floatami? FLD wrzuca float’a na stos FPU, natomiast FSTP kopiuje pierwszą wartość z tego stosu pod wskazany adres, po czym wykonuje POPa (btw. jest też wersja bez POPa - FST). Trzeba też pamiętać, że potrzebujemy aż 64 bitów.


float f = 3.14f;
int floatSize = 8;
__asm {
fld f
sub esp, floatSize
fstp qword ptr [esp]
}
printf("float = %f\n");
__asm add esp, floatSize

Samego listenera można teraz zaimplementować na tyle sposobów ilu jest koderów. W moim przypadku cały snippet wygląda tak:


#include 
#include 
#include 

class PrintfListener {
enum Type {
T_INT,
T_FLOAT
};

struct Value {
Type type;
union V_ {
 int* i;
 float* f;
} val;

Value(int* i) { type = T_INT; val.i = i; }
Value(float* f) { type = T_FLOAT; val.f = f; }
};

std::vector value;
std::string str;
public:
void addParam(int* i) { value.push_back(Value(i)); }
void addParam(float* f) { value.push_back(Value(f)); }
void setString(const std::string& s) { str.assign(s); }

void use() {
std::vector::iterator it = value.end();
int totalSize = 0;
while(true) {
 --it;

 switch(it->type) {
  case T_INT: {
   int v = *(it->val.i);
   __asm push v
   totalSize += 4;
  } break;
  case T_FLOAT: {
   float v = *(it->val.f);
   __asm {
    fld v
    sub esp, 8
    fstp qword ptr [esp]
   }
   totalSize += 8;
  } break;
 }

 if(it == value.begin()) break;
}

printf(str.c_str());
__asm add esp, totalSize
}
};

int main() {
int i = 0;
float f = 0.0f;

PrintfListener listener;
listener.addParam(&i);
listener.addParam(&f);
listener.setString("i = %d, f = %f\n");

listener.use();

i = 10;
f = 3.14f;
listener.use();

return 0;
}

Ok, a jak to ugryźć inaczej? Można np. zastosować STLowy string stream i do printfa przekazywać gotowy poskładany string - ale wtedy właściwie tracimy największą zaletę formatującego printfa, więc przy takim podejściu byśmy już pewnie użyli iostream na konsoli i napisali inną funkcję wypisującą w przypadku aplikacji graficznej. Jak ktoś ma inne genialne sposoby (może da się to zrobić dużo prościej?) to będę wdzięczny za wszelkie info :)

[1] ReverseCraft by Gynvael – dobre źródło dla początkujących z RE: http://re.coldwind.pl/
[2] Introduction to Reverse Engineering Software by Mike Perry - świetne źródło, troszkę wiekowe, dla początkujących z RE, bardzo dużo informacji od podszewki: http://www.acm.uiuc.edu/sigmil/RevEng/

Birthday demo

2009-06-01T17:03:00.002+02:00

This piece of demoscene was created for my friend, Kasia Wasak, on her 22nd birthday. There were some typical demoscene effects included, like growing weeds and moving spheres with environment mapping using dynamic cube-mapping technique.

Metaballs 2D

2009-04-25T17:26:00.001+02:00

Just a demoscene effect, kind of presentation. But nothing big. In this small project I created dynamic metaballs (isosurfaces) and synchronized it with Drum & Bass music in the background. There were also some fancy electrical breakdowns in this demo, that occured when one metaball was close to another, and the other was then attracted by the first one. One of the metaballs was controlled by input device (mouse). And there were also some equalizers in this demo ;) Everything was created in C++ and CG (all metaball stuff is calculated on the GPU, with some simple shader).

Don't Kill The Babcia (Granny)

2009-03-28T17:12:00.027+01:00

The game was created in 8 hours during 6th Conference of Games Engineering in Siedlce, Poland. Compo theme was "psychodelic game". Our team was: me (Sobol, most of the code), Słoń (code & gfx), Koshmaar (some code & gfx & sfx) and Artpoz (code & sfx & gfx).

Our entry was and MMO game (yeah, right - Massive Multiplayer Offline :P), because up to 24 people could could play on one keyboard. The goal of the game is NOT to kill grannies, that are talking some bullshit and swearing at you. Sometimes granny takes a white rabbit out of her pocket and throws it at you. You have to press your key then to block it, otherwise you loose frag. Sometimes granny tries to frighten you by taking the rabbit, but not throwing. If you press the key in such a moment, you loose frag, because granny dies. Once every couple of seconds, there is a keybord shuffle, and you have to find your new key.

We placed 8th out of 9 teams. That's not too good, I agree. But the main problem in my opinion is that we were not able to present our game to the public, because they didn't understand what we were doing. In my opinion this game was kind of fun :)

SA4011, Mirco Machines remake

2008-12-24T16:54:00.001+01:00

This game was created as a term project for "Advanced C++" classes on WEiTI, Warsaw University of Science. The game was supposed to be a crazy variation over Codemasters Micro Machines. We created a game that several people could play over TCP/IP connection, and got the highest mark possible (5). You could choose between 6 unique vehicles (driven by me and my 5 friends). Unfortunately it's too bugy to release on the internet.

Our team was:

Michał "Sobol" Sobiecki (me)
Maciek "Słoń" Stefańczyk
Kacper "Szkudi" Szkudlarek

Think, 4k intro

2008-05-18T16:47:00.000+02:00

Yeah, what can I say? Pure demoscene. This 4k intro (size limited to 4kb) was my entry for gamedev.pl demoscene compo, on may 2008, where I took 2nd place. Video rip was placed on YouTube, and there was also some entry on Pouet.

Too fast, too rabie

2008-04-01T16:35:00.002+02:00

"Too fast, too rabie" ("Szybcy i ze wścieklizną") is a 2D platform game created as a term project for Event Driven Programming classes. The first version was released after one week of development on gamedev.pl compo, where it took 2nd place. The game was created using J2SE, JOGL (OpenGL 4 Java) and Swing for map editor.

[DOWNLOAD]

URPL28, sci-fi RTS game

2007-03-01T16:14:00.001+01:00

Quote from original project site:

"URPL28 is a real time strategy game. Player can choose between two game modes - campaign and free play and three races (...) There are three times of day, and each race has supremacy during one of them. (...) It's a unique combination of fantasy and science fiction genres. (...)"

The game was created in 5 months (September 2006 - february 2007). The project was abandoned after releasing tech demo (the release was on time) due to the beginning of my Bachelor course.

Credits:

Idea, Code & Design - me ("Sobol" , M.Sobiecki)
2D artist - "BlackHawk", P.Lenart
Sounds & music - "Beleg", R.Wieczorek
www - cRgh0sT
Testing - Cenobium team (specialized in reversing and IRC :P)

Thanks guys for your help and support!

[DOWNLOAD, Tech Demo 2k7]

Big Trouble in Moomins Valley

2007-01-01T15:36:00.022+01:00

The game took first place in gamedev.pl 2006 Christmas compo. The theme of this compo was "Moomins or some other popular cartoon". I named it "Big Trouble in Moomins Valley" ("Wielka Draka w Dolinie Muminków") It was created in 9 days, from scratch. Although it was quite buggy, it allowed two players to play against each over over TCP/IP connection.

[DOWNLOAD]