Oren Game Engine

Playing Inside Artist World...

2011-12-28T23:56:00.000-08:00

hi
recently i put my time mainly in modeling/texturing etc... so in the post i will talk about the tools and the pipeline i'm using and then i'll show some works i'm working on.
the tools i'm using is:
1. autodesk 3dsmax 2012, 3d modeling software, for me its the best software... i always liked this program, very easy to understand and control, tons of tutorials more stable version.
2. autodesk mudbox 2012, this is a new program i had to learn from scratch, basically its a 3d sculpting and painting app, allows you to create high detail models and paint directly on them.
3. adobe photoshop, nothing to say about it, great image editing software.
so, the pipeline i'm using now is:
1. collect reference pictures, anything i want in my scene i search for real world references from different viewing angles.
2. start modeling low poly model using the reference images i collected, yes yes, i know i should start modeling high poly model and then create the low poly one, but i found this technique is a waste of time (for most of the models), and i can add detail later in mudbox/photoshop and believe me you wont even know...
3. create uv mapping, well, this is really important, what we really want is to create a uv set the maximize texture space in a way that important parts of the model get bigger area in the texture and at the same time try to make all our uv islands/chinks uniform as much as possible, in simple words, if you put a checker board texture on the model, you should see uniform checkers.
4. texturing, for this i'm using both photoshop and mudbox:
mudbox used when i don't need pixel perfect alignment and its great as i can see the results immediately, photoshop used when i need to fix things and add extra detail that needs pixel perfect matching...

one of the best things in 3dsmax/mudbox/photoshop is that they communicate, in a single click i can send model to mudbox, paint on it, another click to pass the textures to photoshop, fix few things and return to mudbox, the textures in modbox update automatically, and then in another click i update max scene to contain all the changes... really cool stuff, and time saver!

another thing that is really cool is that autodesk software can be downloaded for free! yes free!
how, well, they have an education program that allow students to enjoy their software, so what you really need to do is to register, fill your education info etc.. and you can download everything for free! really nice...
on autodesk site, click solutions-education-students-join...

the pipeline described used to create diffuse texture, to create other textures: normal/bump, specular etc... you can also use mudbox and photoshop also, though you can use other app's like: crazybump, shadermap pro, ndo2 etc... great programs.
maybe i will post on this next time.

now for some works i did recently (simple scene lighting, mudbox capture, without normal/bump/specular maps)

Fuse Box

Trailer Tire

Wood Pallet

Barrel

Power Box

cya until next time...

FBX Exporter

2011-11-28T04:03:00.000-08:00

Hi
after the last post, i had to create a new plan and the first phase was to support different app's to create assets from.

up until now, i use my own maya exporter, which converts models/animations to my own format the engine can read.
this exporter was created entirely for the artist as he worked with maya.

for the record, i don't know to work with maya, but i know to work with 3dsmax, at the time, i didn't want to handle models/animation and prefer to focus on dev but now i will need to do both.

anyway, i decided that an FBX exporter will be good since i know to model/animate with max so i could create few things here and there and in the future i will not bound to a single software, and this is great as finding artist will be much easier if you are not bound to single app.

for these who don't know FBX format: FBX is an autodesk format created so you could share works with different autodesk app's like maya, 3dsmax, softimage, motionbuilder, mudbox etc...
FBX it comes will full SDK & samples and have fairly readable doc that explain how to use and build FBX app. (can be downloaded from autodesk site)

because i already had maya exporter which had all the conversion code to the engine, i just needed to import the fbx and convert everything just like i did with the old exporter, and within few hours i had support for models (no animation).

to support animation i had to dig a little bit as at first i tried to convert the matrices imported from the FBX to engine format at import time (left handed Z up) and that didn't went very well, as the hierarchy of the skeleton needed to work with the stored format, even when i succeeded the animation was screw up.
so what i did i imported the data as is (not changing/converting anything) and only in the exporting phase (just before writing to a file) i convert to my own engine format.
just like i did in the old maya exporter...
i burn a lot of hours just to realize that what i did in the old maya exporter was correct, if i just went and look at the old code i could save a lot of time and thinking...

after i finishing this i notice few animation didn't running correctly, some vertices isn't moving like they supposed to (relative the the skeleton), and after digging a little more i saw that some code i took from the old exporter wasn't fit right for the new one, and the vertices indices wasn't correct.
'vertices indices' means i have for each vertex X indices or more, for vertex position,normal,uv etc.. so these was screw up (the order wasn't correct) and the nasty thing is that for few test models with animation there was no bug at all and for some there was.

NOTE: the skeleton always act and looks fine but vertices wasn't, so it was hard to track down the bug.
the way i eventually track it is that i created a very simple model with animation and compare each of the vertices weights with the vertices weights exported (using weight table in 3dsmax), when i did that i notice that the weights values was fine but the order wasn't, so few vertices that influence by bone1 was influence by bone2 etc...

anyway, one thing to remember from this is that when you take code from some old code of yours make sure to check it fits, and don't assume its good.
it can be good/clean code but it doesn't means it fits like a glove...

so now that the pipeline works you will see some works on the next posts...
cya

The Smell of the Money Can Make You Blind...

2011-10-19T11:24:00.000-07:00

Hi all
this time i'v some "bad" news.
last post i wrote about a project i'm about to expose, unfortunately this isn't going to happened.
i turns out that when "my friend" saw we have some real thing in our hands he smell the money, and that make him do what he did this week.
i wont get into details (numbers and stuff), but i feel i need to share what went wrong so if you will be in my position you know what to do.

i got to know this guy from a good friend of mine, so i trust my friend that this guy is ok.
from day one our working model based on free time only!
i gave him X percent for starting, and he began to work on some models, after working for a while, i rise it 1.5X and eventually he got 2X percent, even that the work he did stays the same, average of one model per week! (for the simple ones!, complex ones could get to one month)

2 weeks before exposing he told me that he wants more and told me to think very careful about what i'm going to say, so i though and even that there was no good reason to rise it up, i want him to be happy, so i give him another 25% of the 2X he got and told him i want him to sign on a contract i will arrange about everything we agreed on.

this week he told me that he doesn't want to continue, talking a little bit with him i realize that he wants 25%+, and he told me that i can't use his models in anyway... for the record, i can use them for non profit use, but i decided that i don't want to, i don't want him to have anything with my projects not now and not ever...

after checking out what he actually did in almost 2 years i saw its less than 50 models! including the simplest one (cans, bottles, barrels etc), so giving him 25% is giving him 0.5% per model!

so the bottom line of all this little story is:
don't trust anyone when doing this kind of thing, make a construct from day one, i did one and gave him but i didn't insist him to sign it, bad mistake.
i will be happy to hear what do you think, did i do the right thing? did i handled it correctly?

i always knew that money can blind wise peoples, but now i know that even the smell...

i will continue to update this blog, hopefully more recent...
cya

Stay Tuned for the BLAST!

2011-10-06T01:43:00.000-07:00

hi
recently i'm not updating this blog often, the reason is that me and my friend working very hard on a big project and i can't find time to post, every free minute i have i put in the project...
if you are curious, here are some Q/A:

* so... whats the big project you are working on?
well, basically it's a game.

* what kind of game?
that's will be published soon.

* what is so special about this game?
feeling! we work hard to make it feel real, in terms of look and feel...

* is it going to be a full game?
no, for now we will publish one level, to show what we can do.

* what engine are you using?
internal, for now i named it: OGE (oren game engine)

* why didn't you use cry-engine,unreal, unity,ogre, or any other free engines out there?
one word: freedom!

* can you tell about the engine a little?
yes, but this can be a very long answer, so here are few cool things we have:

Editor - the engine is just loading and running levels, all logic and gameplay scripted or set by the editor (nothing is hard coded)
Graphics - real-time GI, HDR, filmic tonemapping and filmic DOF , sun effects, flares unlimited lights and shadows! (every light cast shadow) and more...
UI - script based dynamic UI system supporting any resolution.

* where can i see screenshots, videos?
soon i will post screenshots of the project, and talked about few nice things i'v added into.

* do you need people to join in?
yep, basically we need:
art guys - concept, models, textures, animations etc...
sound/music guys to do sound effects and music.
so if you know someone, feel free to contact me.

i'v you have questions you want to ask, feel free...
cya

Sun Lens Flare

2011-08-15T01:10:00.001-07:00

hi
this time i added sun lens flare effect, if you don't know what i'm talking about, just read about it here
http://en.wikipedia.org/wiki/Lens_flare

or if you are lazy :) here is a picture shown this effect:

anyway, to create this effect, what you really need is few things:
1. couple of flare images
2. light position in 2d (screen space)

1. this is simple, just google on it, and you'll get some nice textures... (you can also use photoshop)
2. take you sun light position and project it into screen space, check z to make sure the light isn't behind the camera.
after you have this 2d pos, you need to create 2d direction vector pointed to the center of the screen, and place the flares from 1 in a different color/sizes along this vector.
that's it.
one thing to note is that flares do not disappear immediately when occluded, they basically stay visible and fade away very nice and smoothly (also when they become visible), thats because these flares created from a very bright light sources.
to achieve this kind of effect, what we really need is a way to count how much the light is occluded.
from this info we can compute a scale factor between [0..1] and scale the lens color so they fade in and out smoothy.
few options to use:

1. the simplest and naive way is to trace few rays from the light to camera eye and see how many of them passed and then compute scale factor from 0..1
pros: simple to implement.
cons: not accurate, can hurt performance.

2. texture masking, you render the scene from light point of view to small render target, lets say 16x16 (cleared to white), for every pixel passed you write black, at the end this texture will tell you how much the sun is occluded (the black pixels), to get the result from it, you can lock it out and count for the black/white pixels - not good idea, a better way is to render this texture into 1x1 render target (float point rt, and we will have to use 16x16 vertices for each pixel), we need to enable alpha blending to count the pixels. note that 1 in the 16x16 rt, could be counter for 256 times if all the texture is white (sun isn't occluded), but we need a value between 0..1 to scale the lens color with, so what we output from the ps, is the sampled pixel from the 16x16 rt scaled by 1.0/256.0 (16x16 = 256)
pros: better accuracy.
cons: not easy to implement, need hw float point rt, can hurt performace for big scenes.

3. use hardware occlusion query, just rendered some simple query mesh (quad,box,sphere) and count how many pixels passed, from this you can compute scale factor between 0..1
note that its a little tricky to use, you need a way to know the maximum pixels for the query mesh so you could compute the [0..1] scale factor, second, they can hurt your performance if isn't used right.
pros: very accurate, performance is very good if done right.
cons: need hw occlusion query support, can be tricky to do right.

here is a scren shot to show you the effect in action:

no lens effect

with lens effect

in my implementation i use option 3...
that's it for now, cya until next time ;)

Sun Shafts / God Rays

2011-06-12T09:40:00.000-07:00

hi

this time i talk about nice effect called: sun shafts/god rays/sun rays...
to save words explaining what it is, i found a nice picture that shows how this effects looks like in reality:

notice how the sun "enters" between the trees and block by others, this create the light shafts you see in the picture.
so how do we going to do this effect in real-time you ask?
well, very simple, good old demo scene effect called radial blur as post process effect will do the work (well, with a little help of some Gaussian blur)
so the main steps is:
1. compute light position in screen space (this is our sun light pos)
2. compute radial blur on our image, this is done by blurring the image using normalized pixel to light direction.
something like this:

blur_dir = (sun_pos_2d - pixel_pos) / NUM_SAMPLES
sum = 0
for i = 0 to NUM_SAMPLES do
{
sum += sample(image, uv)
uv += blur_dir
}
return sum / NUM_SAMPLES

this is just an example of the radial blur idea, keep in mind that in order to make the effect looks good you need to weight the samples to give you the best look that you are looking for.
3. combine both sun shafts result we got in 2, with our original image.
thats it.
here is some pictures to show the effect in action:

no sun shafts

with sun shafts

if you follow exactly by the steps i wrote, you probably need a lot of samples to get nice results, so here is few tips to make the effect fast and smooth:
1. try to down sample your image and apply the sun shafts effect on it
2. blur the sun shafts result with your favorite blur (should be fast enough)
3. because it a post effect, the effect will apply the sun shafts on all the image resulting shafts from none sun light pixels, to overcome this, you should mask out all pixels that shouldn't be effected by the sun shafts effect, techniques to consider:
* stencil buffer
* depth buffer
whatever fits you engine...

that's it for now, if you have any question, feel free to ask...
cya until next time

Bitwise Operators on Low End GPU's

2011-05-03T05:22:00.000-07:00

hi
recently i was needed to perform bitwise operators on SM 3, but as you know, SM 3- doesn't support it (only DX10 SM 4.0 and up).
if you try to write this line: (hlsl SM 3 for example):
some_var & 2
you will get error message saying: Bitwise operations not supported on legacy targets.
the technique i present here can be used for few more things (lighting, shading etc), but here i will show how to do bitwise ops with it.
i support: &, |, ^ (AND,OR,XOR) - more complicated operators could be used but these are the base.
the trick is to use a texture to store the results of these operators, and then to sample this texture and get the result.
a code to compute this texture will look like this: (assuming 8 bit range for AND op)
for i=0 to 255
for j=0 to 255
texture[i][j] = i & j
to maximize storage, encode different operators on different channels.
here is a sample texture that encode AND,OR,XOR in different channels:

bitwise operators texture: AND,OR,XOR

the way you use this texture in your shader looks something like this: (hlsl style)
float AND(in float A, in float B)
{
tex2Dlod(BitwiseOpMap, float4(A, B,0,0)).r;
}

NOTE: make sure you use POINT sampling, you don't want to filter the results in the texture, you also don't need mipmaps...

thats it, i hope you find this post useful...
cya until next time ;)

Post Anti-Aliasing #2

2011-05-01T10:04:00.000-07:00

hi
few months ago i'v read an article on intel research group called: Morphological Antialiasing.
this technique designed for cpu but with few tricks and hacks we can use it on gpu as well.
the algorithm consist of 3 main steps:
1. find discontinuities between pixels
2. identify predefined patterns
3. blend pixels in the neighborhood of the patterns in 2
1. simple edge detection on the image, using depth or color differences should do the work, keep in mind that you should encode edge type in you color channels so you could use it in 2, lets say red is horizontal edges, and g is vertical edges.
2. this is tricky, you basically need to identify few shapes: Z, U, L
see image below (grabbed from original intel article):

Reshetov A. 2009. Morphological Antialiasing. In Proceedings of High Performace Graphics

so based on the article, you only need to identify L shapes, as Z, U can be split into L shapes.
for more deep information please refer to the original article that can be found here:
http://visual-computing.intel-research.net/publications/publications.htm#Y2009

to identify L shapes there are few tricks, a simple one is to just follow the edges you mark in 1 and see if you get a match (few loops for each side: left/right/top/bottom and of course branching), if so you compute blend weights for these and continue to the next edges.
at the end, you end up with blend weights texture so you could blend the pixel to get the final image, you can use a the trick described in gpu pro 2, they encode the final weights in textures and sample it.
btw: if you have ATI HD 6850+ you have built in support for that, so no need to worry, for consoles you may want to worry a little ;)

this technique isn't simple to implement as a first shot, i tried few algorithms and techniques before i got this thing working.
after seeing the demo from gpu pro 2, i'v got to say i was impressed by the speed of their implementation so i put some tricks into mine as well to get the missing cycles :)

optimization tip: when doing edge detection pass, use the stencil buffer to mark these pixels, then in the next step, use the stencil apply your "massive" shapes/blend weights shader only on edges pixels, this way you won't waste power on irrelevant pixels

here is a few screenshots of the main steps and result:

Edges Detection with encoded edge type using image colors

Blend Weights

Without MLAA

With MLAA

Without MLAA

With MLAA

as you can see, this technique have very good result.
extra: few other techniques you should check:
* GPAA - show it at humus
* FXAA - nvidia sdk 11 (looks pretty good)

cya until next time...

Adding Vegetation

2011-03-20T11:31:00.000-07:00

hi
one of the thing i always wanted to add is vegetation, tree, weeds, grass etc...
in a nutshell, to support all kind of vegetation you need to have few things:
1. some app to generate the content, plant model, textures etc.
2. engine supporting geometry instancing.
3. extra (depends of scene size), engine supporting model level of detail (LOD)
4. extra (depends of scene size), engine supporting good outdoor culling.
1. this is very critical, having great app for generating plants is a must, if the model and textures isn't quality enough, the best code won't do much... i checked some apps, and i want to tell you that if you have some $, speedtree is the way to go, checked it, love it...
2. if you are going to render plants, you won't render one tree with 1x1 meter of grass, you probably want to spread it all over a 1x1 km terrain, so you are going to render hundreds of the same plant with different properties or such, so you don't want to kill your gpu with 20000 draw calls... unless real time performance isn't an issue for you.
for me performance is critical so i'v implemented instancing support for each plant type.
3. if your scene is large enough you need to consider LOD support, there is not need to render full plant geometry from certain distance, you probably won't notice if its real geometry or simple billboard, but your gpu will, so consider replacing you full model with low model or even quad when distance to eye pos is large enough.
i added auto lod support in the engine and use it also for plants (maybe i will post on it next time)
4. if your scene is large enough and you have massive amount of plants, so you already know that its a good idea to cull your data.

anther thing, because we are using instancing on the same model again and again, its a better idea to break symmetry when rendering the plants.
you can place them with different rotation and apply random motion for each plant (in shader).
here is a screenshot of a test scene:

vegetation, sun shafts and dynamic atmosphere

cya until next time...

Lens Effect / Bokeh - Getting Into Details

2011-01-30T03:56:00.000-08:00

hi
last time i talked about lens effect/bokeh, this time i talk about how to do it using FFT with information of how to implement it on the GPU.
i will not get into the theory of FFT, if you want to, check out this:
http://en.wikipedia.org/wiki/Fast_Fourier_transform

what i will explain here is how to do image processing using FFT and how to achieve a lens effects/bokeh filter.
if we have an image and we apply FFT on it we get this image in something called frequency domain.
after applying FFT every pixel in the image have its own frequency in the frequency domain that compose of a real and imaginary parts (a complex number)
after getting the image in the frequency domain, all we have to do is to decide which frequencies we want to "filter" out and then, apply the inverse FFT to get back to our image domain again, without the "filtered pixels"
that's the main idea.

nice thing with FFT is that its separable, what this means is that to apply FFT in 2D, we can simply apply 2 1D FFT, the first one goes on the rows (horizontal) and the second one goes on the columns (vertical) of the result.
another thing to know is that transforming N points can be done with two N/2 transforms, that is a dived and conquer approach, which helps to reuse computations.
so knowing that, we will use a divide and conquer algorithm called butterflies:
more info can be found here:
http://en.wikipedia.org/wiki/Butterfly_diagram
http://www.cmlab.csie.ntu.edu.tw/cml/dsp/training/coding/transform/fft.html

you can see really nice diagrams which helps to understand how it is works and how we can create and encode indices and weights for doing FFT on the GPU using textures and ping/pong method.

so if for example we have N=8 points to transform, we have log2(8) =3 steps of butterflies to perform, beginning with computation on four 2 points DFT, then two 4 points DFT and finally one 8 points DFT.

so, assuming you understand what the butterfly does, the steps to do it on the GPU is a matter of doing those steps:
1. create 2 textures (render targets) used for the ping/pong operations, those needed to be with high precision float point because the pixel on the frequency domain is a complex number with greater range than the pixel in the image spatial domain.
2. encode indices & weights into texture (also high precision)
3. do log2(Width) horizontal butterflies steps (using RT's from 1 and bf from 2)
4. do log2(Height) vertical butterflies steps (using RT's from 1 and bf from 2) on the result from 3
lets call those steps GPFFT
note: the log2 in steps 3,4 - this needs your image to with power of two size.
so how all of this nasty things helps us to do image processing on an image? and where is the bokeh stuff?
so here is the beauty:
suppose we have 2 images, one of them is our kernal, lets call it K, and the other is our source image that we wish to apply the effect on, lets call it I
apply GPFFT on K,I (transform them into frequency domain), multiply them together (complex multiply, remember we are using complex number in this domain), and then apply inverse GPFFT (to inverse transform the result) on the result to get a new I' convolved with K.
and that's it, all it matter is how your K looks like (the size and shape: triangle, square, octagon etc) and whats I.
as for bokeh/lens effect, basically it is working on bright pixels so simply filter the brighter pixels from your image with some threshold into other image (this is your I) and do the process on it.
this method works on low systems, DX9 with MRT support.
we can optimize the algorithm a lot using DX11 compute shader and get rid of the log(N) passes of steps 3,4 and perform only on pass each.
hope this post didn't make you headache' i'm starting to get one ;P
that's it for now
cya next time...

Lens Effect / Bokeh

2011-01-04T13:56:00.000-08:00

hi
this time i'm attacking a problem related to lens blur effect or bokeh.
as you know (or don't) real time app such as games mimic lens effects with blur filters that applied on some image (scaled or not, depending or the app)
until now, blur could be done with few methods/filters such as gaussian, poisson disk, bilateral and etc depending on the problem you want to solve.
for example:
1. Gaussian could be used for blurring image that need a smooth look, like lighting and such...
2. Poisson disk blur could be used to smooth shadow mapping as it faster than 1 and basically produces nice result.
3. Bilateral blur could be for smoothing SSAO, because it can take into account few vars (like normal, depth) when doing the blur and reduce bleeding.
ok, those methods used until now and rely on samples count.
more samples means nicer result but takes a lot of power and most of the time it doesn't really worth it...
what we really need is a filter that doesn't rely on the kernal/filter size and mimic real camera lens effects without killing our app and can achieve this:

image taken from wiki under 'bokeh'
Coarse bokeh on a photo shot with an 85mm lens and 70mm aperture, which corresponds to f/1.2

the circle shapes is what we need to achieve! (or any other shape we want).
how we get this in reality: when we use smaller f in our camera, out of focus areas/points blurred into polygonal shape formed by the aperture blades.

somebody did this in real time or what? yes, Futuremark group in their new 3dmark 2011 benchmark (the underwater demo... amazing stuff...) and i think me 8p
lets see screenshots:

original image

increase filter size

and here is the hexagon shape...
note that any shape could be done with no cost!

and a video...

real time video of lens effect / bokeh

with the new gpu's features and dx11 we can do it in real time, right?
well... yes, but we don't really need dx11 or 10... ;p

what we really need the heavy duty guns! Fast Fourier Transform or FFT in short...
cya until next time...

Deferred Iterative Parallax Mapping

2010-12-02T12:35:00.000-08:00

hi
the title name is a "bomb" but its nothing too fancy...
just added parallax mapping using iterative scheme, this method uses few iterations of parallax mapping in order to get more accuracy.
for those who doesn't familiar with parallax mapping, here is a short description:
1. you need two texture maps: height, normal map
2. start from current texcoord used to sample your diffuse map (for example) and offset it by the height value (scaled and biased) of the current pixel in the direction you view direction (in texture/tangent space)
3. sample your diffuse map with the new texcoord.
iterative parallax mapping does just like that, but for X iteration, every iteration tries to move one step closer to more accurate solution.
don't get me wrong, you are not going to get better solution than a ray traced methods (depends on you viewing angle, at some angles you can't even tell the difference), but this method cost almost nothing, especially if you can save your height map values in normal map alpha channel.
also num iteration can be changed depending on surface properties and such.
here is screenshots thats shows it in action using deferred method:

without parallax

with parallax (4 iterations)

OIT - Order Independent Transparency #3

2010-10-27T02:55:00.000-07:00

recently i needed to do OIT in DX9 HW and as you know (from my previous posts), i don't have the same access i have in DX11 (i can't create linked list per pixel and do the sorting after), so what i can do is simple depth peeling...
few words about depth peeling: depth peeling works by peel geometry with specific depth value, so to create OIT we can peel geometry starting from the nearest depth (to the camera eye) going to the farthest depth, each step we peel few pixels and store them to in separate RT, then we composite those RT's in back to front order to achieve the right transparency order effect.
so how do we implement that?
well, from what we can see we need color RT to store the result, also a depth buffer so we could compare pixels depth against, we also need a "second" depth buffer so we could reject pixels that already peeled/visited.
1. color RT supported by DX9 and upper
2. first depth buffer, also supported but...
3. second depth buffer, not supported but...
so we have issues with 2,3, to implement pixel depth compression we need to have the ability to pass depth buffer into the pixel shader so we could do the compare ourselves so we could reject already peeled/visited pixels, BUT DX9 doesn't even let us bind depth buffer as texture (even if i'm not writing to it - can be done in DX10, but we need DX9), so we need a way to emulate depth buffer that can be bind as texture and act as depth buffer.
to do this we can use float point RT, for the OIT we will use 2 float point RT, the first one used for first pass, second for the second pass, then the first again and so on, this is our ping/pong depth RT's.
the reason we need this kind of ping/pong RT's is to peel the correct layer every pass.
for example:
to peel the first layer we need empty depth buffer, the we render and store it to our color RT
to peel the second layer, we need to use the depth buffer from the first pass, so we could ignore the pixels handled at the first layer
to peel the third layer, we need to use the depth buffer from the second pass, so we could ignore the pixels handled at the second layer (and first layer)
and so on... you can see that we don't need more then 2 depth buffer to manage all those passes.
ok, so now we can peel layers with our depth buffer RT's, but how can do OIT for more than 8 layers? (we can only bind 8/16 texture), well here comes the reverse depth peeling (RDP) technique, instead of peeling in front to back order, peel with back to front order, so every time you peel one layer you can immediately composite it to the back buffer, so only one color buffer needed.
total memory needed could be one of those:
1. 3 RT's, two 32 bit float point and one RGBA
2. 2 RT's, one 32 bit float point for both depth buffer, and one RGBA
NOTE: in deferred rendering you can get rid of the RGBA buffer.
so as you can see, total memory is very low.
after all the talking, here comes a video that shows RDP in action:

simple planes shows the idea, this model doesn't need per pixel sorting but it shows that the algorithm works well.

Teapot model - needs per pixel sorting

NOTE: technique implemented in render monkey, the video shows very simple mesh containing 8 planes so it will be easy to see the effect.
each peeled layer render with small alpha value, so you can see how layers blended when you see through all layers (you get the white color)
some performance info: RM window 1272x856 ATI 5850 - 270+ FPS
thats it for now, cya...

Post Anti-Aliasing

2010-10-10T10:49:00.000-07:00

hi
recently i'v added few post effects and i thought i need some AA solution to remove those jaggy edges.
traditional AA solution have its quality, no questions but it have some drawbacks:
1. deferred or semi deferred need special care and will need DX10+.
2. needs more memory
3. eat gpu power
i guess there is more but this is enough for me to consider some other solution, not the same quality but better than none.
so what i did is pretty simple:
1. run edge detection
2. run post AA which samples 4 pixels and use the value from 1 to know if its an edge or not, if its an edge i output the filtered pixel, if not i output none filtered pixel.
the heart of the algorithm is 1, what i did is taking few neighbors pixels and check for a big change in their depths/normals (for normals i check angles, for depth i check the gradients from center pixel)
again, very simple but i think it does the work, very fast and its generic for xbox,ps3,pc...
here is few screenshots that shows you the process

Without Post AA

Edge Detection

With Post AA

Deferred Decals

2010-09-10T09:48:00.001-07:00

hi
this time i improved my decals system.
one of the things that make decals looks real is the way it interact with the environment lighting and how it clipped against the world geometry...
the old decals system has good clipping but it was rendered using a forward rendering, so it didn't interact with environment lights/shadows which look very strange when you put decals in a dark room with small candle light.
another thing is, decals on dynamic entities, which need to take into account fast clipping against those entities.
to fix problem 1, i replaced the forward renderer into a deferred one, which rendered the decals into two render targets (using MRT support), one rt for diffuse color and the other for normals, then in the rendering pass i blend the diffuse/normal with surfaces diffuse/normals to get the final image.
to fix the second one, i change the way i create collision data, each object in the scene that needs collision detection keeps handle to collision tree which used to get the needed data when doing clipping, collisions etc...
that's it for now, i think the result are pretty good...
here is a screen shots that show it in action:

wall rendered without decal on it
the small picture in the top left shows diffuse term of lighting

wall rendered with decal on it
notice the bump map generated from the decal normals

physical entity rendered without decal on it

physical entity rendered with decal on it
note that when i "shot" the decal on the box, i apply impulse on the box so it moves a little

Editor Updates

2010-08-05T12:57:00.000-07:00

hi
last weeks i worked hard to make the editor useful in the meaning that i actually build full level with physics, lights, logic and all game play feature i could and would want to have.
to support future feature that i might want to have but i can't really think of them right now, i added something i called "generic entity system", this system basically allow me to define any entity i want by specifying entity params which also define the ui elements needed to define and set those params, i also support serialization, which load and save those params automatically.
params can be scalar, vectors, color, file, string, multiple selection values etc...
with the system, i define the main entities that allow me to build full working level:
1. light entity - define lights in the scene such as: point/spot/sun/dir light
2. player entity - define player start position when the level is up
3. physics constraints entity - define physics constraints such as spherical/hinge/fixed etc.
4. fx entity - define special effect using my effect system
5. model entity - define geometric model to be placed in the scene

the last time i wrote about the editor is said that i added boolean operation which helps me to build brushed that i could build the level from, after long thinking i decided that it wont be good in the long term as brushes i good for old school bsp and stuff like that.
the things is my engine doesn't do any assumption about the scene is being static, this means that everything can move and the engine will handle with no problem.
as for the visibility issue, i want to replace my portals with hierarchia z buffer occlusion culling (but this will be in another post...)

when i finish to work on the scene, i save it as a .map file, this is very similar format to the old quake map because it fit my generic entity system and all the entities written into it will all the needed params. it also very easy to parse it, used to load q4 maps, so i fit like a glove ;p
anyway, here is a screen shot that shows my progress:

the left toolbar is my action bar which i create all entities, manipulate scale/rotation/position.
the right window is the entity property grid which allow me to modify selected entity params.
the button window is the log windows, where i write all the action and info to the user.
that's it for now, cya...

Multiple API Render

2010-06-08T05:32:00.000-07:00

hi
recently i didn't post a lot because the engine was down, not all things worked because replace the current render system with new one.
my engine use dx9 api for the rendering and when dx11 was out i wanted to integrate it, to do that i had two options:
1. replace all dx9 related code with dx11
2. create generic render system to support any render api (dx9, dx10, dx11, opengl, whatever)
after doing some thinking i got to the conclusion that option 2 will be the best.
option 1: good if i want dx11 only (win vista+) and supporting only dx11 features, if in the future ms decide to change few api and add few shader stages, this will be a mess to change and add those.
option 2: take some time to do, but will support anything you need and will need in the future (its all about how you design your api)

now i will describe few things i think is important to know when implementing option 2 with dx9, dx11 support (in case you will need to do it for some project).

the biggest challenge was to replace my shader system, i mainly use the dx effect framework because it seems like the best choice and very easy to use.
one of the features i use in techniques to apply different shaders, for example: when you generate shadow maps for a fench you want to reject pixels using alpha value sampled from a texture, and when you render opaque surfaces you don't, so you need 2 techniques, one for each.
features that the new shader system must to support are:
1. support any shader stages we have now and new ones that will be added in the future (if any), also it must support the technique feature so i won't need to change a lot of the code that already assume techniques.
2. keep track of constants, sampler states, textures etc, so it won't set the same constant again and again when it already set, or set texture when it is already binded.
3. ability to compile shaders for different api (for example: dx9 shader - shader model 3, and dx11 shaders - shader model 5, or opengl glsl shaders)
4. easy to use - setting shader data must be easy and understandable from the name of the functions.

supporting 1: done using file of each stage (.vs, .ps, .gs etc)
supporting 2: done using few variables that store the last state (dirty value vars)
supporting 3: done using a script that defines every technique and the stage shaders, this script supports the define macro so i could select which stage shaders and other defines to load and set depending on api macro, for example:
#if DX11
code block
#endif
the code block will be parsed only if the current renderer is dx11.
note that this script also solved the techniques issue because it contain the techniques that defines which shaders to bind when the technique is set.
when i create a shader from this script the shader is actually a multi shader as it contain few shaders and not one (each technique contain shader per stage), so this script is my multi shader script definition.
supporting 4: well, this is the easiest i think...

the next challenge was state management.
from dx10 all render states replaced with state objects: rasterizer, depth-stencil, blend and sampler state object. so you can't call SetRenderState anymore.
to solve this issue, we can do few things:
1. emulate dx10+ state objects using dx9 style render states (SetRenderState functions)
2. emulate dx9 render states using state objects.
1. in some cases you want option 1, in fact i implemented this at work where all the developers used to work with SetRenderState style.
to do this, you can use hash for the state object and create it on the fly when it's not in the hash.
2. this is what i did in my engine, 99% of the states is known in advance so no need to create state object on the fly, for the other 1%, when it happens, there must be a new object/mesh that was loaded so his material was loaded too, and all states objects was created (on the fly).
each state is tracked and managed so there the state will be state only once (when needed)

another thing that took a lot of time is to convert the dx9 shaders into both dx9/11 shaders using files each stage.
instead of duplicating the files and rewrite them using dx11 functions, i added render system define (DX9 for directx9, DX11 for directx11 etc) which is added automatically for each shader i compile and use it to know which function to use, for example:
#if DX9 == 1
col = tex2D(diffuseSampler, UV);
#else
col = diffuseTexture.Sample(diffuseSampler, UV);
#endif
when i need to recreate specific shader stage for DX11 only (for example: using tessellation), i write the shaders (add domain, hull shader files) and add their filenames the multi shader script (the same can be done for optimizing shaders to use the new dx11 functions, for example: blur and pcf can be optimized using gather function)

for now, the render system supports only dx9,dx11 render paths, opengl can be added by implementing the renderer functions.
note that i kept dx9 renderer path so i know every thing was implemented right in dx11 renderer, this is mainly to validate every function i wrote in dx11 renderer.
everything renderer with dx11 renderer must be the same (using only dx9 features) using dx9 renderer.

thats it for now, i hope will find this info useful, if you have any question on topics i didn't or forgot to cover, feels free to ask...
cya

OIT - Order Independent Transparency #2

2010-05-10T03:08:00.001-07:00

hi
recently i'm very busy converting my engine into cross renderer supporting both dx 9,11 and maybe gl in the future, so until i will finish it and have some nice features to show here is a complex & large model (50k) using OIT from the last post.
note that this scene isn't complex compared to the simple 31 planes in terms of solving the OIT problem (because the fragments counts in the linked list is low => less pixel work).
for the ones who interesting in fps: 1024 x 768 with ati 5850
1. planes scene: avg 180
2. this scene: avg 230

N dot L

Output of OIT

Fragments Count

OIT - Order Independent Transparency

2010-03-31T10:32:00.000-07:00

hi
recently i'm checking dx11 features and one of the nice thing he have is read/write/structured buffers. (unlike shader model 4 that have read only buffers)
read/write buffer (or RWBuffer) is just as it sounds, a buffer that we can use to read from or/and write into.
structured buffers (or SB) is a buffer that contains elements (c style structs), for example:
struct MyStruct
{
float4 color;
float4 normal;
};

then, we can use it like this:
StructuredBuffer mySB;
mySB[0].Normal = something
New Resource Types
RWSB have another nice feature, it have internal counter that we can increment/decrement its value.
those buffers can be used to create very nice effects and really fast (if used wisely).
this time i'm using it to solve some old problem in computer graphics:
order independent transparency (or OIT), if you don't know what i'm talking about then i suggest you should google on it...
in dxsdk you can find a sample called OIT, this sample uses compute shader to solve this problem, the sample show you how you should NOT use compute shader! and just show you that its possible using it... this sample runs so slow that you better do a software solution for it ;)
one thing you should remember is: if you write your pixel shader good enough, you probably get better performance than using compute shader (with some exception off course)

anyway, the question i want to answer is: how can we draw transparent surfaces without worrying about the order?
there are few solution to this but every one of them have some drawback:
1. depth peeling - very heavy, even if using dual version.
reverse depth peeling is more friendly as it peel layers from back to front so we can blend immediately with the backbuffer and only use one buffer for it.
2. stencil routed k buffer - say goodbye to your stencil and allow you up to 16 fragments to be blended, for some of you its enough for the some its not an option.
3. dx11 method, based on the idea presented on gdc2010 by ati.
i will focus on 3 as its what i implemented and it doesn't suffer from the issues the other methods is.
the idea can be simplify into 2 main steps:
1. build - in this step we build linked list for every fragment that contains all the fragments that "fall" on this fragment screen position, i use RWBuffer to store the linked list head for that pixel, and another 2 RWBuffers to store pixel attributes (color, depth and next "pointer" to the next fragment in the list), those attributes buffers need to be big enough to contain all the fragments that placed at the same fragment position.
in this step i'm also using the structured buffer internal counter to get unique "id" for each fragment and use it to write/read the fragments attributes.

2. resolve - this is where we do the magic, here i just traverse the linked list stored in step 1, and sort the fragments, then i manually blend the fragments.
note that you need to sort the fragments in place! that means your linked list should be accessed a lot or... you can simply fill a bunch of registered, and sort them instead.
tip: use the [earlydepthstencil] attribute to skip pixels that aren't needed to be processed.

here is a screenshots that show it in action using 32 registers (max of 32 fragments per screen fragment)

31 transparent surfaces

debug mode that shows the fragments count in each of the fragments linked list
black means 0 fragments, white means 32 fragments (num_fragments/max_fragments)

yes i know, this 32 surfaces can be easily sorted and rendered correctly without the GPU, but here i'm not sorting and not worrying about the order! i'm just rendered them as one batch, maybe next time i will show complex geometry... ;)

Real-Time Destruction/Fractures

2010-03-15T11:45:00.000-07:00

hi
in the last two weekends i'v been working on real time destruction/fractures on 3d models, i always amazed by havok destruction demonstration and even more by red fraction guerrilla.
unlike havok physics/animation, havok destruction isn't free, but i really wanted something like that in my engine.
after few days of thinking and googling, i got few options on how to implement it:
1) get into some really nasty physics using fem model, build tetrahedrons that fit to the model and use it to know which part do i need to break.
2) voxelize the model and use the voxels to know which part do i need to break.
3) clip the model by a plane.
every option need to take care two things:
1) the render model which is the model that you render and contain valid tnb vectors, mapping, position etc.
2) the physics model which you use to do collision with.

the option i implement is 3, because it is very fast to implement, doesn't need to preprocess the mesh like option 1 and does not restrict you with same fracture size like option 2.
also it doesn't take extra memory to store data per model, everything is computed in real time, so if you are not breaking the model it is just like any other model in the scene.
if you break it, it will take the memory needed to store fractures data and that's it.
as you all know (or don't), nothing comes for free, more memory means less cpu work and less memory means more cpu work.
this is always the dilemma when implementing an algorithm, but in this case its not because you can't really preprocess the fractures because you don't really know where the player is going to shot the model.
some games generating fractures in advance and when you shot on the model, the closest fractures is detached from the parent model, in my opinion its doesn't do the work like the real thing and again, memory could be huge if you split the model into small fractures.
another thing to take into account is how many time do you have to implement it, if you don't really have a limit i think you can find some cool idea...
anyway, option 3 can be simplified in few steps:
1. determine the model that you hit, call it M (your physics engine should do the job)
2. split M by a plane into two parts, negative and positive, call them N and P
3. close the holes of N, P using triangulation algorithm (ear cutting or something similar), if you assume convex shapes you can simply build a fan to close those holes very fast.
4. apply uv mapping for the faces that closed N,P holes.
5. build physic shapes for N and P.
thats it, the catch is to do those steps fast!
here is a video to show what i'v done so far, note that in the video step 4 is disabled and you see the same color (all vertices map into 0,0) that's because i need to add option to give faces from step 3 different material so it will look good and not using #1 texture i used in the video

DX11 Hardware Tessellation

2010-02-24T02:51:00.000-08:00

hi
recently i got a new job and i got new radeon 5850 which supports dx11 so i stated to check out those nastly new dx11 features, and let me tell you that: hw tessellation is COOOOL.
little info, dx11 tessellation works with 3 new stages added:
1.) the hull shader (aka HS) - get [1..32] input control points of the patch and responsible to output [1..32] new control points, it is also output constants which control how much to subdivide each patch.
2) the tessellator (fixed-function) - get the output of the hull shader as input and generate the new points, you have no control on this stage.
3) the domain shader (aka DS) - generates surface geometry from the transformed control points from a hull shader and the UV coordinates. the DS run once for each point generated in step 2, the input of DS is bary coords of the point on the patch so you could easily interpolate vectors other than position and uv.
HS supports 4 different partitioning methods, topology and few more things (check out dx sdk if you are interested on the tiny details)
so why do we need it if we already have geometry shader? well, geometry shader is programmable and generic in a way that you can do whatever you want in it, such has point sprites, fur, object silhouette and more but its not free and not optimized for things like tessellation. in dx11 you have dedicated unit for doing tessellation so the speed can't even compared with gs.
here is a video that shows dx11 tessellation with adaptive tessellation:

note that the geometry passed is simple 4 vertices quad.

Atmospheric scattering

2010-01-23T05:14:00.000-08:00

hi
this time i'm showing atmospheric scattering using oneil atmospheric scattering from gpu gems 2.
to implement it correctly i started with cpu based solution which computed all the nasty integrals on cpu and store it in a texture, this cpu solution used so i can debug and fix issues with the integral computations.
after everything works on cpu i convert it to gpu version and use it as default.
this texture is then mapped on a sky dome where camera eye is at origin.
clouds are procedurally generated using few noise textures, they also change their color based on sun direction.
for now i'm not taking into account sun lighting, shadowing this is simple solution so the sky wont look empty.
here is a short video to show it in action:

Stable Shadows

2009-12-21T11:48:00.000-08:00

hi
this time i worked on stabilizing the flickering when doing cascaded/pssm shadow maps.
if you had the chance to do cssm/pssm you know what i'm talking about, you can't ignore those flickering when you move your camera (panning/rotating).
the first game i know who solve this problem was kill zone 2, nothing to say about this game!
i'v a lot of respect to those guys :)
anyway, if you don't know what i'm talking about and what those flickers are, let me explain (i can't promise you will understand it but i will still try...)
i will talk about cssm from now, the same idea works for pssm.
when you render your shadows you are creating/generating your shadow matrix whenever the view changes (your camera view), if this change is very small and almost smooth you are fine but if not, the shadows boundaries are rendered or more correctly rasterized differently which cause visible flickering of the shadow edges.
the more area your farther shadows (farther cascaded) will cover the more you will notice it.
ok, get the idea, how do i solve it? well, i split it into 2 cases:
1. rotation problem
2. moving/panning problem
case 1: can be solved by eliminating the rotation of the shadow maps when our camera is rotated (this cause our shadow map to be rasterized differently) , we can use smallest enclosing sphere of the cascaded frustum and use it to generate our cascaded matrices, using the center as the lookat target and the radius to generate the orthogonal projection matrix.
this assure that your shadow maps will not rotate with the camera.
case 2: can be solved by canceling the movement in sub-texel level, this can be archived by multiplying a fixed world position with our cascaded matrix, round the result and see how much it differs from your fixed world position, note that this must be calculated in shadow map space in order to get the right offset. we now use this offset to translate our cascaded matrix.
note that my implementation is different, i use bounding box slice selection and different flickering solution which is very sable (can't give info about that because we are working on a big project so i need to keep few tricks inside)
here is a video to show the translation of all those words in action :)

The resolution of the shadow maps are low to make the problem more noticeable

Revisiting Shadows Methods

2009-11-07T23:28:00.000-08:00

hi
shadows are always been an issue when it comes to real-time app, there is no such thing a perfect method for shadows, until now i choose vsm for shadowing, but the more i work with them, the more i get the feeling its great for "demos" not for complex scene where shadow complexity is high , yes i know about the bleeding issues and how to minimize them, but there are scenes where you need to minimize them a lot and at the end you just get simple shadow map, and the softness you applied by blurring or such isn't noticed so much.
because of this i started to investigate few other methods, and i must say i got really good results:
a word about poplar shadowing methods:
1. sm - old school shadow maps
2. pcss - percentage closer soft shadows
3. vsm - variance shadow maps
4. esm - exponential shadow maps
5. cssm - cascaded shadow maps
6. pssm - parallel split shadow maps
as much as it will sound odd, i choose method 1 for indoor shadows, yes, old school shadow maps with poission disk and jittering gives me very good results.
while method 2 sound really good, its not applied very well for every scene, it also not free in terms of performance.
anyway, i created 16 samples of poission disk and generated jitter texture which i passed to the shader. the poission disk can be tuned for more samples or less, the jittering can be tuned for more jitter or less.
because i use two shadow maps, static for static shadows and dynamic for dynamic shadows, i managed to optimize this by using one texture with offsetting.
method 5,6 used for outdoor scenes, i use pssm...
here is few screenshots:

complex shadows from 2 light sources
note that vsm will fail below the platform (light bleeding) and the fence details won't be visible even with 1k shadow maps because the compassion is based on probability and could be failed where simple compassion will pass.

complex surface casting shadows

zoom in on shadows

before you said its not so impressive, note that the 2 light sources using only 8 samples on 1k maps, the barrel is dynamic object which means the dynamic shadow map is updated and merged with static shadow maps, the fence have very tiny elements, and it all runs on my old g6600, so i think its pretty good ;)

Maya Exporter

2009-09-30T04:50:00.000-07:00

hi
this time i talked about the maya exporter i wrote so i could defines whatever i want where i want and the why i want, without sticking to id md5 format.
when you want to create maya exporter you have few options:
1. create plugin dll
2. create exe application and call maya functions
3. create mel script
i choose option 2 because it more easy to debug and doesn't need your maya run everytime you want to export and test something, the drawback is the you don't go to file menu in maya, select export and see your new format.
option 3 is also good if you know mel script, but doesn't allow you to access everything in maya, and i don't think you have tools to debug it like in dev studio.
anyway, the new format called OGE, this format designed to support both static and dynamic models.
the structure of this format looks like this:
MESH
mesh_info - vertices count, texcoords count, normal count, weight_count (if animated), faces etc...
material_info - the name to material defined in .mtr script
mesh_data - vertices, normals, texcoords, indices etc...
anim_data - weights, skeleton data

global for all meshes
anim_data - anim sets count, fps of each set, joints animated and their anim data

the reason anim_data is shared between all meshes is because each mesh could have different influence on specific joints and those have it own skinCluster, because i don't want to manage and control animation controller per skinCluster, i'm merging those skinCluster's data into one skinCluster data and export it as it was single skin for the whole model meshes.
each of those data is optional and could be selected from the exporter ui.
here i a screenshot of the exporter:

options:
1. convert from right to left handed (maya uses right handed, engine uses left handed)
2. convert from Y up to Z up (engine uses z up)
3. export position, normals, texture coordinates (possible to invert v coord)
4. export materials
5. export animations, possible to set animation name
6. at right i have meshes list, this list allows me to export only the meshes i select. skinned meshes will be shown with '(skinned)' keyword after their name.

the reason i have the option to overwrite animation name is that i can use the exporter to create animation files (containing only animation data without geometry data).
the model could be created at first with one idle animation (or without animation at all), and at later point i can add more animations to it.
also, if you have few characters with same skeleton, you don't want to duplicate all animations, you just want to have shared animation folder containing all animation files for those characters.

New Animation System

2009-09-29T08:05:00.000-07:00

hi
its been more than a month since i updated this blog, the reason is that i just didn't save time for taking screenshots/create a video and update the blog.
so here i'm finding few minutes to write about the new things i implemented, hopefully updating with screenshots/videos on the next post ;)
list of things i'v working on:
1. new animation system
2. abandon md5 file format and use internal format (writting exporter from maya)
3. real-time atmospheric scattering
4. HDR
5. read shaderx6 :)

the first thing i wanted to rewrite for along time is the animation system, calling it animation system is a nice joke, but still it could play different animations for different parts of the model, do some kind of blending and at the time it was enough.
but the time is come and i wanted more advanced system which allows me control and create animation on the fly, adding sse and such...
the new animation system based on blend trees, what it means is that you can apply operations/operators on trees and get a new tree as a result.
the system designed so the operators works just like in math, you apply operator get a result and apply another operator on it and so on...
so how this is going to help with animation?
when doing skinned animation, you need few things:
a. model with weights
b. bind pose skeleton
c. animation data for that bind pose skeleton
this skeleton form a tree, so you can define the operations in term of animation and you are set.
you can thing of animation as a list of skeletons which defines new position & orientation for this skeleton or just list of that skeleton with different poses.
the operations i'm using is:
a. subtract tree A from tree B - useful for separating certain parts from specific animation, for example: you have walk animation which moves both hands and legs, but you want to separate it to two new animations one that moves on the legs and another for moving the hands.

b. multiple tree A with tree B - useful for merging two trees to form merged animation, for example: merging the two animation created in a and get the original animation (the one which moves both hands and legs)

c. transition from tree A to tree B - the is by far the most useful operation, this create a transition from one animation to another by setting transition/blend factor [0..1], what this means is for blend factor 0 tree A will be the returned, 1 tree B will be returned, for 0.5 for example a tree between A and B will be returned. so why is it so useful? well imagine you have a character that have walk,run animations and you want to play walk animation for velocity under 10 and run over 50, but what happens between 10 and 50? well you can use the velocity to compute blend factor to be used to create smooth transition between walk and run and run to walk.

when setting animation is just a matter of setting list of skeletons, but when implementing you don't want to switch from one skeleton to another in one frame, what you want is to create smooth transition between one skeleton to another, for example: skeleton from frame 1 to 2, 2 to 3, 3 to 4 and so on... the result is a skeleton inbetween old frame skeleton and current frame skeleton, this skeleton used as input to other operations.
also, the animation system works hand by hand with the new engine format 'oge', used for both static and animated models, this format created using the new exporter i wrote.
next time i will write about the other things i worked on...
cya

Deferred Lighting

2009-08-20T03:58:00.000-07:00

hi, quick update
last crytek presentation they show their deferred lighting system, and i thought.. hmmm, i implemented those things few months ago, doing test and stuff to see if its good, but i didn't finsih all the tiny things that make it unstable (i wanted to focus on things other the graphics & effect), so last week i finished handling those tiny things and here is the result:

87 dynamic lights (yes, they all cast dynamic shadows)

Undo/Redo System

2009-08-02T05:13:00.001-07:00

hi, last week i implemented undo/redo system.
as you all know, editing software without undo/redo system is pretty useless.
i think undo/redo system is a must in any editing software, i think the system is very simple and easy to implement (depending on the app, but still) so i can't see any reason why not supporting it.
ok, so explained why, so now i explain (in general) how i added it to my level editor, i will explain the idea so for implementation detail just ask...
the more generic your system is (in term of managing editable objects) the more easy it become, here i describe a system with user define max size for undo/redo (because of memory issues, you don't want to consume more than needed).
you need to support few things before implementing it:
1. you have to be able to take a snapshot of current scene state, meaning, every editable object must be stored in a way that could be restored later.
2. deque container, i use deque so i could keep X oldest elements (used to limit memory used by the system), basically every container with option to add and remove from both direction will be fine.
after you support those its just a matter of identify the places you want to support undo/redo, and wrap them with Undo_Start & Undo_End or whatever name you want.
so what those functions do?
1. Undo_Start - take a snapshot of the scene and save it in undo deque, i make sure to store a flag (lets call it done) which says if i called Undo_End or not, and i checked this flag right after i entered this function. this to assure i wont try to call Undo_Start inside Undo_Start/Undo_End block (prevent nesting), the function also gets a string so i could name the operation i wrap, useful if you want your console to output text like: Undo create new box, or undo delete...
2. Undo_End - checks if i started undo op, and set the 'done' flag to true
simple enough, so now we'll see how to perform undo/redo actions:
1. Perform_Undo - pop the head from the undo deque, push it to the redo queue, and restore the snapshot you saved, i also check size limits right after pushig new element and i its greater then a max size i defined i just pop from the tail.
2. Perform_Redo - pop the head from the redo deque, push it the the undo deque, and restore the snapshot you saved, also do same limit test as in Perform_Undo

note this system could be optimized in few ways, one place to start is the snapshot function.
how exactly you do the snapshot is depends on the app, but a simple method is to duplicate all editable objects in the scene.
also note that the snapshot needs to run ONLY once, just before you modifying the scene.
practical example:
if you have 'CreateNewBox' function that you call when you click on a create new box button on main toolbar, you need to wrap this function like this:
OnButtonCreateNewBox
{
Undo_Start("Create New Box")
CreateNewBox()
Undo_End()
}
if your system supporting those kind of scene changes, speed isn't an issue, but if you support dragging and manipulating object properties with the mouse (like scale/rotate/move vertices/faces) you need to do some optimizations.
that's it, pretty simple right?

Building Editor

2009-07-19T23:43:00.001-07:00

hi
i'v thought it will be good to leave id tools (their editor) because the more the engine improved the more id editor doesn't give me good options to set the new properties the engine supports, for example, i want to create constraints and apply them to brushes or entities, until now i added new entity call constraint_hinge (for example) and then i added properties to this entity that the engine can parse and set constraint values, but the editor doesn't know its hinge constraint and can't show me the angles in the viewport, i was better if the editor could draw/show me the angles in a more friendly way so i know how to set them correctly without running the engine and testing it.
this i just an exampe, so i started to build an editor (i always wanted to, but there was important things to do before...) which will support all engine features and option to add generic porperties to each entity (just like id editor).
the editor isn't going to be like crysis editor, its more like ut editor which you build the level from scracth or more correcty, from basic objects, detail object could be added as well.
right now i setup the basic ui, viewports, tools toolbar and basic manipolation on brushes such as move, scale, rotate, multi selection, also supporting copy/paste system.
the 2d viewports support zooming and snap to grid option, the 3d viewport allow you to conrol a free camera with the mouse so you can view the scene from any angle.
still have to finish alot of things but its getting better each day i'm working on it.
next time i will work on it, i think i will add undo/redo system, without it i think the editor is useless ;)
btw: no its not C# its pure c++ with mfc! uses the new feature pack which is great...
here is a screenshot of how it looks so far:

Havok Physics Demonstration

2009-06-20T23:48:00.001-07:00

hi
its been a long time since i posted anything, this is because i didn't have time to work on the engine... (busy busy busy)
so here is the video of few physics elements using havok i said i will post:

few elements shown in the video:
1. better and smooth character controller (no jittering, smooth jumping), every character/bot have its own properties set using a script.
2. moving platform interacting with character controller, platform push everything on it, which means if something goes on the platform it will move.
3. dynamic bridge using limited hinge constraint, i added options to add constraints via editor so this bridge is a simple brush with hinge constraint at the bottom, when the character apply enough force on it, it will fall down.
4. smooth movement using fixed time step and interpolation, almost every physics engine (physx, bullet, havok, ode, newton etc...) have the option to use fixed time step (i use 1/60), but what this means is when appication dt goes down 1/60 you will notice slow motion and moon gravity effect because the physics simulation is updating in the right time step (which is 1/60), to overcome this we need to check for this situation and apply few interations and interpolate between last and new physics objects states if current dt is not multiple of physics dt (for more info see my post on fixed time step or ask on the forum)
if you have any question feel free to ask http://orenk2k.forumotion.net/

Havok Integration Completed

2009-05-03T07:19:00.000-07:00

hi
its been a while since i posted anything, i didn't had time to code so...
anyway, i'v finished to integrate havok physics and got rid of any nvidia physx, i must tell you that i'm pleased with the results, havok rocks!
few features added:
1) anything could be physical, entities, brushes, models etc, that means i can create houses, towers directly from the editor and make it interact/break to parts very easy.

2) using fixed time step, this is huge win because by default havok/physx runs great when doing the step in a fixed manner thats mean you need to choose your dt and step the simulation with it.
why you need this thing?
a quick example, lets say we are using dt=1/60, that means your game need to be run at 60 hz so the physics simulation will be fine, if your game runs for 30 hz that means you get slow motion physics or moon gravity effect, if you game runs at 120 hz that means your physics simulation get andernaline and runs twice as fast as you intended.
consoles does not have this issues as the run in a fixed tv hz 25/30/60, but in pc it doesn't, so to fix this fast, you can turn on vsync and everything will be fine (at least for hardware that support it), but this way your renderer is limited to 60 hz! not so good, so the ideal solution is to run the renderer at high hz as possible and the physics at fixed hz, so what you should do is
to simulate the physics engine considering your fixed and dynamic time step and perform one or more steps of the physics simulation to achive smooth motion, using interpolator.
in our example (dt=1/60) if the game run at 30 hz we should perform 2 physics updates, if the game run at 5 hz we should do more, if the game runs at 120 hz we should do on update per 0.5 updates, meaning one update per 2 frames.
to deal with this i use accumulator and interpolation factor, the accumulator used to know how much updates we should do (you should set max steps so you wont freeze the game when the steps goes to high) and the interpolation factor used to interpolate between prev and current states of the objects, used when game dt isn't multiple of our fixed dt (if for example we are running at 45 hz and not 60 hz, we should perform 1.5 updates, but we can't do 0.5 update, so instead we do 2 updates and use 0.5 as the interpolation factor).
if you want to know more details on the subject please ask at the forum...

3) character controller interaction with physical objects, moving platform moves the controllers, the controller blocks other physical objects, other physical objects can push the controller, characters can push other characters and more.

4) character motion properties set by the script, so each bot can have different abilities, jump height, movment speed etc.

5) ragdoll are much more stable, angles limits are set very easy via scripts, havok have greate contraint for doing shoulder joint limits.

i probably forget few things but those are the main features.
i already have some scenes that shows those in action, but as usual i prefered to code few min more than capture a movie :)
as usual, if you have any question feel free to ask http://orenk2k.forumotion.net/

Moving to Havok

2009-04-05T03:14:00.000-07:00

hi
well, the day has come and i realize that nvidia physx isn't good enough for my game play physics, so i started to read havok physics sdk and i really like it, its not simple as physx but gives better control over things like character controller, ragdolls, ray casts etc.
why i'm doing it right now and not waiting after i release a demo?
the things is the physics is very important part of the game especially the character controller, so i prefer doing it before and have solid system than say: "i cant do it now, its a lot of work".
few things i found physx is very bad at:
1. filters, not enough and not general so i could filter collision detecting between objects and such, for example: i want to the bot to shot but i dont want it to collide with its ragdoll! i solved it via bits filtering but limit to only 32 bots.
2. character controller! smooth collision nice handling with different shapes (box, sphere, capsule) but very very bad in interacting other physics element, the thing is that this character controller (cct) is placed outside the physical system and perform sweep test against the world to do sliding and stairs handling.
so interacting with other rigid bodies is done via collision callback that tells you which bodies the cct collide with and allows you to add forces to do the pushing effect, but what about other rigid bodies that pushing the cct? well this is not possible! because the cct is a kinematic object which means its static! and have high priority over other none kinematic objects.
so doing moving platforms that allows the cct to stand and moving with them isn't possible! you can do it by doing dirty hacks and maybe you get the right results but it will jitter a lot and wont perform very well.
those are 2 things i can't compromise and because of them (mostly because the cct) i move to havok, which have great cct and let you chose the one which fits better to your game, they have rigid body cct and proxy cct which acts like physx cct (placed outside of the physical system and do sweep test and such), when you choose rigid body cct it means it part of the physical system and everything works! meaning you can push things, things can push you, moving platform become very easy to do.
they also have very generic filtering system and ragdoll support, they even have animation support which works with ragdoll physics and ik so you can do animation with ik and enable ragdoll physics when you want.
there alot of things i didn't mentioned but i think that if you need good physics system and you dont want to compromise you should select it very carfull or you end up changing it like me :)
so in two words: Havok Rocks!
cya until next time...

if you have any question feel free to ask http://orenk2k.forumotion.net/

Triggers in Action

2009-03-27T08:07:00.000-07:00

hi, after i finished to update my system (installing and updating few things) i remembered that i said i will put some video to show triggers in action so i created a small map with a box attached to ceiling with few physics objects inside, so when i touch the trigger the box will be opened and the objects will fall down.
this is very simple example of using trigger_once (which trigger his targets only once), other triggers could be use at the same manner to achieve more complex behavior.

using triggers

if you have any question feel free to ask http://orenk2k.forumotion.net/

Doing some maintenance

2009-03-21T11:12:00.000-07:00

hi, this week i did some maintenance, something i want to do for a long time is to replace my hard disk, my current hdisk (old 80 gb) start to do some noises so i thought its time to replace it, so i buy new 320 gb and clone everything.
i thought i will be fast and simple but the new norton ghost is so bad, i just want to do simple task (as i did in the dos days) and they make it so hard, they change the option for cloning hdisk to copy hard drive option which allows you to clone only one partition at a time and not the whole hdisk as one unit.
so i searched for another app, and i found really good software 'Acronis True Image Home', this is the best app i found for doing the job, very easy to use and have a lot of options to backup things. anyway i use it and it work perfectly.
i also install source control software (which i didn't use until now), the project become very big with a lot of files and it become very complicate to control it, so i installed svn (which i also use it at work), i really like this software, very fast and relaible.
the last thing i did is to upgrade my dev system to vs2008, i was using vs2003 which wasn't so great, i hope the new one will perform much better :)
thats it for now, bye

Triggers

2009-03-11T07:15:00.000-07:00

hi, long time i didn't post anything, i'v been busy at work and also wanted to try few techniques and to read few articles from gpu gems 3 and gpg 7, i'm going to get a new copy of ai game programming wisdom 4 which will complete my series so i'm really looking forward to read it.
anyway, after checking some new methods on the graphics side (deferred methods) i wanted to get on with the gameplay so i decided to add new triggers to support interesting level design stuff.
background on triggers for those who are not familiar with it.
trigger is a convex volume which triggers an event when game entity (player, bots, projectiles etc) touches it.
simple example for using triggers: you place a door and want it to be opened only if you get nearer, so you place a trigger around the door but make it a little bit bigger so you will touch the trigger before you touch the door, you set the target of the trigger to be the door so when you touch it it will send a 'trigger' message to the door.
each trigger have basic attributes:
1) target - name of the entity that will be triggered when we touch the trigger, we can set multiple targets.
2) message - message to desplay when triggered
3) delay - amount of time between the touching and the actual triggering
there are few more relative to trigger type.
the triggers i'v added so far:
1) trigger_once - triggers only once, when it is triggered you can't trigger it again, can be used to destroy a bridge after you pass on it.
2) trigger_multiple - triggers multiple times, you can set wait time before the trigger will be trigger again when touched.
3) trigger_hurt - apply damage when touched, can set damage amount.
thats the main idea of triggers, i'v few more to add and there is cool stuff you can make with them.
next time i hope i will finish the rest and upload some video to show some action.
bye
as always if you have any question feel free to ask http://orenk2k.forumotion.net/

Custom Deformation

2009-02-15T01:07:00.001-08:00

hi, quick update about new feature i'v added into material system called custom deform.
this feature allow you to create specific deformation on a geometry batch.
by saying specific i mean that you define 3 functions/expressions (anything you want), to define the deformation on x,y,z component of each vertex in the batch.
for example:
here is a material definition for sin wave deformation:
materialTestDeform
{
deform custom 0, sin(time+VertexIndex), 0
}
ok, what this simple material does to any geometry using it, is applying a sin wave deformation on each vertex on the y component. (the x,z component doesn't do anything as its 0)
time - internal keyword returning game time in ms
VertexIndex - internal keyword returning current vertex index of the vertex we are going to deform.
i could also use it to do some old scholl water deformation (using height map) by doing something like this:
materialWaterDeform
{
deform custom 0, heightMapTexture[256*VertexPos.y+256*VertexPos.x], 0
}
heightMapTexture - is the dynamic 256x256 height map texture
VertexPos.x/y/z - internal keyword returning current vertex component of the vertex we are going to deform.
this is just a few examples of using this new feature (you probably wont apply this water deformation as its not fast enough and could be done faster using the gpu)
because this deformation is based on the functions you define (its not constant), this could not be done in the gpu so its take some cpu time.
thats all for now.
if you have any question feel free to ask http://orenk2k.forumotion.net/

Forum For All

2009-02-04T00:16:00.000-08:00

hi
i decided to open a forum to discus my engine programming and game development in general.
the main idea of the forum is to be the place to ask questions and hopefully get answers :)
it also contain game design area which allow you to share you work and show what you got, the main idea of this section is to get in contact with some talented users who would like to help with new models, animations, level design etc.
i still post news here but if you have any questions about something (new or old), i would like you to ask it in the forum, so enjoy and cya in the forum :)
forum address:
http://orenk2k.forumotion.net/

Improving Shadows System Continued

2009-01-25T00:16:00.000-08:00

hi, last post i let you think on answer to some question about shadow updating scheme.
in short, the problem was that if dynamic entity gets into influence area of the light it means the light needs to update his shadow map, but this turns to be very intensive if this area contains lots of detail models which is static (read the last post to get the details and comments...)
ok, so the solution to this problem could be one of:
(1) two shadow maps for each light
(2) stay with one shadow map per light but...
(3) other
lets check those options:
(1) two shadow maps for each lights is the way to go but still raise some problems:
a. more memory (twice), if the light taken 1.5 mb per cube shadow map, now it will take 3mb!,
not so good as the reason i use shadow cache system is to maximize shadows cound and minimize the memory used by them.
b. we need to merge those shadow maps to get final one so we could use it when rendering, so we need another shadow maps for this! still the merging process isn't for free so i think you get the idea way this option isn't so good.
(2) here i stay with one shadow map per light but i use another shadow map which will be shared for all lights, this second shadow map will only used for dynamic geometry, so the unique shadow map per light stay ONLY for static geometry and the shared one ONLY for dynamic geometry.
so the memory issue solved, what about the merging? well, instead of merging those shadow maps in cpu, we merge them on gpu.
sound good but that means we need another shadow map right? not necessity, what i do is binding those shadow maps and merge them inside ps, and then i compute shadow map as usual. so instead of using the value sampled from one shadow map, i use the merged sample.
this method saved the need for another shadow map and the extra pass for merging them.
(3) other? nothing i see now, but maybe you could think of something?...
in practice its work very well and the performance gain is huge.
here is two screenshots show the results using this method:

using both static & dynamic shadows

using only static shadows

i see those screenshots but what is so special about them? its just shadow maps...
well yes and no, the first screenshot shows simple scene with few static geometry and one dynamic pickup item (armor), the only shadow map that is being updated is the dynamic shadow map, so what you see is the result of merging two shadow maps in the ps, so you can see both static and dynamic shadows.
the second screenshot shows the same scene but this time we picked up this item, so the resulting shadow map taken only from the static shadow map (dynamic one is empty!)

Improving Shadows System

2009-01-19T00:14:00.000-08:00

hi
recently i'm working on performance issues and such, one of the biggest challenge in this area is shadows and how do we make them faster?
the answer to this question is another question:
how much cpu and memory can we sacrifice for this?
the answer to this one is: it depends on other process in the game and your platform.
so here i'm working on pc platform where memory is not an issue (like in ps2/xbox/ps3) so the main question is:
what do you do if you have big scene with 5000 point lights that need to cast dynamic shadows?
lets say we can determine their visibility very fast, so the bottleneck is the shadows generation and not the visibility of the lights. another assumption is that the lights is mostly static but if at any time we want some of the lights become dynamic, we could.
so the answer to this question can be one of those:
1. use light maps
2. compute all shadow map at load time
3. other
well, lets check those methods one by one:
1. light maps is out of the question because they are static and if a light is moving, his shadows wont be updated. also if we have a bridge and we walk beneath, the shadows of the bridge wont cast on our character, because when we compute those light maps, our character wasn't there.
2. this sound promising, it solved the problems in 1 but has another problem.
each point light using cube map for his shadow maps, that means 6 maps for each side, so if we take for example 256 by 256 cube map for all the lights we get something like 1.5 mb per light (assuming 4 bytes per pixel), this become 1.5*5000=7500 mb!! = 7.5 gigs, this is huge and of course cant be done in the real world when we have limited memory.
3. so what we need is a solution that solve both 1 and 2 and take reasonable memory, so the solution i come with is to use a cache system for shadows.
this system will have specific amount of memory dedicated to shadows and based on priority value we computed for each light the system will give cache entry for the most important lights (that is for example: the lights with large range and closer to the viewer).
so basically the system work with x entries that keeps shadow maps and set them as needed to the right lights, when we set shadow entry, we flag the light that he needs to update his shadows, this way we wont spend memory for far lights the viewer wont even see.
so when the scene loaded, the system set shadow entries for the most important lights and when the light tries to generate his shadows we check:
a. is this light have shadow entry? if not it means this light is not important and wont generate shadows.
b. is this light already updated his shadows or not? if not it means the light become dirty or someone flag the light that he need to update shadows (see below)
if we have shadow entry and the light needs to update his shadows, we get the shadow maps from cache entry and generate shadow maps for shadow maps stored in this entry.
when we done, we flag this light that he update his shadows so next frame we wont update it again.
few thing we need to consider:
1. if entity that cast shadows get inside light bounds, the light must update his shadows so the shadows of the entity will get in.
2. if the light is moving we need to update his shadows maps.
ok, so this is the main idea of the system and it is very fast and generic and as any algorithm, this have some tiny things that need to be done correctly so it works smoothly and handle all the special cases.
before i finish, here is another question:
what if we have a room with 500,000 faces with one point light that cast shadows?
we use this great shadows cache system :)
right, but what if an entity, lets say a small ball with 16 faces get inside that room?
hmm, the light need to update his shadows so the shadows of the entity will get in.
well, thats right but that means that for this tiny entity with only 16 faces you need to generate shadows from 500,000+16 faces???
think about it until next time...

Volumetric Flares

2009-01-13T03:22:00.000-08:00

hi
while changing some of my render batches design to support static and dynamic batches better and faster, i decided to add this nice fake volume effect that i called light flares or volume flares.
unlike the simple 4 vertices billboard/sprite flares that we rotate to face the camera those flares are different and look much better.
when editing the map i place quad shapes aligned with scene geometry and gives them the special flares material, inside the engine i build special border extruded by specific size (defined inside material script) and make sure they always face the viewer.
i also make sure the flare wont be visible if the camera position placed behind.
when the position of the camera is at front and smoothly become behind, i take the distance from camera position to the flare plane and use it to compute flare intensity so the flare will smoothly become invisible the more the camera become closer.
also i bind it a built-in texture which encoded a quadratic function so the borders of will have a smooth falloff effect.
there are few tiny things here and there (setting texcoords and such) but this is the main idea.
here is a screenshot to show this in action:

Volumetric Flare Around Fluorescent

note that this volume shape changed relative to viewer position so it will be different when looking from other position, but the volumetric effect will be preserved.

Improving Area Visibility

2009-01-11T00:22:00.000-08:00

hi
last time i talked about my new visibility system and how i compute lights and areas visibility, this time i improved my visibility system in a way that i could know the visibility inside each area and not just which areas are visible.
i call it internal area pvs, this pvs use the same mechanism of bitsets and gives me information about all the entities/surfaces etc that are visible inside specific area.
at first it sound like, why do you need it? well, when running big levels each area have lots of detail in term of level design and also game play by placing high detail models and pickup items, those can take a lot of power when rendering.
also note that computing internal area pvs is very fast and done when doing the portal traversal, so with a few lines i save lots of rendering, also what you don't see does not need to be lit so the saving is huge when doing the lighting pass!
here is 2 screenshots that shows it in action:
NOTE: the images in wireframe mode so you could see the data the visible without and with internal area pvs system.

without internal area pvs
notice the small red entities at the right side

with internal area pvs
notice the red entities at the right side was removed along with other surfaces

the red entities in the images are light flares, which is a nice effect to fake volume light effects. note that unlike billboard/sprites those are not simple quad aligned to camera view, next time i talked about them...

Visibility System And Shadow Casters

2008-12-30T02:11:00.000-08:00

hi, last days i'v been working on my visibility system, rendering system and redesign few things related to them, also fix some low performance issues in big levels.
so in order to attack those issues i stared so see what could be optimized, one thing was the pvs data set which was basically a list of visible objects created from specific view point.
this pvs is needed for both camera and lights, also mirror materials needs to generate this set for the mirror generation pass.
those list was filled in few places but the thing is that we could do alot of the work in load time and achive better performance and still get the same thing.
so instead of keeping list of scene objects which could be changed doring the game (for example: another bot got in or out), i'm using a bit set for lights and camera pvs.
each entity update which areas they belong to, lights only update thier bit set when they move/change.
when i want to render the scene, i only need to check camera pvs bit set and see which areas are visible. to know which entity is visible is just a matter of checking the right bits in camera bit set.
in lighting pass we need to know which areas the current light influenced, so to get this info we need to do an AND bit operator between current light bit set and camera bit set, the result is the areas the light can influence and the camera can see.
the same thing is done for shadows generation, that using the same light bit set pvs with an exception.
when we are generating shadows we still need to consider shadows that comes from unvisible objects, object that is not visible still can cast visible shadow!
to solve this issue, we should check if the shadow volume of that object is intersecting our view frustum, if so it means this object needs to be rendered into the shadow map even if its not visible!.
if you dont handle those object you will get wrong shadows.
for example: if you have an open space scene with sun as the only light source and simple cave built from floor, ceiling and walls. when you enter the cave and look down (ceiling is not visible!) you still want to see the shadow of the ceiling.
here is screenshots from medium scene with unvisible shadow caster

shadows off

shadows generating from unvisible ceiling of this hallway

Portals

2008-12-14T00:21:00.000-08:00

hi, this time i had to recreate my portals visibility system, why? well i had some nasty bug that pop out when doing my pvs (possible visibility set) on complicated levels with lots of portals crossing each other.
i will try to explain the problem so when you see one you could attack it :)
little info about portals for some of you who don't familiar with it.
portals is related to visibility system because they help to cull scene areas, how?
think for a moment on a door that connecting two rooms room A and room B, if you stand in room A and looking through the door you only can a portion of room B.
now if you doesn't look through the door, you probably wont see room B (if you cant see the door, you cant see the room/s it leads to)
so portals basically hand placed (can be places automatically) in few places (not just corridors) as convex polygons (usually quads).
now, when you want to know which areas are visible, you start from camera area and check which portals inside this area, for each portal you clip your current frustum planes (the camera planes) against the portal and check again with the new clipped planes as the new frustum (yes its recursive function) and so on and on for each portal until there is nothing to see/visit.
now each portal you enter lead you to a new area so you flag this area so you know it is visible.
after you quit this function you end up with a list of areas that are potentially visible from camera area. this is the basic idea but few trick here and there could do this faster!
now that you know whats portals, i try to explain why i think recursive function for portals visibility are not so good in complicating levels with lots of portals!
the thing is that every portal you pass, the current frustum get clipped and pass for the next check, for every area you visit you also flag it so you wont check it again (this also helps to break the recursion, if not you can get stack overflow) because other portals can also leads to it.
because of this you can have few routes (in the recursion tree) that can lead to the same area! but not all of them will result in a visible area at the end! this is because we flag all the visited areas so the other routes that start like the first one but ends different (in terms of areas) wont even ends! meaning the area at the end of their route wont even visit because the first ones was flagged as visited - resulting in a none visible area that needs to be visible!!
i hope you didn't get lost in this long explanation and get the idea, so here is my solution to this problem:
the way i solve it is to look at the problem as a tree where the camera eye placed at the root, each portal is node, each branch is an area. (this is just how it help me to solve the problem).
i scan this tree by levels!, this way the areas are visited in a sorted order relative to eye pos (the root) and all the routes advance one step at a time and not allowing one route to get to the end (leaf) and others stay at the beginning.
here is few screenshots that shows portals in action:

visible portals in green, none visible in red

visible portals in green, none visible in red
yellow lines are current frustum planes
NOTE: portals are clipped against current frustum thats why part of the portal is red and the other part is green

Gamma Correction

2008-12-03T06:44:00.000-08:00

hi, after reading the article "the importance of being linear" in gpu gems 3, i decided that its a good thing to add gamma correction into my engine.
by setting the right gamma value everything will look more real and the colors get the right felling.
there is few tecniques to do that, i decided to do it as a post process on the final pixel color by applying the function:
gammaCorrectedColor = pow(finalColor, 1/gammaValue)
as a bonus we can now optimize light interaction because the light bounds doesn't need to be big in order to make the effected area more clear and bright.
also, its a good idea to make the gamma value controllable so every player could set it as needed, i'm using the console to change it.
here is a screenshot of the effect:

without gamma correction

with gamma correction

Mini Map

2008-11-22T23:48:00.000-08:00

hi, one of the things that was missing for me in fps game is the way to know where i am, where do i need to go and where the hell is my enemies that keep shooting at me.
so i thought to add this mini map feature which shows you the level (from top), you and the enemies near you, this including orientation so you know where they look at.
for now its just shows you where is the bots in the map (including you) but eventually it will show you:
1. your objectives
2. war zones
3. special items
4. shortcuts
and more, this list is changing from day to day but i think you got the idea :)
here is a screenshot the shows the mini map inside the game (top left)

yellow icon is you, red icons is other bots
note that the detail is not so good because the image compression

Swinging Lights

2008-11-15T07:18:00.001-08:00

hi, this time i just added new feature to my articulate figure system that i'm using for ragdolls, the new feature allow me to define any model to be physical so to test it i tried to use it for lights so i could interact with them.
its very simple to define, just one .af script to define the bodies & constraints and one 3d model to attach the .af script to.
here is a small video to show this in action:

Advanced Shadows

2008-11-02T01:30:00.001-07:00

hi, last post i talked about the new render system and the improved shadow and lighting system, so here is few screenshots that shows some action:

soft particles with per pixel lighting and shadowing,
notice the green shadows on the wall

this is not projected light effect, this is true shadows generated from the fench

first picture shows some green smoke effect that cast green shadows, this is not precomputed effect or projected video, this is real shadows producing by the particles.
here i show this on particles but it will work perfectly for glass and other translucent materials.
the second picture shows shadows created from semi transparent materials, here i show this on fence but it will work for any semi transparent materials such as trees, grass etc.

i also added some optimizations to point light shadowing by skipping cube face passes by determine if face frustum is not intersecting camera frustum.

New Render System

2008-10-27T02:19:00.000-07:00

Hi, recently i worked on a new render system, the old system created at the first stages of the engine just so i could render some geometry.
the old system wasn't generic and fast, it didn't support alpha blend surfaces very well and optimize material and stage binds, also shadows for special media wasn't supported and was hard to add (shadows for translucent surfaces for example).
those things result in lower fps and unrealistic scene, so i decided to create new system to overcome those problems.
the new system manage all scene rendering using special batches, each render object need to generate those batches and feed the system, then the system manage and optimize those batches for fast rendering and lower material and stage binds.
also the system support few render options so it will be easy and fast to render special passes such as shadows, ambient light etc.
the good thing with this system is that it doesn't need to know about the objects being rendered, it works only on those special batches and thats it, so if i need to add new support for 3ds object for example, i just need to make sure it will generate the batches and it will automatically get all the features (shadows, lighting, post process effects etc)
i also improved my lighting and shadowing system to support some new features:
1. light interaction of translucent surfaces
2. shadows for translucent surfaces, for example: glass and smoke will cast shadows depending on how translucent it is, red smoke will cast red shadows.
next time i will upload some screenshots...

Debug in Release

2008-10-19T01:35:00.000-07:00

hi, this time i talk about something i "bump into" while trying to run my engine in release mode (after i changed all engine class design and such) and get a crash into my face, oops not good.
at first i thought it something i mess with, i had no clue where to begin because the change was so big so i start shooting all over with no luck.
so i created exception handler lib which will catch exceptions and just before it will crash it will generate two files:
1) log file about the stack, modules, user, and the must important is the eip, which is the instruction pointer where the crash was happened.
2) mini dump file which is generated using dbghelp.dll, this is basically a snapshot of the program before it crashed, and it can be opened via vs or windbg and it will show you the exact line that cause the crash (very useful)
after having this kind of tool i started debugging and check what the hack cause the crash, i saw that there was uninitialized pointers such as d3ddevice interface, which wasn't make any sense because in the log i saw that textures and other data was loaded.
this turn on the red alert, what is wrong with my code, and why it is working in debug and not in release (and it was working!!)
i watch the engine log and see that the constructor of some managers was called twice which wasn't possible and make sens because they are singletons!! after digging a bit i notice that if you create static inline singletons (scott mayers singletongs) the compiler (which is vs2003 not 2005/2008) generating wrong code when optimization is on, and make the constructor called twice or more if you include the header in more then one object file and you call the static inline function that return the singleton instance/object.
if you move the implementation to the .cpp code the compiler generate "good" code.
because those managers are heavily used i didn't want the overhead of the function calls, so i dig a little bit more and i found a trick that works.
NOTE: this only happened on vc6 and 2003, in 2005 they fix the problem.
so if you are used to create singletons like this:
class CTest
{
public:
static CTest &GetInstance()
{
static CTest instance;
return instance;
}
}
you should now use this trick:
class CTest
{
public:
struct tDummy
{
static CTest &getInst()
{
static CTest instance;
return instance;
}
}
static CTest &GetInstance()
{
static tDummy instance;
return instance.getInst();
}
}
vc2003 deals fine with static var which contained in a non-static inline method.
so what i found is that i didn't mess anything and the code was fine and the compiler wasn't
after all it was good practice to wrote the tools and i think they will be useful in the future - i hope i wont need to use them :)

Lights And Sound Shake Data

2008-10-15T08:22:00.000-07:00

hi, on my last posts about sounds i talked about shake data which defines the intensity of the sound at a given time/point, so i thought it will be nice to add sound to lights, but then i want the intensity of the light to be changed based on what we hear.
for example: if we hear sound of blinking light we want the light intensity to blink and sync with that sound - this is where shake data comes in use.
i wrote some helper function that gives me the exact shake value and i use it as scale factor when i compute the light color.
so now i can set sounds for lights and the intensity of the light will be sync with sound shake data and gives really nice and creepy effect :)
watch the video to see it in action:

Loading Screen

2008-10-04T09:34:00.000-07:00

hi, this time i added loading screen feature so we see when the loading process while level data is loaded and cached.
i also added the feature to load new maps on runtime via cvar, so i could check other maps while the core engine i initialize and cached so i wont need to stop and run the project every time i want to check other/new map.
this was mainly an engine redesign process so everything related to level map could be released and initialized on demand.
the loading screen i based on my gui system so its just a matter of designing the loading script and load it and update the variable and call triggers when needed.
here is some of the code in the loading gui script:
windowDef p_load_bar
{
rect 235,431,( "gui::map_loading" * 405 ),26
visible 1
windowDef load_bar
{
rect 0,0,405,26
visible 1
background "gfx/guis/mainmenu/load_bar"
matcolor 0.878,0.423,0,0.5
}
}
this window i the loading progress bar we see while we wait for the level to start, notice the 'gui::map_loading' variable in the rect definition of the window 'p_load_bar', this variable used to control the visibility of window 'load_bar'.
because i have parent/child design, the parent window also scissor his child, that means the child windows can be visible only inside their parent rect.
when i'm loading level/map data i'm setting this variable to the right value [0..1] and when i'm finished i'm triggering the event 'FinishedLoading' that changed the text near the loading to
'click to continue'
also i added script file per map, so i could define map related parameters such as the loading image. thumb image etc.
when i need to load specific map i'm checking if the map has a script file, if so i'm getting the image that i need to load and set it as 'gui::loading_bkgnd' in the loading gui, here is the loadimg window declared inside the script:
windowDef loadimg
{
rect 0,0,640,480
visible 1
background "gui::loading_bkgnd"
matcolor 1,1,1,1
}
the window is responsible to display the loading background image.
here is a screenshot of one of my test levels:

map doesn't have loading image
notice the click to continue text which shown when the map finished loading

Sound Occlusion Per Material

2008-09-28T01:45:00.000-07:00

hi, i did small update to sound occlusion which defines sound occlusion properties via script file.
so now i can define reverb and direct occlusion for each material.
the script is very simple: (for short only 2 materials)
none =
{
"0.5", -- directOcclusion
"0.5" -- reverbOcclusion
}

stone =
{
"1.0", -- directOcclusion
"1.0" -- reverbOcclusion
}

none - is the default occlusion properties if material not defined/found/exist
the rest is direct and reverb occlusion values per material (using material name)
when creating the sound geometry the occlusion properties will set based on material and his values from the script.

Caching Data

2008-09-15T02:49:00.001-07:00

hi, this time i added new script file that will contain all the data that needed to be cached before the game start.
the engine designed to load data on demand so when i'm checking things i don't need to wait until all map data will be loaded, so if for example you are not shooting at all, then the sounds and effects for the shooting wont be loaded (it will be loaded and cached when you shot at the first time)
this is very nice and good when you are testing things but when you want to play the game this is very annoying as the game will freeze a little when you do some actions (firing/jumping etc)
the script is very simple, it contains data to be loaded and cached per category: sounds/effects/animations.
example for sounds category:
SoundShaders =
{
"pickup_weapon"
}
this we cached only the "pickup_weapon" sound shader before the game start.
for now i'm using only one cache file, but it will be extended to support few cache files - one for each map so every map will have its own data that needed to be cached before playing it.

Sound Geometry And Occlusion

2008-09-12T09:16:00.000-07:00

hi, i added sound occlusion effect which takes scene geometry into consideration when trying to play sound with his properties.
i created new class called CSoundGeometry which contains the geometry the sound need to consider when we are playing it.
all sound geometry classes separated by material properties so i can give different sound occlusion and reverberation properties based on the material.
for example: stone will occlude more sound then glass.
for now i didn't setup the properties table for each material, so every material will block the sound in 100% (so no reverberation for now).
i added debug rendering for the sounds so i know when sound is occlude and how much by rendering red to green color circle interpolated from the min to max distance property of the sound, so if the sound have 10 to 100 (min, max distance) and it is occluded it is shown in red, if not it is shown in green, if it is 50% occluded it is shown a circle radius of 45 and with 50% color between red and green.
note that only one room has sound in it so only when the door is opened we can hear it, you can also hear the steps sound and gear when you are moving.
the door also have few sounds for few states: open/opened/closes/locked
here is screenshots and short movie that shows sound occlusion in action.

sounds shown in green spheres, occluded sounds in red

min/max distances of sounds shown in green circles, occluded sounds in red
the door is opened at 50% so the top sound is occluded 50% meaning 50% between red to green

Light Leaks

2008-09-12T08:41:00.000-07:00

hi, small update about something i saw while working on sound occlusion.
i created small level containing 2 rooms with a door separating them, while playing with this level i saw some lights leaks near the door and at the sides of one of the rooms room (the one without a light) it appears that some of the light from the lighten room leaked into the dark room - very strange, because i'm using vsm for shadowing the scene and i'm using some thresholds to solve the light bleeding problem i thought to give a second check to this threshold.
so what i did is increasing the light bleeding threshold and everything look good now :)
here is few screenshots showing the problem before and after solving it:

close door - leaks on sides and near door

open door - leaks on sides

close door - no leaks

open door - no leaks

Ambience Sounds

2008-09-07T02:43:00.001-07:00

hi, this week i added ambience sounds, so i could place sounds in the scene which will be played based on their properties defined in the map file.
unlike other sounds, those sounds usually played automatically (some ambient creepy sounds), or by triggering some triggers/events (like opening a door, or using an elevator)
here is an example of sound entity defined in the map:
{
"origin" "753.48 2078.26 66.7"
"classname" "speaker"
"angle" "315.181274"
"s_shader" "sound/ambience/music.ogg"
"s_looping" "1"
"s_shakes" "0.000000"
"name" "speaker_2"
"s_volume" "-6.000000"
"s_mindistance" "512.000000"
"s_maxdistance" "1200.000000"
"s_occlusion" "0"
"s_waitfortrigger" "0"
"soundgroup" ""
"wait" "0.000000"
"random" "0.000000"
"s_global" "0"
}

ok, so what are all those properties do? here is a quick info:
origin - the position in 3d space of the sound (if ambient this will be ignored)
classname - internal use, basically its the type of the entity
angle - control the spread of the sound
s_shader - sound shader or sound media file (.wav, .ogg, .mp3)
s_looping - need to loop or not (repeat the sound over and over)
s_shakes - shake factor controlling how strong the view will be shake when playing the sound (also based on the loudness of the sound)
name - name of the sound/speaker entity
s_volume - volume of sound (in decibels)
s_mindistance, s_maxdistance - minimum and maximum audible distance for the sound
s_occlusion - is this sound need to take care of geometry occlusion or not
s_waitfortrigger - sound will be played only when the right trigger will be triggered
soundgroup - the group the sound belongs to, useful for setting volume for few sounds, for example, all music sounds added to group "music" so if we want to mute the music in the game we just mute the group called "musics" and its done.
wait - delay between playing the sound again
random - random factor added to wait when needing to play the sound again
s_global - is this sound need to be heard every where (makes the sound ambient - used for music), if its ambient the sound will ignore his 3d properties.
so as you can see it is very easy to define ambient sounds in the scene, those sounds adding alot to the game play and make the game more realistic.
for now, geometry occlusion is not supported maybe i will add it next time.

Convex Decomposition

2008-08-30T10:42:00.001-07:00

hi, this time i fixed my physics objects support so i could add more complicated objects to the scene not just box, sphere etc, but also concave models.
physx does not support dynamic concave objects but it support multiple collision shape per obj so in order to support concave objects we must do something called: convex decomposition which break down or split the mesh into few convex meshes.
the data is stored in xml file which include all the info to create the convex mesh shapes that describe to render model.
i created new function in the physics manager that creates physics obj directly from this xml file, also i add the ability to specify collision script file (this xml) to every render model exist in the scene.
to work with xml files i use tinyXml which is very small and easy to use.
here is few screenshots that shows perfect collision with concave objects:

tables lies on the inner part of other tables
note the left table edge placed on the right table

tables placed on the inner parts of other tables

Sound Manager

2008-08-23T10:35:00.000-07:00

hi, this time i worked on the sound system, there is a lot of sound libs such as openal, bass, fmod, miles.
i chosed to use fmod ex because it is very advanced system and very easy to use.
i created sound manager to manage all sound creation in the game, i also add something called sound shader which is very similar to my material script.
sound shader is a script that let you to define specific parameters to one or few sounds and when you want to play the sound/s in that shader you just call CreateSoundFromShader(shaderNameInScript) which is a function inside sound manager and it will be played with all the attributes you specified in the script.
for example:
sound weapon_blaster_fire
{
minDistance 393
maxDistance 1181
volumeDb -2
frequentlyused

sound/weapons/blaster/fire01
shakeData 0 zzzztsolggeedccbbbaaaaaaaa
sound/weapons/blaster/fire02
shakeData 1 zzzztsolggeedccbbbaaaaaaaa
}
1) weapon_blaster_fire is sound shader name which we called from the code
min/max distance is the distance which the sound is audible
2) volumeDb is volume in decibels
3) frequentlyused is one of few flags that allow me to control few sound attributes such as occlusion, looping etc. this is used to cache the sound so it will be played from memory and wont be decompressed every time we want to play it
4) sound/weapons/blaster/fire01 and sound/weapons/blaster/fire02 is 2 sound files we wish to play while activating this sound shader. by default we chose randomly one of them.
5) shakeData is intensity of the sound in ascii form (z is loud, a is complete silence), i use it to change camera view based on the sound volume.
few of the sounds in the game must be played in relation to model animations, so to make it possible i created something called frame based event system, which allows you to specify events that will be triggered on specific animation frame/s.
for example, this is how i created shotgun reload sound events:
VIEW_RELOAD_CMD =
{
"RELOAD", "9", "sound", "weapon_shotgun_clipout",
"RELOAD", "22", "sound", "weapon_shotgun_clipin",
"RELOAD", "35", "sound", "weapon_shotgun_pump1",
"RELOAD", "38", "sound", "weapon_shotgun_pump2"
}
"RELOAD" is animation name
"9", "22", "35", "38" is frames to trigger the event
"sound" event type - all of them is sound
the last parameter is based on event type, in sound events its sound shader name

Material Hit Effect

2008-08-16T05:43:00.000-07:00

hi, this week i fix my projectiles hit effects so they support per surface material effect,
until now, i had only one impact effect per projectile for all surface types, this was very unnatural when you hit water surface because it was applied the same effect on it, so you saw decal rendered on the water, yes - very strange so now if you hit glass surface the effect will be different when you hit stone or liquid surfaces, depending on what you defined in the weapon script.
here is a screenshot that shows the effect on stone, glass surfaces:

left: stone hits, right: glass hits

Weapons Sniper Scope

2008-08-02T04:19:00.000-07:00

hi, i'm still working on weapons features, this time i added sniper scope with nice radial blur effect.
to create this radial effect i needed to add few features to material system so i could define which shader to use in which stage and which shader parameters and samplers i need to bind when binding this shader.
i also add the option to use current back buffer image as one of the samplers i'm binding to the shader, so i could create post process effects.
the effect i chosed is radial blur so everything outside our zoom area will be blurred and stretched.
i also change aim accuracy based on zoom, the more we zoom in the more we get accurate.
here is screenshots of the effect.

Weapon Sight and Lock mode

2008-07-23T07:11:00.000-07:00

hi
i worked on some game play features that allows you to control your weapon more easy.
1. adding weapon sight on the screen so you know where you are aiming at also when you are aiming on game entity (for now bots) you will see the name of the bot and the distance near your sight icon.
note that each weapon have its own sight icon.
2. weapon lock mode, allows you to lock your weapon to your shoulder, and set your view with weapon sight for more accurate aiming, also it increase weapon accuracy while shoting.
here his few screenshots:
note: hud removed from those sceenshots.

bot name and distance

lock mode active

SSAO Integration

2008-07-14T02:28:00.001-07:00

hi
last time i was playing with SSAO effect inside render monkey, after i was pleased with the results i started to integrate it into my engine.
it was very easy to integrate it because my flexible material system, the only thing i needed to do is to scale the parameters to fit my scene scale.
i still think there is few tiny things to fix (i don't know if i would fix them), but still it adds very nice global illumination effect :)
here is few screenshots:

shadows without ssao

shadows with ssao

ssao texture at top left corner

Screen Space Ambient Occlusion (SSAO)

2008-07-11T08:08:00.000-07:00

hi, since the game crysis (by crytek) every talks about it, so i thought to give it a try :)
ambient occlusion is a global shading method that computes how much a certain point need to be illuminated based on the surrounding objects.
in computer graphics we can calculated this by taking specific point in space and cast x rays in random directions from that point and for every ray hit we check add or subtract "illumination value" from that point based on the closeness of the object the ray hit.
the closest the surface we hit, the point will be less illuminated, so if we have a point in space surrounded by alot of objects the point will be darken while other point that does not have a lot of objects around will be lighten.
ssao approximate this by using the depth buffer, for every pixel we check/sample few pixels around and try to compute the amount of occlusion from those points based on the difference in the depth of the current pixel and the pixels around, this technique has a lot of tiny things to set up before you could make it looks good, because of that i'v chosen to use ati render monkey application to create and test my shaders.
i'm glade to say the after one day and a half i got it, and it looks very good.
here is a screenshot from my results:

Physics in Action

2008-06-28T08:55:00.001-07:00

hi
with the new physics engine and ragdoll i added damage system, so if you hit the head you will damage the bot a lot more if you hit the leg or arm.
also if the bot kills you the camera change from first to third person mode so you could see ragdoll physics in action when you fall on the ground.
few bugs here and there but the new system is really cool :)
few videos that shows the new physics engine in action:

NVidia PhysX Integration

2008-06-19T01:35:00.000-07:00

hi
while trying to create advanced ragdoll physics i found that my physics engine isn't so stable.
for example: if i throw ragdoll from high place to the ground, it could get very unstable due to my simple solver.
as you all know, nvidia acquired ageia physx and they also have 2 new cards geforce 260/280 thats have build in physics accelerator. (based on ageia physx technologies)
i think is great solution, buying one card that support graphics and physics is cool.
the solution to my physics problems was very simple:
1. i could spend few more weeks to fix and some few other things on the way
2. integrate some of the commercial physics libs. (havok/physx)
i decided that it is best to go with option 2.
another question was havok or physx? i decided to go with physx as it is very understandable, easy and have tons of samples.
the integration went very smooth, i change my physics manager to support their function and the ragdoll is very stable now.

Ragdoll Physics

2008-05-31T10:28:00.000-07:00

hi, long time without updates...
while shooting and killing bots i notice that something isn't right, something is missing - die animation or something like that.
so to fix that i thought i to create some new animation sets but that isn't perfect, so i decided to add ragdoll physics which have some drawbacks but is better then animation sets.
i added new script file like id does (.af files) which defines the physics bodies and properties also constraints between those bodies.
i also add new class that will read and manage the info and create the physics model from it.
after that i created two main functions:
1. setup physics bodies from current animation set - this is very useful function because you don't have to care about model pose and how to set physics from it, you just call this function and it will set the physics bodies to match current model animation.
2. set animation set from physics pose - used to alter model skeleton so everything applied to the physics bodies will change the visual model.
NOTE: when i setup physics bodies from skeleton i use T pose so it will be easy to setup physics bodies and constraints.
here is screenshot of ragdoll setup using T pose (red/green spheres is constraints)

Jumping, Climbing, Crouching in Action

2008-04-26T09:12:00.000-07:00

hi, as i promised from the last post, here is movie that shows the bot in action using the new areas features (showing crouching and jumping)

i also add the ability of climbing and crouching to the player.
note that the bot can also climb a ladder, i'm not showing it in the video because i dont have climbing animation and it looks like flying on it and not climbing.
also nice feature i added to collision system is the ability to know which type of material i collided with so for example: if a bolt hit a stone it will leave different mark if it hits liquid.

Jumping, Climbing, Crouching and more

2008-04-22T09:53:00.000-07:00

hi
this is holidays time so i had some time to dig into some cool AI stuff, basically i added the ability to edit AI data in run-time with a mini AI editor.
what this means is that i can add special features between areas such as, jumping, climbing a ladder, teleporting etc.
here is a screen shot of the mini editing tool:

1. the red/green spheres on the edge is the start/end points of the jump feature
2. the right side shows me which features the area the mouse on support, this is marked by the floating green sphere.
few keys to do some basic stuff such as set start/end points, set current feature, reset and save the data.
next time i will upload movie that shows the bot in action.

Console

2008-04-05T10:50:00.000-07:00

hi, another post this weekend.
this time is the console, allows me to change engine variables (cvars) at runtime, such as AI params, renderer params etc.
support auto complete, history, keyboard and mouse wheel scrolling, not much to say - just a console.
here is a screenshot:

before execute shadowmapblur=1

after before execute shadowmapblur=1

Profiler Improvement

2008-04-05T10:40:00.000-07:00

hi, this weekend i improve my profiler.
i have simple profiling that let me mark places in the code with PROFILER_BEGIN/END commands and then it shows me the results in a tree view.
while trying to profile some area in the renderer i found a bug in the timing, i cast the time value to dword while i should not.
i also added the feature which mark in red the worst time node in the tree and in orange the worst time leaf in the tree, this way i can see very clearly where the optimization needs to be.
one area i know for sure that needs to be optimize is make skinning. so here is a screenshot of the profiler shows you the results.

Dynamic Obstacle Avodance Integration

2008-03-23T10:37:00.000-07:00

hi, this task wasn't easy, a lot of tiny things that needed to be fix - as i said in my last post :)
but now i'm very pleased with the result, i can drop any number of dynamic obstacles in the scene and the bot/entity will navigate around them.
one very important thing is to make your bot move smoothly and try to take shortcuts when possible, if you wont do it your bot will move around obstacles edges while you can see for sure he can take shortcut, this will make him looks very unnatural and robotic.
here is some screenshots that shows the system in action:
NOTES:
* purple lines shows the from the precomputed ai data the bot aware of, this is convex area so the bot knows he can walk in straight line to any other point in that area.
* small green sphere, goal position the bot need to be at the end
* medium green sphere is the point the bot will move to on the path resulting from dynamic obstacles system, this point is the result of path smoothing. the yellow lines is the path around obstacles without smoothing.
* white boxes is dynamic obstacles (dynamic rigid bodies in debug mode), the green lines around them is the expanding edges of their box.

Simple scene (1 area) this is what the bot aware of

One obstacle added and path generated from the system

Few more added and you can see the new path generated

stress test - start of movement

stress test - middle of movement.
if you watch closely you can see the bot is not moving along the yellow lines and take shortcuts where possible, this can be seen from the bot direction toward medium green sphere.

Dynamic Obstacle Avoidance

2008-03-03T02:04:00.001-08:00

Hi, after setting up some basics in my physics engine i realize that my AI system isn't aware of any dynamic object created from the physics engine so i started to think about some generic solution to solve the problem of dynamic avoidance.
until now, i had some basic dynamic obstacle avoidance inside my steering system that check against obstacles on the way and if it found some, it add avoidance forces so the agent while try to steer around the obstacle (works fine for the bots)
the main advantage of this system is that its very simple to implement and it very fast, the disadvantage is that it tries to steer around one obstacle at a time, so if you have few obstacles one after another, it will steer around the first and return, steer around the second and return and so on (does not look very smart), also it doesn't handle the case where few obstacles block our path, it doesn't find a path that goes a around them (if exists) it just tries to steer around the first on the way but end up bumping against them until they moved (and if they wont move you are stuck)
this is unacceptable when you can have a lot of dynamic objects that moves around and could block our path, so i started to build some generic solution to this problem.
the main idea is that i trace a line from my current position to my current goal position (path line), and any obstacle that founded in my way, added to a list of obstacles.
then i check this list against my path line and build "edges graph"/"path tree" from the bounding edges of intersected obstacles and my path line fractions.
this tree is just a graph containing all the combination paths from my current position to my current goal, so then i found the shortest path in the graph and save it as a local path around the obstacles.
of course this is just a brief of the algorithm, there is a lot of tiny things that you need to consider when creating the graph, and also how you can optimize it so you have only few edges to run the shortest path algorithm on.
after i finish the algorithm i had time only to test it against rigid bodies that i throw inside the scene and it really perform well (still need to add few things here and there), i didn't had time to integrate it into my AI system :(
no pictures/movies maybe next time...
BTW: i today i got game programming gems 7, so i have a lot of things to dig into :)

Rigid Body Physics #4

2008-02-16T09:41:00.000-08:00

hi, last weeks i created the physics engine with general constraints, and i though it will be fun to play with them a little, so i added more constraints to the system so i could build more complex systems with it.
the constraints the system support:
1. ball and socket - constraint two bodies to one common point
2. body to body - constraint point on one body to a point on another body
3. body to body with distance - same as 2 but maintain a specific distance between the points
4. body to world - constraint point on a body to be fixed on specific world position
5. body to plane - constraint a body to move inside specific plane
6. body to line - constraint point on a body to move along specific line
7. hinge - constraint point on one body to a point on another body along specific axis with angle limits.
8. universal - same as 1 but constraint an extra degree of freedom, if we specify one axis on body0 and another axis (perpendicular to the first axis) on body1 it keeps them perpendicular.
here is few movies that demonstrate few of the constraints in action:
NOTE: the movies captured in debug mode of the physics system so you'll see some lines and spheres that shows constraints info.

body to line

body to plane

body to world position

body to body

Hinge

Rigid Body Physics #3

2008-02-02T07:49:00.000-08:00

hi, still working on rigid body physics (not an easy task).
i have finished few constraints, (ball & socket, hinge and universal) fixed some collision bugs, improve stability and collision system.
with the new constraints i could start creating rag dolls (maybe next time),
to test the constraints i created simple rope simulation using few universal constraints, and some swinging light, real cool :)
i also added rigid body interactions with other entities like the bots and weapons.
for example: when we shot on a box, the box will be respond to the hit like a real box.
here is few videos that demonstrate the new features:

Weapons interaction

Skeleton of simple rope physics

Rigid Body Physics #2

2008-01-19T09:31:00.001-08:00

hi
i fixed some bugs in the physics engine related to inertia tensor calculations and collisions.
i also add it to my fixed time step scheme, so it will be more smooth.
while checking performance i found a bug in my particle system related to profiler sections, it seems that profiler section started but wasn't ended so it damaged the profiler (this isn't related to rigid body physics but because of this i added nice feature to the profiler so it will show me if sections are not closed properly).
anyway, i founded that my collision system needs optimizations (because of the mesh vs mesh collision), so i searched the net to find some info about generic convex mesh collision and i found something called: GJK algorithm.
i also so that its good to build AABB/OBB trees for the meshes for fast culling.
i already implement AABB tree in my engine for some collision testing at the beginning, now i found some useful area to use it.
as for GJK, i need to read more about it and see how it goes.
in my last update i uploaded screenshots, and its time to add some nice movie to show my physics in action:

Rigid Body Physics

2008-01-12T10:10:00.000-08:00

hi, i decided to add some rigid body physics.
there is a lot of physics engines out there that i could integrate into my engine, so i have checked few engines such as Agiea PhysX, newton dynamics and ode.
Agiea PhysX seems to be very fast and stable, and it comes with great sdk with tons of examples, so i decided to give it a try.
while trying t integrate i have founded that its not so great for me, because i already have very good and fast collision system that i'm using in my AI, projectiles,camera collision and more, so to make use of external lib i must change all the places that use my system to use theirs.
this wasn't an option because i need to check that everything that was working is still works after the change.
i could use their engine with my own systems but it required to duplicate the data, the scene for example must be known by both systems so they and mine could do collisions.
also, i just want simple physics and i wont even use all the features that Agiea PhysX support so i decided to write my own physics engine so the integration will be smooth and clean, this will take some time to do but i think its worth the a effort, i also will learn from the process :)
my physics system is impulsed based, that means that in order to move an object an impulse to act on the object on a certain point.
i choose to use impulsed base physics engine so i wont need to solve big linear equations system every frame, also i could give x ms for the physics engine and things that didn't solved correctly in current frame will get a chance next frame.
also in impulsed base, constraints system isn't stiff, that means the constraints is trying to be preserved by applying forces every frame/iteration, this is different from linear systems (implicit method) because if the system can't be solved (for example: one of the constraint needs very big forces to be preserved) the system will explode.
after reading some materials and got refreshed in my calculus, i'v started to wrote the engine.
i have finished the integration, also add simple shapes: sphere, box, cylinder
the collision system is also finished and support rigid body vs scene and rigid body vs rigid body collision.
for now each rigid body is a mesh, so the collision basically does mesh vs mesh collision, this simplify the things a lot because i don't need to a lot of collision functions based on rigid bodies type.
i also started working on few joint constraints: ball & socket, hinge and universal, next time i hope i will finish it and put some screenshots :)
here is few screenshots of the rigid bodies in action (wireframe mode).

box stacks

one of the stacks lost balance and fall

Per pixel lit particles

2007-12-22T08:41:00.000-08:00

Hi, i added nice feature: per pixel lit particles.
i can now set if particles emitter needed per pixel lighting via effects file, so this emitter will effected by scene lights.
the effect rendered with shader model 3, so i could gather more than one light and render the particles in one pass.
for example: if i create smoke particles and the particles goes through red light, the particles will get some of the red color from the light.
here is few screenshots:

left: unlit smoke, right: lit smoke

Under water effects

2007-12-22T08:33:00.000-08:00

I did some changes in the rendering order, because when i worked with scenes with water surfaces i notice that particles and decals effects doesn't rendered correctly under water, so few fixes here and there, moving fews functions to the right place fixed the problem :)
here is few screenshots:

under water blast

under water smoke

Weapons Lighting Effects

2007-12-13T03:46:00.000-08:00

hi, last weeks was very stressed because finally the baby comes out :) - yes i'm now officially a father, this i very new to me and i'm trying to adjust myself to the new situation, can't tell you how happy i'm, this is amazing feeling :)

for now i'm finding few minutes here and there so this new update i just a new feature i added to the effects system, this feature allow you to create and attach dynamic light to specific effect.
for example: when you fire your weapon you see the muzzle flash effects a small area around it, this is because the muzzle flash is a real light and it lights the area around it.
to create this realistic effect i changed effects script and add dynamic light with small radius for x milliseconds for the muzzle flash effect, this way the area near the flash will be lighted.
i also changed rocket effect so it will create light attach to the rocket and cast shadows.
here is few screenshots:

muzzle flash lights the area around

muzzle flash lights the character

rocket cast shadows and lights the area around

Freezing the scene

2007-12-01T10:20:00.000-08:00

hi, it became very difficult to debug AI and effects, so i thought it will be nice if i could freeze the scene and move with my camera to see things from closer view.
so i added the new feature along with few options:
1. freezing the scene and get a free camera so i could move around, good for debugging effects from different view.
2. do one update step so i could see how things get updated, good for AI debugging.
3. keep my free camera and let the scene updated for a while, good to see how bots moves and fight.
here is few screenshots that couldn't be captured without freezing the scene.

Input Manager

2007-11-25T05:19:00.001-08:00

Input manager is not the main thing you need but its certainly a thing you should have, and its not so complicated to do, so i created input manager class that will handle questions like:
IsMouseButtonGoingDown/Up? IsMouseBottunUp?
IsKeyGoingDown/Up? IsKeyDown?
the 'going' notation is to indicate that we want to know if specific action is about to be triggered, for example: if we want to know when specific key is pressed, we use IsKeyGoingDown, but if the key already pushed and we want to now when we released him we use IsKeyGoingUp, at last if we want to perform some action as long as the key is down we just use IsKeyDown (same for mouse functions).
the input manager uses directinput8 to communicate with hardware devices such keyboard, mouse, joystick (for now i'm using only keyboard and mouse devices).
i also add support for keyboard layout, which allow me to distinguish between different input languages, so now you can type in other languages besides english.
still, i need to match the right font file in order to see the right characters, but this is just a matter of exporting new font texture.

Weapon Effects

2007-11-24T09:35:00.000-08:00

i'v just finished setting weapons effects script.
i added muzzle flash effect per weapon, each weapon have its own muzzle flash effect.
for example: machinegun flashes different and more frequently than shotgun, shotgun also lives some smoke after the shot.
impact effect also added per weapon, each weapon bolt/projectile lives its own mark and create different effect.
for example: rocket effect is the most complicated, it creates smoke trails, fire trails, heat effect (because fire and smoke), sparks and rocket flash.
i also worked on weapon handling, when weapon clip is finished reload sequence is started so you cant shot until finished.
here is few screenshots:

reload and impact effect
note: the red color on the weapon is the gui that
shows how much bolts you have

shotgun - muzzle flash

machinegun - muzzle flash

HUD

2007-11-23T11:02:00.000-08:00

hi, recently i have worked on game play, one of the things i'v added is hud (heads up display).
at the bottom of the screen you will see which weapon you are using, how much ammo left, health and armor, also when your are hit by something you will see red mark on the screen that will fade out.
the hud is based on the gui system i was worked on, while adding the hud i found couple of bugs in the gui system, some of them was critical, but i fixed them :).
until now, all gui rendering was handled by id3dxsprite interface, and gui elements didn't have full material like i'v used on 3d surface (they have just the texture so i could display it).
one of the changes i'v done was the removing of id3dxsprite interface from gui renderer and adding my own sprite renderer with specific gui shader.
i also removed the texture and add full material support like i'v used on 3d surfaces, so each 2d gui surface will support all the features on 3d surface material.

Flashlights

2007-11-10T04:16:00.000-08:00

hi
i always liked the cut scene in games when you see few agents walking in a dark room and you see their flashlight moves.
flashlight is really cool effect i wanted to add long time but i always had something more important to add, last week i finally add it.
to polish this effect i added flashlight beam/volume to create the illusion of volume lighting, and last thing - every flashlight cast shadows.

flashlight volume/beam

correct order

top view - player flashlight is off so no shadow

top view - player flashlight cast shadow

Soft Shadows continued

2007-11-03T05:23:00.000-07:00

like all shadow map algorithms, VSM also suffer from something called light bleeding (instead of shadows you will see some light color pops at the middle), this is due to the fact that its a probabilistic algorithm.
when the variance over a filter region is high we probably see light bleeding artifacts, we more likely to see LB in scenes where depth complexity is high.
the good news is that VSM have a lot more advantages than disadvantages if we compare it to other pixel based shadows algorithm, also we can reduce the light bleeding issue by doing a smoothstep with the variance value and some threshold.
some of the advantages:
1. we can use mip maps on the "shadow map" texture (the variance map).
2. we can blur it like regular texture blurring (no pcf needed), and because of that we can use hardware filtering so as linear, anisotropic etc.
3. we can get good soft shadows a lot faster and smoother than using pcf.

i have added softness for both spot and point lights, point light is a little bit tricky :)
here is few screenshots:

no soft applied

with soft applied

no soft applied

with soft applied

Soft Shadows

2007-10-27T12:12:00.000-07:00

i have added soft shadows using variance shadow map (VSM) for both point and spot lights, i also convert shadow code to use this new shadow technique because stencil shadows is fill rate/cpu intensive, especially for dynamic scene.

Different Head

2007-10-20T05:39:00.000-07:00

hi
i fix huge bug in md5 model, it seams that when i converted it to the new design i forgot update the transformation matrices (of the bones) after loading the mesh so every model that didn't had animation controller or bind animation will be wrong and distorted.
i found this while trying to add different head models (to same body model), and i so that the transformations matrices was identity!
here is screenshots marine model with different head:

Dynamic Fluid on GPU

2007-10-13T10:42:00.000-07:00

hi
i'v added dynamic water/fluid interaction on GPU using 2 render target and simple wave equation, so when you fire on water/fluid surfaces you will see the waves the bullet cause.
here is a screenshot:

Water surfaces

2007-09-29T09:18:00.000-07:00

hi
a lot of features and bug fixes, one of them is water surfaces.
i'v added water surfaces at the beginning but there was no lights interaction with it, i just rendered it last and it doesn't looks real, one of the main changes i made is recreating the material system so each material stage could use different shader, also each shader need to have few techniques if light interaction is needed.
after all shaders recreated for this new material system, every surface in the game could define how light interaction will effect the surface, so water will effected by lights.
i'v also fix refraction mask generation, i'm using ambient pass to generate refraction map, after that i'm rendering water surface into alpha channel of this map so i could mask pixels that doesn't need to be effected by water pertubation effect.
here is few screenshots of water inside the game.

ambient and point light

flash light interaction

refraction (close look)

Soft Particles

2007-09-15T10:56:00.000-07:00

hi
one of DX10 features is the ability to read from depth buffer, in DX9 you can't do it unless you are generating it by yourself and pass it as texture.
in my ambient pass i'm using multiple render target, one for color buffer and one for depth, after that i'm setting it as texture and use it when needed in the pixel shader.
for soft particle effect, i'm reading the depth value from depth buffer rt and compare it with particle depth, then i'm compute new alpha value based on the difference between those values, (closest particle to level surfaces = more transparent).
here is few screenshots of the effect.
i marked in red the area the particles intersect with level surfaces.

MegaTexture

2007-09-08T05:01:00.000-07:00

hi
after seeing id tech 5 mega texturing, i though how the heal he did that?
so i start digging and reading a lot about clipmaps and streaming and i succeeded creating mega texturing.
to create the huge textures i'm using L3DT (pro trial version) i'v created 8k and 16k, the 16k texture took more than 12 hours to complete and with 5 mip levels its takes 1 giga.
my computer have only 1 giga ram so it's not impossible to use this texture in system mem.
here is few screenshots showing the difference between using mega texturing and not.
note that this is just sample app using engine features but for now its isn't integrated inside.
the app uses 16k streaming texture with about 20 mb gpu mem.
the fps difference is big because mega texture ps takes 74 instructions (not optimized)

using mega texture

not using mega texture (very blurry)

Fixed time step

2007-08-12T01:48:00.000-07:00

hi
i have added fixed time step with new interagor (midpoint or rk4) to the physics simulation (objects movement), until now i used the frame dt with euler (yes euler - very lame) integration and the results was very bad, the movement was very jerky (very noticeable when fps goes down and up during the game).
the problem is this, when we are using numerical integrations the result depends on the dt, the larger the dt the less accurate result we get, so if develop our simulation to run at 60 fps (dt = 1/60) and at some point the frame rate drops to 10 fps then the result we get is very inaccurate and results very odd movement (or even exploding), this is true for advance integrations as well - verlet, midpoint, rk4 etc...
with the new fixed dt, i assure the physics simulation runs at the same speed as the display frame rate (sync with it), so if the display frame rate is 30 fps and the physics design to run in 60 fps then we need to do 2 physics steps for every display update to make physics in sync.
i also added a final touch that interpolate between 2 physics states (previous and current) based on some alpha.
interpolation is needed to handle cases when the physics frame rate is not divided by display frame rate (without a remainder), for example the frame rate is 50 fps and the physics is 60 fps, so every frame the algorithm will have to alternate between 2 physics steps or one, this will be good enough to keep it in sync but visually it looks jerky.

GUI Screen shots

2007-08-04T10:10:00.000-07:00

Outdoor scenes

2007-07-28T11:00:00.001-07:00

hi, a a lot of updates i have integrated the GUI on weapons, also add option to add terrian models to map, see pictures below:

GUI Continued

2007-06-24T02:15:00.001-07:00

hi
there is a lot of updates, the must important ones is: events and if expressions.
here is the list of events supported by the system:
onTime - Runs the event at T+ milliseconds.
onMouseEnter - Runs the event when the mouse enters the window rectangle.
onMouseExit - Runs the event when the mouse exits the window rectangle.
onEnter - Runs this event when the user presses enter.
onEnterRelease - Runs this event when the user lets go of the enter key.
those events are must if you need to do some hover effects, or press/release button actions.

if expression adds a lot of freedom when you want the gui stay small and responds to other gui variables, controls properties or game cvars.
for example:
windowDef Desktop
{
rect 0, 0, 640, 480
background 0, 0, 0, 1
float "fTest" 0
OnMouseEnter
{
if ("desktop::fTest" == 0)
{
background 0, 0, 0, 1
}
if ("desktop::fTest" == 1)
{
background 1, 0, 0, 1
}
}
OnEnter
{
set "desktop:fTest" "1"
}
}
this simple script creates desktop window with 680x480, black background and one variable called "fTest" (initialized to zero)
when the mouse enters window rect it changes the background according to "fTest" value,
because "fTest" is zero, the background will stay black everytime the mouse enters.
when we press the enter key, "fTest" will set to one, and now if we move the mouse into window rect the background will change to red.

i also added more controls:
ChoichBox (choichDef) - A window that allows the user to toggle between a few different choices.
ScrollBar (sliderDef) - The volume control is a scrollbar, as are the scroll bars in listbox windows.
ListBox (listDef) - A window that displays a list of items. support multi column and alignment for each column.

i added cvar property to few controls (editBox, scrollBar, choichBox), which is the cvar to attach to. It displays the value of the cvar, and changes the cvar when the user changes the value of the control.

i also fix few issues with font scale rendering,
id uses 3 sizes for each font type and store it in 3 files fontname_12/_24/_48.extension,
the textscale property of the controls used to determine which font file we should use and in what scale to render the text.
(1) if textscale less than or equal to 0.3 use font file with _12 (font size 12 pixels)
(2) if textscale larger than 0.3 and 0.6 or less use font file with _24 (font size 24 pixels)
(3) if textscale larger than 0.6 use font file with _48 (font size 48 pixels)
after we know which file to use, we compute the render scale of the text we want to display, this is by checking the value of the textscale against the range it falls in, for example
if textscale is 0.3 we know from (1) that we need to use font with size 12, and the render scale is 1.0 because the range of (1) is [0, 0.3] and 0.3 is 100% of this range.
if textscale is 0.15 the render scale is 0.5 because 0.15 is 50% of this range.

i also changed my font files generator tool to:
Bitmap Font Generator v1.8c by Andreas Jצnsson (www.AngelCode.com)
it take less space when using fonts with large sizes such as 24 and 48.
this tool make sure every black area will be filled with the right character and not just putting the characters with equal distance between them, for example the characters '_' and '-' will take 2 areas of size 48 in the old tool, and with the new they take hardly one area, it basically compute character rectangle and fit it where he can by keeping track of empty and filled areas inside the texture.

More on GUI

2007-04-28T09:10:00.000-07:00

hi
in the last weeks, i was working on the gui, it is more complicated then i thought but i'm now supporting almost all the features. the best way to explain what this .gui file can do is by giving an example so here is one:
windowDef Desktop
{
rect 0,0,640,480
backcolor 0,0,0,1
visible 1
windowDef raven
{
rect 120,40,400,400
visible 1
background "gfx/guis/mainmenu/raven_1"
matcolor 0,0,0,1
}
}

the system based on nested windows and events. there is one top level window called 'Desktop' then one or more windows that are 'children' of the desktop, then zero or more windows that are children of the children, etc... (every window/event has it own params)
here we define the top must window 'Desktop' positioned at 0,0 with size of 640 n 480 (width and height), we set his background color to black and make sure he is visible.
we then create a second window, which is child on desktop positioned at 120,40 with size 400,400, make sure this one also visible and also set his background image to some texture.
'matcolor' is texture color, so here we set it to black so later we could create a transition effect so it fades in and out.
the lines below define transitions on texture color of raven window (they should be inside 'Desktop' brackets)
windowDef anim_credits
{
rect 0,0,1,1
visible 1
notime 0

onTime 0 {
transition "raven::matcolor" "0,0,0,1" "0.839,1,0.658,1" "1000" ;
}

onTime +3000 {
transition "raven::matcolor" "0.839,1,0.658,1" "0,0,0,1" "1000" ;
}
}

ok, i said we could define some events so here we define the 'onTime' events which runs the actions/sets inside is brackets every T+ milliseconds, the timeline isnt static so we reset it with 'resetTime' command.
inside the first 'onTime' we set new transition, transition linearly interpolates a variable from one value to another over time (in milliseconds), so what i do here is to interpolate between texture color of raven window from 0,0,0,1 to new color 0.839,1,0.658,1 over 1000 milliseconds (one second), after 4 second we create new transition which linearly interpolate between the new color to black. you can also define some local variables inside each window so instead of writing and duplicate certain values you could define some at first and use them later, for example: you can define those vectors as global by declaring them on 'Desktop'
definevec4 "new_color" 0.839,1,0.658,1
definevec4 "org_color" 0,0,0,1
then you can write:
windowDef anim_credits
{
rect 0,0,1,1
visible 1
notime 0

onTime 0 {
transition "raven::matcolor" "$desktop::org_color" "$desktop::new_color" "1000" ;
}

onTime +3000 {
transition "raven::matcolor" "$desktop::new_color" "$desktop::org_color" "1000" ;
}
}
when you have a lot of transitions this is more readable and generic if you want to change the color to some other value, you just change the variable value and the rest works fine.
note the $ sign, this tells the system its a reference to some variable.
ok, this was a crush course about some of the cool things you can do with .gui files.
what i have left to do is some fixes here and there and also adding other events and controls such as sliders and lists.
here is some screen shots:

GUI files

2007-04-07T10:40:00.000-07:00

hi
this week i added GUI so i could use it for displaying hud/weapons ammo/power ups etc.
id uses .gui files which basically a script that allows you to define elements to display on the gui such as windows/text boxs/images etc, you can also set there properties like rect, color, text, font and more - this is very easy and fast way to create GUI's.
after you have the GUI script you can render the GUI on a 3d surface in the game.
for example: you can use it to display player info like health, power ups (on 2d screen), or on 3d surface of a weapon to show ammo info.
here is a screen shots of .gui files from id quake4 folder that i'm loading from my engine, for now its rendered on the screen, but next time i will show it inside the game.

railgun.gui

machinegun_inview_scope.gui

Bitmap fonts

2007-03-31T08:51:00.000-07:00

hi, long time i didnt post anything because i didnt had time to.
after i return from my vacation in the far east, thailand - amazing country, i needed couple of weeks to return to the real world :)
ok, now the weapons works fine, but in some weapons the ammo left should be rendered in specific place on the entity model.
id defines something called entitygui shader for surfaces that should be display gui, so what i'm going to do is to support this cool thing.
i'm supporting the shader definition, so now all surfaces with entitygui shaders suppose to render their gui on that surface (texture)
i also added bitmap fonts, until now i use d3dxfont lib but it is not so fast and i cant render textured characters.
to genrate font data i'm using: bitmap font builder by thom wetzel.
next time i hope i will finish some gui controls.

Profiling stuff

2007-02-18T04:40:00.000-08:00

hi
i didin't have time to add new features, instead i run the game on few maps and do some profiling, and i saw that on some maps the fps drop down to 20-30 fps - what the...
at first i thought its the rendering, but after checking the profiling data i saw its the bots update function, i checked it out and see its the skinning stuff :(
well, in the beginning i wrote some slow functions just to make it work and now its coming back, so i think i will need to rewrite those functions and add some asm code.
in the next 3/4 week i wont updating because i will be on vacation :)

First person mode and torso,legs synchronization

2007-02-10T09:56:00.000-08:00

ok, first updates from last week.

i added synchronization with torso & legs to allow the bots to aim at direction x and walk in other direction y, this is very important when the bots fight (because if the bot could not do that i will looks very robotic).

this week i added first person mode, which is better than third person if you need very accurate aiming, i also synchronize the animation with the third person mode so when you look at mirror you see yourself.

here is few screen shots: