Addicted engine developer

2011-12-10T07:19:00.001-08:00

I moved this blog to www.glow3d.com/blog. New blog is built on Wordpress and hosted on the same site as www.glow3d.com. I think Wordpress is more convenient and if you interested, please subscribe to www.glow3d.com/blog.

SSAO: First steps

2011-12-08T09:14:00.000-08:00

Today's results - fancy Screen Space Ambient Occlusion!
It searches pixel's surroundings to check pixel's occlusion, after
that blurs results and blends with the screen.

Video with a water:

Some additional effects like Light Scattering (God rays ) remains to implement
and I can finally start work on the game!

Finally water!

2011-12-06T08:38:00.001-08:00

First stage of water with reflection and refraction in Glow engine. Plus HDR, Antialiasing, Color Corrections and Gamma Corrected (Linear) Rendering.

New day - new picture with house )

2011-12-02T10:19:00.000-08:00

Playing with combination of atmospheric scattering, light
intensity, dynamic sun and time of day.

Atmospheric Scattering

2011-12-01T09:36:00.001-08:00

Atmospheric Scattering was added (restored) today. It's dynamic and renders beautiful sunsets and dawns. Special values added to Scene properties - Time of the Day (0..24, in hours), Length of the day ( in hours ).

HDR finally done

2011-11-30T08:45:00.001-08:00

fuuuf .. 4 months without updates.

I returned to HDR, finally cracked it. It's probably
not so very efficient now, and I will return to it later.
It uses 64bit float render targets, bloom, all standard.

2011-06-16T03:43:00.000-07:00

Current state of editor.. several tasks to finish alpha version..

Color transformations

2011-04-04T01:40:00.000-07:00

Color transformations as Post-Process is added into Glow engine.

Currently supported transformations are contrast, brightness, black and white, red, green, blue shifts, saturation will be added later. All transformations work in a same step, so adding, for example contrast to brightness will not slow down it in 2 times.

Transformations added as scene property, and can be accessed from script.

Image:

Adjusted brightness:

Blue and Green shifted, to create Matrix movie look

Black and white:

Antialiasing

2011-04-04T00:57:00.000-07:00

Antialiasing is finally implemented in Glow engine.

It's implemented by Directionally Localized AA algorithm,implemented in The Force Unleashed 2. It's operates in image space and works as post-process, finding edges by High-Pass filter and blur it with 5x5 (and 16x16 for long edges) kernel.

Looks cool .. my images long time suffered from jaggies .. not now)

Antialiasing is off:

Antialiasing is on:

NPC with several lights

2011-03-21T02:58:00.000-07:00

More pictures from Sponza model

2011-03-10T07:06:00.001-08:00

Lion by Glow engine

2011-03-09T08:05:00.000-08:00

Just screen

2011-03-03T00:12:00.000-08:00

Little by little engine becomes usable after various changes (as usual it need to be completely rewritten after reading about some interesting idea :)). Last ideas were concurrency, memory debugging,fragmentation and reference counting. Anyway, it improves engine, makes it safer and usable.

Screen from "Deadly light" demo:

Debugging in Glow Engine

2011-03-02T03:06:00.000-08:00

It's very important to display debugging information about your level or models during developing game level. Previously, I used 3ds max to place all objects, including lights and it was not easy task. Tweak lighting in 3ds max, switch to engine, check lighting etc...

Now several debugging modes are supported in Glow engine - wire-frame mode, displaying normals in world space, depth of pixel, lights, physics, AI (triggers), navigation meshes.

All modes can be used same time (except normals, depth and diffuse color), button "layers" should be pressed and mode selected.

Room from "Deadly Light" demo, lighted with 6 lights:

Same room in wire-frame debug mode:

Normals mode:

Lights debugger:

Physics:

Depth:

Site is updated

2011-02-20T23:20:00.001-08:00

www.glow3d.com is updated to reflect all recent changes.

TBB adopted

2011-02-02T00:22:00.000-08:00

Embedding of Intel Threading Building Blocks is finished, really good library with many abilities.

Development of a concurrent scene graph is started, scene graph (sectors - portals) was made templated, to hold different types of objects and it supports now read-only access from several threads (or tasks). Also several modules of engine have copy of the scene graph - renderer holds scene graph with visible objects, physics - with physical to optimize simulation.

moving to Intel Threading Blocks

2011-01-30T21:22:00.001-08:00

deeper and deeper into concurrency and multi threading...

I have decision to use Intel Threading Building Blocks instead of experimental boost::thread_pool. All computations in the Glow engine are organized into tasks and theoretically would scale well when number of hardware threads (CPU cores) will be increased.

Previously, I used boost::thread_pool for task execution. Now, when I returned to concurrency, I realized that usage of boost::thread_pool is not scalable, because it heavily uses mutexes (spin-based). Later I will launch tests to measure scalability of both methods and post results here.

2011-01-26T17:42:00.000-08:00

I am thinking about concurrent scene graph.

The are several modules in the engine, which needs queries to the scene graph, like Physics, Audio, Render. Moreover, in the future, several threads (tasks) inside of module will need concurrent access to the scene graph.

There several options how to do it:

1) copies of scene graph in every module (used also in OpenSceneGraph engine)- needs more memory, but should hold different types of objects - Physics module will hold only physics objects etc. Still it does not resolve problem with concurrent access in the future

2) concurrent containers in the scene graph - maybe the best solution, but currently I can not find best fit for it. Also looks like it hardware dependent and not robust enought. There is Intel Thread Building Blocks library with concurrent containers, but it's not perfect and doesn't support Android and iOS.

3) mutexes to isolate queries. Usage of mutex is not good thing for scalable multi threading, but maybe for some usage patterns it's ok. In my case it's SINGLE PRODUCER MULTIPLY CONSUMERS model.

Can anyone suggest robust cross platform concurrent containers (hash_map or vector at least) ?

excellent blog http://www.1024cores.net about concurrency and scalability.

UPD: I was wrong about Intel TBB, it's cool and powerful library. It's not clear now for me, how to use it under iOS or Android, but it's Open Source and ports are available for different platforms.

2011-01-23T07:14:00.000-08:00

High Dynamic Range lighting with eye adaptation is implemented in the Glow engine. Plus gamma-correct rendering. Plus Color Transformations (hue, saturation, brightness etc) were started.

2011-01-17T00:27:00.000-08:00

Memory Management in the Glow engine

Memory management is very important thing in a console world. We can forget about it on a PC (at least for several hours without leaks, but consoles are restricted, so we should consider that after some time, allocation of memory will return NULL (or exception, depending on compiler). Also fragmentation is serious problem after allocation of many small objects. So with the plans to move on mobile devices, we decided to develop system for memory management.

New memory manager is implemented for Glow engine. Separate optimized singlethreaded heaps with pools for small objects for every module of the engine (physics, ai, navigation, sounds etc) are added instead of the single common C++ heap.

Special heap for transferring messages between modules, memory leak debugging, shared pointers (boost c++ library) for memory arrays.

Allocator for STL containers was implemented, so every memory allocation in the specific module goes from the module heap. STL containers and strings are evil force of a memory fragmentation, so process for removing every STL container from code is started. Some vectors are replaced by special Stack vector container, based on boost::array with restricted dynamic grow. Also major part of constant std::string was replaced with const char* equivalent (with memory allocated from constant string pool) and "copy on create if exists" usage.

Memory debugger UI, with rendering of memory fragmentation, information about allocated blocks - count, amount, overhead.

Remaining part for the memory manager implementation - garbage collector for Geometry.

January release date was very optimistic, so we moved release of alpha version to Spring, 2011. Major parts are ready, but there are many small task to polish editor and engine.

2010-12-30T02:28:00.000-08:00

I am working currently on memory management for the engine, done a lot..later about it in details..

now about arrays. Everybody knows, that dynamic allocation is bad thing, especially in optimized applications. Fragmentations, locks, time to find free block etc. General advice is to avoid any kind of dynamic allocation in update loop. So I decided to remove it everywhere and move all dynamic data to the stack.

There were many std::vectors, std::strings in the source, around 700 cases of using std::string, same for vector. Firstly I changed vector into C arrays, but it's not convenient to use. After that I found boost::array, but it's not dynamic.

So my decision was to create mix of boost::array and std::vector, it's based on sources of boost::array, but has ability to dynamically grew (one additional variable m_size).

Useful and looks optimal.

UPD. maybe not so optimal for complex objects with not simple constructors and also for big object, but optimal for pointers and simple types.

SIGGRAPH Asia 2010

2010-12-20T01:14:00.000-08:00

I visited SIGGRAPH Asia 2010, it was interesting. Several courses was attended, number of interesting people was met. Tessellation is still hot theme, it was discussed heavily in DirectX 11 and OpenGL 4.0 courses. Also Realtime Ray Tracing and stereoscopic rendering.

Post processing pipeline started

2010-12-15T08:08:00.000-08:00

Previous week was spent on post-processing. Pipeline is implemented in the engine now. Also motion blur done as post-process (built from Geometry Buffer, described here ) and can be safely disabled. My paper library became useful.

This motion blur goes from camera movement, per-object motion blur will be implemented later (per pixel velocities will be saved in Geometry Buffer).

Motion blur in action, kernel from 15 samples:

Original scene:

Several post-processing effects are scheduled - glow pass (blur bright parts of the scene),

Analytical Anti-aliasing, Depth of Field and more.

Mirrors and reflections (deferred) are started.

2010-12-12T20:32:00.000-08:00

very inspirational reading, Shishkovtsov is smart guy

http://www.eurogamer.net/articles/digitalfoundry-tech-interview-metro-2033

especially deferred reflections - so simple idea to make reflections in deferred shader! just render reflected attributes (position, normal etc) into Geometry buffer and draw as usual.

also I am thinking about implementation of Exponential Shadow Maps after reading it.

I read the article half of year ago and have rewritten engine significantly after that. Thread pool was added, engine was detached into several parts etc.

Update

2010-12-05T11:07:00.000-08:00

Plan for November for Editor development was over-fulfilled. Over 30 tasks was implemented in time.

New features:

editable scaling
asset preview for sounds, scripts and textures
skyboxes (simple, without any dynamic)
new gizmos for move, rotate, scale entities

Normal texture trick

2010-12-01T04:58:00.000-08:00

I found interesting trick for accessing normals from textures.

Capcon's DXT trick - http://code.google.com/p/nvidia-texture-tools/wiki/NormalMapCompression

Shortly, it allows to use DXT1 and DXT5 bump textures with same shaders.

It's important for editor because bump texture in DXT5 will be ready only at the last stage -

game packaging. There will be small difference in object appearance during in-Editor testing because DXT1 is not good for normals, but I think it's acceptable.

Auto-reloading resources

2010-11-22T23:17:00.000-08:00

Auto reloading resources are implemented for the Editor. Scripts, textures, models (by background thread, thus not stopping work), shaders are loading automatically after switching from editing application (Photoshop, 3ds max etc) into Editor.

Also - camera manipulation - zoom to selected objects, top, bottom, left, right, front back view of selected objects. UI for edit assets in external application (defined by OS), opening resource location in the Explorer, import from Assets window.

Big face on landscape

2010-11-18T08:45:00.000-08:00

During testing new features of the editor, I set landscape texture to random photo. Interesting effect, to walk on gigantic face!

New features are:

import of 3d models from FBX file by Autodesk FBX SDK
tracing of landscapes by tracing of heightmaps (faster then tracing actual geometry)
assigning of materials, scripts, audio files to objects by dragging from Explorer or Assets window
Scripts - editing by Notepad, assigning to object, removing.
Depth Pass before Geometry Buffer Pass, for Deferred Shading
Current insertion position, for cut-copy-paste

2010-11-05T09:38:00.000-07:00

Weekly editor image.

Deferred shading restored, shadow maps, landscapes

by clipmaps, translation and rotation of entities by

mouse with restriction by selected axis (x, y, z).

Plan for the next 2 months is prepared, to complete first version

of editor and engine.

editor status

2010-10-25T01:16:00.000-07:00

Editor is developing very fast. A lot of things are complete - window layout management, editing of object's type, assets management (drag and drop assets to scene from asset tree, renaming, deleting etc), project save/load etc.

Next week I will prepare video.

I see light at the end of the tunnel ))

2010-09-30T03:10:00.000-07:00

Some progress with editor - project loading/saving,
list of assets, list of entities, property editing. All by in-game
3d ui with undo/redo.

vacation

2010-09-27T19:19:00.000-07:00

I am back from 3 weeks vacation... 5 countries, 11 flights.

Started project management for Editor.

Editor features

2010-08-24T22:02:00.000-07:00

New features added to Glow engine editor during last week. Previously, all level geometry was created in 3ds max and imported into game engine. It's not convenient (and not cheap) way of editing game level, so development of Editor was started.

After week it has next features - drag and drop meshes from Explorer (currently OBJ format, more later), simple Asset manager, executed as job (in parallel thread), so parsing 3d meshes will not stop UI.

Also Undo/Redo is implemented ( with boost functors ). Currently it works for move/rotate/scale, delete/insert, select. Objects can be linked to landscape, so, for example, building and trees will be always on the ground. Rotation, movement will be in local or world coordinate system.

Next things to implement: building level, attaching scripts to objects, assigning materials by drag and drop from Windows Explorer.

2010-08-04T23:53:00.000-07:00

Long time ago i wrote function, which creates quaternion for rotation from 0,0,1 to any unit vector. Function was very long, contained asin, acos, several conditions etc... So today i returned and after some time:

// dir should be unit

void Quaternion::from_direction(const vec3& dir)

{

x = dir.y;

y = -dir.x;

z = 0;

w = 1 + dir.z; // simplified dot product with 0,0,1

normalize();

};

Editor UI

2010-08-02T22:38:00.001-07:00

Finally returned to editor development.

Editor UI will be written by Lua scripts.

I started my UI from simple and usable source of Recast library,

For example, button usage:

if ( imguiButton("Start game") )

LoadLevel("super-duper mega Quake level.mdl")

this is button creation, displaying and logic in one place. After

years on Windows it was amazing!

I mapped API into Lua script language by luabind library, and

now UI script code looks like here:

if object_selected then

rollout( "Object", 0, 0, width, height )

show_object_properties()

if collapse("physics", true, true) then

show_physics_properties()

end

if collapse("visual", true, true) then

show_visual_properties()

end

if collapse("script", true, true) then

show_object_script()

end

end_rollout()

end

2010-07-28T10:28:00.000-07:00

I prepared site for the engine: www.glow3d.com

3 days with CSS, html and Photoshop.

Feature list

2010-07-22T00:15:00.000-07:00

I made the presentation of engine features.

It can be viewed here

2010-07-06T23:26:00.000-07:00

I spent a month on refactoring of engine.

It's became so big, I can not serve it in my little brain.

So I detached it into small pieces, like physics, sound,

networking, core, ai, ui, archive, prepared solid interface to

access features of engine (which will be visible for users of

engine). Also put all pieces into dll, and prepare abstract

interface for every module to clearly isolate it.

Also the thread pool (boost::threadpool) is added to execute jobs from modules.

So now engine will scale performance easily with more CPU cores.

Streaming

2010-03-12T00:29:00.000-08:00

To implement WebPlayer I had to implement streaming from Internet. Now it works, with additional layer for loading data.

Several types of data sources are supported:

1) usual file system

2) zip files

3) files from inet (http, ftp)

Last thing to implement - installer for ActiveX. I haven't decided yet, how to install it properly - by separate msi installer, or as usual ActiveX, by services of browser.

Альбом: Deadly light screens

WebPlayer!

2010-02-02T02:47:00.001-08:00

Today I started development of the WebPlayer for Glow engine,

and already have results! ActiveX, based on ATL is created,

engine is attached, and all it successfully tested in the Test Container.

Now it works only for Internet Explorer, later I will test Firefox

and Chrome.

Water

2010-01-31T20:20:00.000-08:00

First tests with water. It's based on the article from GPU Gems 2.

2 pass rendering:

1) render all without water - refraction pass

2) copy image to refraction map

3) render all from "reflected" camera position - reflect camera position relative to water plane

4) copy image to reflection map

5) render water with reflection and refraction map

comments for my game from IGF judges

2010-01-10T18:10:00.000-08:00

Here is comments for my game from IGF judges.

Completely correct, I just spent more time on a graphics

and programming than on game play and level.

so -> more game play and play testing, fresh ideas, design documents etc

Comments:

--

wow... I can't say I was expecting this. Fantastic opening intro with the 'kids' drawings. Very powerful!!!! It is very immersive.
Unfortunately the 3D world is poor, level design & use of lighting (both for Art + guide the player) are poor, and I think it would have desrved a better visual environment (it could have been isometric). I think interactions need to be facilitated in this type of games.

---

The introduction to this game was terrific and set a great vibe. Unfortunately the game itself didn't really follow through on this.

Visual art rated low mostly because of the level design - I found it extremely difficult to navigate the level, and points of interest were not at all clear. Would also have been nice to see the two important states of my family reflected on their bodies rather than via meters on screen (although the meters are also necessary).

Audio was not used to indicate the positions of interesting things, either - humans came up and attacked and I had no idea they were there until they were hitting me, and I had very little awareness of where my family members were.

---

The opening sequence is great, but the game loses steam after that. After the intro, I was expecting something sillier and more playful. Cow-slapping is fun and all, but it only goes so far. If the game harnessed more of the puckishness on display in the intro, it would be more appealing.

2010-01-04T22:40:00.000-08:00

I am improving my game design ability, did some brainstorming.

Already have around 80 gameplay ideas ))

I want to have clear picture of gameplay before implementing something.

After 2 or 3 project without gameplay at all ))

Here is my plan:

1) raw ideas in mind and pictures

2) design document

3) draft demo with simple graphics and animations

4) play testing

5) final graphics and animations

First horde tests

2009-12-24T02:36:00.000-08:00

Spent day for implementing steering behaviors for horde.

Recast navigation + avoid nearest neighbor (with prediction, OpenSteer style) + avoid near walls

Recast navigation + avoid nearest neighbor (with prediction, OpenSteer style) + avoid walls only after collision + avoid dynamic obstacles

It needs time to update nav mesh (usually nav mesh updated with 0.5 sec intervals), so sometimes bots can go throw obstacle. Maybe for moving obstacles I need to use same steering behavior as for another bots.

Does it look natural? Or need some enhancements?

2009-12-23T19:56:00.000-08:00

http://forums.tigsource.com/index.php?topic=8625.0 very funny about indies

2009-12-18T00:57:00.000-08:00

finally understand, what is Velocity Obstacle.
it's freakin simple ))

print of the source article helps a lot

it will be hordes of zombies!!!

Recast navigation + steering behavior + wall repulse force

2009-12-16T23:00:00.000-08:00

path following force + steering behaviors + wall repulse force

red line - path from Recast
grreen line - resulting velocity
blue line - wall repulse force

Simple steering behavior

2009-12-15T00:23:00.000-08:00

I added yesterday simple steering behavior
for bots. Movement became more realistic than
previous direct path following. Now bot has
velocity and acceleration, and it tries to move
along current path line.

Remaining task - dealing with walls (current bot position now
not exactly on the safe path), moving obstacles.

simple optimization

2009-12-13T18:23:00.000-08:00

If you have vector assignment in your code,
use Swap member function of std::vector, if
you will not need source vector anymore

it will save you one memory allocation

void SetPath_Dirty(vec3& path)
{
m_path.swap(path);
}

Lighting abilities of my engine

2009-12-09T00:33:00.000-08:00

Deferred shading (plus Doom3-like lighting for slow hardware),
more than 1000 lights (without shadows) possible simultaneously,
soft shadow maps for omni lights, attenuation maps, fog,
bump maps, specular maps, ambient etc.

Recast dynamic navigation meshes

2009-12-07T07:59:00.000-08:00

Some examples of using Recast dynamic navigation meshes in gameplay

Memory management

2009-12-01T01:47:00.000-08:00

Usually C++ uses linked list to holding free memory chunks, so searching for free chunk is not fast. Especially for small objects. So I decided to optimize allocating of memory using special pool allocator. All small objects in engine have base class, which get and release memory from pool allocator. 3x times optimization for memory allocation (small objects)

Look Andrei Alexandrescu Modern C++ Design and in details here

Loading of materials

2009-11-29T21:24:00.000-08:00

My previous demo had very long loading time (~4 min). There were many big textures there (usually 1024x1024), most of it in tga format.

To fix it, I changed format to dds, pack mips to texture and moved loading of textures to separate thread. Moreover, only near textures (~50 meters - engine parameter) are loaded and during moving, textures outside of that radius will be unloaded. Small versions of texture (64x64 usually) are used instead of full versions on a distance.

Results - 3-4 sec for loading current outdoor level (~800 000 tris), unlimited number of textures on a level, all in separate thread, important for today's multicore CPUs.

Ideas

2009-11-27T00:56:00.000-08:00

i broke my brain in search for fresh game idea. It's not so easy, as i think.

There is one stupid idea - a atomic bombing in details. In first part you will be pilot of a bomber, after that - civilian, escaping from town. Burning people, death everywhere. Something about how bad is it. Short game especially for IGF. Kind of interactive movie...

All in real 3D, with details... maybe for IGF in 2D, as they like ))

2009-11-26T01:33:00.001-08:00

Great article about indie game PR

http://gillen.cream.org/wordpress_html/?page_id=693

plus http://thegameprodigy.com/zero-budget-indie-marketing-guide/#more-118

Optimization

2009-11-25T02:17:00.000-08:00

During tests, my game has average 40 fps on GeForce 9600 with Intel quad core CPU.

That version was sent to IGF.

Several days ago I found, that all shadows on level are drawn every frame. After searching in source I found commented for debugging line of code, which increase speed twice! So fps becomes ~ 80. After switching off grass and NPC sensor system (which do search for enemies 5 times per second) fps becomes 400!.

So first of all I implemented correct instancing for a grass ( and cut off all cards without support of Shader model 3). Next step - faster sensor system for nps.

Now average fps is 160 but there are a lot of ways for improvement.

Little Zombie Susie gameplay

2009-11-08T20:01:00.000-08:00

First several minutes of gameplay

2009-11-05T02:05:00.000-08:00

i didn't show all gameplay in the trailer, just for a mystique.
But there are many things - puzzles, based on creating ways
for your npc, mines, automatic weapons, fights with humans,
eating cows etc in the game.
I will post pictures and videos here.

New video for IGF

2009-11-01T23:54:00.001-08:00

I hope to finish gameplay in near 2 weeks

first screen from my new game - Little Zombie Susie!

2009-11-01T12:18:00.000-08:00

Recast navigation plus Havok physics engine

2009-10-20T03:26:00.000-07:00

Demonstration of the Recast navigation plus Havok physics engine

Explosions and weapon for zombie

2009-10-16T06:19:00.000-07:00

Trying to finish demo for IGF competition (1st november)...

Winner!

2009-09-02T18:16:00.000-07:00

AAAAA! I am winner of Intel Level Up 2009!

First place in Best Game Optimized for Intel® Graphics

and second place in Best Threaded Game!

and judges was most famous game developers and designers on the planet!

http://software.intel.com/en-us/articles/levelup-judges/

Thanks, Intel!

2009-08-20T02:10:00.000-07:00

Here is my current demo (~50 mb).

It contains one level, more graphics than gameplay. I submitted

this demo for Intel Level Up 2009 competition. Try to find

cover before night, close doors, use boxes to build barricades.

Run "best threaded" shortcut for best graphics and "Intel graphics"

for integrated hardware.

I continue work on game, have found talented artist, implement

networking

Dynamic paths in Glow engine

2009-08-17T22:17:00.000-07:00

Here is how I implemented dynamic paths in my engine.
First of all I searched available path engines and
didn't find any acceptable. Some costs money,
some wasn't complete enough. Month ago I saw demonstation
of "Recast" library from Mikko Mononen. Library generates

correct paths from triangle soup by voxelization. I was very

impressed, so I downloaded it and added support for dynamic

objects.

Video:

2009-08-12T02:23:00.000-07:00

I will upload tech videos from "I know your Deeds"

This one about graphics.

Grass, trees, deferred shading,

dynamic sky, clouds, 3 landscape materials with weight map.

Landscape modelled in Phoshop using clouds filter, altered by

hand for house placement. Grass drawn by grass density map,

one per landscape, trees places on landscape in photosop also.

There is special bitmap for foliage, if you draw, for example,

red point, there will be tree in level. Shadows by shadow mapping,

not perspective.

2009-08-11T02:25:00.000-07:00

Today I finished game demo for Intel Level Up 2009,

it costs me 3 nights without sleep. Somethings remain

non implemented, but overall picture is good.

I will prepare big video and demo later.

here is small video about dynamic navigation meshes in

my engine

It's based on TileMesh, and fast. Building whole level (300x300) in separate thread in 5 seconds on single core PC, tile size 32. Dont look to fps, this is deferred shading plus old PC

here is how it works:

render static mesh, memorize static mesh
render dynamic objects, memorize objects per tile
when object moved, add tile of old box of object to update list
if not moved object intersects with updated tile, it will be added to updating tile
render updated tiles with objects 6) connect tile into mesh (recast lib)

My current game project

2009-07-17T00:10:00.000-07:00

I know your deeds challenges players to survive over the course of months and years, trapped in a city dominated by nightmarish zombies. While of course concerned with the ever-present threat these creatures represent, the player will face long-term concerns like obtaining sources of food and water, building shelter from attack, and the overall survival of the human race.
Game Mechanics:
The player begins in a village environment. A full day and night will take place over the course of 20 minutes, the proportions of which will depend on the time of year (i.e. More of that twenty minutes is day in the summer, less in the winter). During the day, the player enjoys relative safety from zombie attacks (at least outdoors), and those encountered tend to be lethargic and confused. Days are typically spent scavenging for supplies and building materials, constructing barricades and traps, and investigating scripted plot points.
Crafting
A crafting system exists in the game, in which players need to collect tools and materials to build and reinforce whatever position they've chosen as their base of operations. Stress is induced in the player as collecting these materials, building, and setting up the barricades and traps will take up more time than they have allocated in a given day, and the attacks that will occur all night wears down these defenses, requiring repairs the next day.
Sleep
Sleep also takes a major position in the game. If the player refuses to sleep, they will begin falling asleep while performing tasks, and generally perform miserably. Sleeping during the day is safer, but sacrifices critical time that could be spent building and scavenging. Sleeping at night means you may be rudely (and suddenly) awakened by a zombie chewing on your throat. Additionally, nighttime sleep is less restful, due to the loud noises going on outside. Going to sleep on a daily basis thus becomes a thing of terror, rather than relaxation.
Freeform
Unlike most survival horror games, there are very few scripted events in I know your deeds, beyond the seeding of background story information and certain key events which are linked to game timeline. The plot is developed by finding items which piece together a patchwork background story, eventually resulting in a method of destroying the zombies en masse. The player can ‘hole up' in any building they choose, and reinforce it as they can. Items and buildings are pseudo-randomly generated in a manner that makes each game unique, but also consistently playable and interesting.
Difficulty curve
As time goes on, more and more of the framework of society begins to fail (for example, initially the electrical grid may still be working, but will eventually collapse), creating an increasingly difficult environment in which to survive, and forcing the player to continually be allocating time to deal with these situations, instead of ‘base building'. Additionally, as time goes on, the zombie threat becomes continually more intense and ferocious.
End Game
The game ends when either the player can no longer handle the zombie threat and is overcome, or the player gathers the information and materials necessary to build a device which will end the zombie threat.
Author of concept - Angus McQuarrie, concept used with permission.

Engine:
The Glow engine delivers realistic environment, covers wide range of hardware (from cards without shaders to SM 3.0), uses multithreading, deffered shading, 3d sound, networking (up to 32 players), Havok physics. Full realtime day-night cycle. It has support for mobility - power indicator, messages about lo power.

My blog

2008-10-09T21:32:00.001-07:00

Здесь мой основной блог:
http://yak32.livejournal.com

первопост

2007-11-03T21:01:00.000-07:00

Хаииииии