Been thinking a lot about a 3D engine architecture lately (both for my self and work). I’m not completely satisfied with my own at the moment (and it basically lacks a proper renderer). However, I always get stuck in designing hell (too many monologs). Thankfully Jason Gregory recently published his book Game Engine Architecture, and after finishing the totally awesome “Uncharted 2” I’ll swallow anything he has to say on the subject hook, line and sinker.

OpenSceneGraph seems to be fairly popular, but I always feel like it’s a bit old in the way it works. I’d definitely want to use GBuffers and separate the scene graph from the actual renderer. Especially with all the cool stuff Crytek is doing.

Also I’d like for my project to be cross-plattform enough to work on an iPhone (using some kind of abstraction layer for graphics). Have to verify that boost works though as Clang isn’t very comfortable with advanced C++. And I love my templates.

In my list of possible candidates, I have included both full-fledged game engines aswell as 3D rendering engines. In this article, I will outline the differences and decide which of the two that suits this project the best.

What do I need?

Before I start, I think it makes sense to state what needs I have.

The primary goal is to bring an open source visualization solution to a CAVE-like environment located in Lund, Sweden. This is because our current system doesn’t allow us to visualize human beings, which we want to accomplish with Skeletal animation.

The visualization solution must be able to provide support for

• A variety of input controllers
• Head tracking
• Stereoscopic rendering
• Windows XP
• Clustering / Parallel rendering via Ethernet
• Skeletal animation
• Audio
• Physics & collision detection

3D rendering engine

Definition

A 3D rendering engine’s main purpose is to provide a general solution for graphics rendering by giving the programmer an abstraction layer to the underlying system libraries, e.g. OpenGL, Direct3D.

Pros

Freedom. You can choose whatever other libraries you want, and you can restrict them to contain only the ones that you need.

Cons

You yourself have to make every different part of your ad-hoc game engine work. That could mean that you spend a lot of time just making the different subsystems talk to each other.

Game engine

Definition

A game engine consists of all the things you need to build a game. That is, most notably, a 3D rendering engine, sound, networking, AI, collision, physics etc.

Pros

When everything is bundled together like they are in a game engine, it makes the job easier for me, the developer. I can therefore spend my time with coding the actual application.

Cons

By design, you are more restricted using a game engine. If you want to make your own life easy, you more or less have to stick with the various tools that are in that particular game engine.

Discussion

There seems to be less trouble involved with picking a game engine over a 3D rendering engine. You get all the libraries you will need and in the best of worlds: it just works.

However, I have been eyeing a 3D rendering engine that seems to be quite capable. That said, it might be interesting to try and see how long it takes to get various subsystems integrated.

Posted on http://www.ddj.com/go-parallel
Silverlight 3 doesn’t offer native support for loading and rendering 3D models. However, Balder, an open source project, offers a very complete managed 3D engine for Silverlight 3. It achieved the necessary frame rate taking advantage of Silverlight’s threading capabilities.
Read more here

I’ve just installed Python and Panda3D, then realised that… …Panda3D installs it’s own (outdated) Python release.

This may be the first of a small series of Python/Panda3D tutorials. As it turns it will be a ‘peer to peer’ tutorial, since I’m learning both Python and Panda3D as I go.

I won’t assume that you can’t write a computer program or don’t understand 3D. So I’m afraid this won’t be suitable for complete newbies. More like a crash course.

OK, after running a couple of examples, my first question was:

How does Python find imported modules?

Yes, there is a ‘classpath’:

1. Current directory, ie, the target directory when starting our python app.
2. PYTHONPATH environment variable
3. .pth files; .pth files are used to add locations to the search path – if a pth files is on the search path (in an already known location), then it is read and all files listed there are also added to the path.
   This is convenient – say we have a foo/script.py script, then all we need to import custom modules is define a foo/import.pth file pointing at our custom module definition files.
4. sys.path variable. At runtime, we can reach (and edit) this by importing sys, and print the current classpath using print sys.path.
   Changing sys.path at runtime allows dynamically adding locations to the classpath.

Most of this is  documented. The best of it,  .pth files, is apparently still undocumented.

I’m just running the sample programs so far. My guess is that Panda3D is adding its eggs to PYTHONPATH.

Import statements

Python uses both import X and import X from Y statements. The equivalent of the java import is import X from Y (I found a nice article detailing python imports)

Why bother?

Sure, if you install P3D the way I did, you don’t really need to know about sys.path to get started with the sample programs. But then, until we know how the path works, we can’t release software. Let’s be agile. We don’t want to wait another year until we release our first P3D app.

After reading AdvancED Actionscript 3.0 Animation, I have decided to give a self-made Flash 3D Engine a shot. The idea is to create a small and fast 3d framework that out-powers the 3 major engines (Away, Papervision, Alternative). through incorporation of Pixel Bender, minimising function calls and if possible passing byte-arrays to OpenGL via “Alchemy”. The Framework shall provide 3D Vertice management on byte-level with Depth-Sorting,  rotation matrices and UV mapping , a Camera Object, a Render Engine, and eventually an Obj parser.

The Books I am using are:

• AdvancED Actionscript 3.0 Animation – Keith Peters – friedsofed – ISBN: 978 – 1 – 4302 – 1608 – 7
• Actionscript 3.0 Animation “Making things move” – Keith Peters – friendsofed – ISBN: 1 – 59059 – 791 – 5
• 3D Math Primer – Fletcher Dunn and Ian Parberry – Wordware – ISBN: 1 – 55622 – 911 – 9

To instantiate the engine, the code should look similar to this:

var engine:Cheata = new Cheata();

addChild(engine);

engine.data = _initVertices:Vector<Number>;

engine.startRendering();

engine.startRotatingX(anglePerSeconds:Number);

CryTek just released some screen shots of their new engine. Man does it look awesome! Be sure to check them out. I can’t wait to see this engine in action!

http://kotaku.com/5184482/new-cryengine-3-trailer-screens

Not really a release but this is what I completed so far. Include a SPT Maker beta 0.1 release. SPT Maker is quite stable now and I am going to use it in my upcoming project Atomic Empire casual game

Download Source Codes

Edit: now I update some minor update to the sources download. Please download the source codes again. Here is some test data for Brainiac SPT Maker:

Download Test Images

Enjoy the sources!!!

Finally I am able to chunk out a sprite maker for Brainiac engine.It is half-way finish now and I am hoping to finish it before end of next week. Features currently implemented:
- packing images into sprite with 2 options: optimized for VRAM usage and minimized image output count (VRAM optimization can be better but current one is not bad either given time and effort went into it)
- Pivot and additional prop pivot setup
- some frame manipulation tools
- animation preview mode where user can add another prop to test prop pivot offsets.

Things still need to implement:
- scale back the image when loading if it is scaled outside the program (by Photoshop etc)
- Some pivot alignment tools
- Add support for Alpha buffer
- Add support for Hit-testing buffer
- Add support for Mask buffer(s)
- Support loading of 8-bit images
- implement various animation methods
- shadow and reflection options

OK half-way finished now! Need to implement the other half. After it is finished, I will write the Brainiac font generator.

I’m going to try to write a feature complete 3D engine, mainly as a learning experience, and to exercise/perfect my programming style.  It will not be the fastest thing out, but I hope that it will be the most beautiful.  I would like it to be self contained, apart from the graphics and sound api’s everything will be coded by me.

Features

Anyways, thats the plan, I dont know how far I’ll get, how quick it will develop but I’ll give it a go.

Just have a try on this new 3d player. It is a flash 3d player. No special plug-in needed. Sophie 3D claim that it can render in realtime over 50.000 polygons with texture maps, reflection maps, transparent materials, an infinite number of lights and shadow planes.

I have go though some sample on their website. Seem pretty good in quality and run smooth on my old P4 machine.

After trying their sample, i want to test with my own model. Since i havn’t Rhino 4. So, i try to use 3d max to export my model into wavefront object and load with the player. But seem can’t make it success with any setting. Hope they will have more info on authoring 3d model. It is important for content maker.

Last, some more opinion. It is great if interactive is supported with the player. Such as click on object to have some action. Also, animation is important. Hope they will improve in the future version.

If you are interesting on this player, you can try Sophie 3D here. It is free to download and use.

http://www.sophie3d.com/

Found a terrific Flash 3D engine.  Tried a few of their demos and check out bits of code.  Very nice.  Now I need to find a way to hack this into Flex.  Fun!

Away3D’s Link

The next step is to code the Brainiac Tool Framework which will be used by all the tools in Brainiac tool chain. BTF will be similar to the DirectX Sample Framework – just a simple framework including a D3D setup and some MFC framework for GUI programming. I made the decision to use DirectX 9 for all the tools development. This means all game creation must be done on Windows platform though the end result should be cross-platform. But considering that 99.99% of all development system is PC and Windows being the dominance of the PC OSs, it won’t hurt too many developers by making a Window-based development tool now

Major requirements in BTF ares

• Simple D3D Setup with DirectX 9
• File readers for most image file types: PNG, JPG and BMP
• File readers for XFile format (and any other 3D file format – *.3ds is another target to support on my game engine)
• XML parser

So I need to finish the BTF first before start writing tool chains for the Brainiac. The core Brainiac is still a long way to go…. Phew…

Well, I am doing it right this time. The first engine I made is derived from another first engine I made as a school-project. So it makes a lot of reference to it’s first generation engine from which it came and it has to be backward compatible. I need to manually remove all obsolete functions later. This time I am not going for a backward compatibility. I am starting everything from scratch.

For that, I needs to write tools first and am not going to use tools left by the first engine. Bye, bye font generator and PIC format. Here come the SPT format (read Sprite) for picture file, FNT format
(read Font) for Font and GDX format (Game Data in XML) for game data (everything from menu configuration files to custom game data files).

So, for first step, I need to create tools to generate those data. Here is the list:

SPT Image Converter: convert raw image format like png into SPT file. SPT file format not only has just raw image data, it would have alpha buffer, hit-test buffer, and color buffer. It would also have named rectangle marker, custom pivots, animation information, and image compression and automatic pivot adjustment.

Packed Resource File: loading resources by their filename causes a lot of trouble in the past so I gonna use a resource packer and resource meta data to load the resources inside the game. So for example, if I need to load resource with filename “Resource\worker.spt” whose ID is “worker0″ and whose index value is 30, I can load it with ID “worker0″ or index 30. I don’t need to use the actual filename which make replacing graphic easier and less error-prone. And these resources will be packed into a single file. I will not be using the old file packer which pack the entire file structure under the game folder. I will only pack the resources (graphic, sound, game data etc) because they are the files used by the game in most time and don’t need/want for player to edit them. Setting and other file types can stay unpacked and under game folder.

Font Maker: one of the thing I always wanted is a font maker. Right now, making Burmese language game s sucks. It may be because our mother language itself sucks (haven’t thought of computers at the time of language creation, aren’t we ). Font maker will allow the user to insert any character or add more characters later as needed for localization and we don’t have to recompile the game again whenever the language changes B) And only one font will be loaded for all languages meaning a single font file include all characters for all languages. And they will be loaded only when we need to display a character from specific language – saving a lot of VRAM. Right now, there are separate fonts for separate languages giving me headache for managing multiple language builds

These 3 tools will be created first before actually designing and developing the core engine. Wish me luck

Ok, this is going great! The blog will help me get focus on what I need to do. I am kind of the type who get better ideas when talking to myself than thinking it alone inside my head. Don’t know if anyone else or everyone’s brain works that way. It is like having 2 brains work instead of one on the subject. But I do not have enough humor to talk to myself in the mirror or something. Writing it all down will work just as well. OK, now back to the business.

The first step in making an engine that is decent enough to use but not to get too much “scope-creep” is to have good requirements at start up. And here is what I like to see in my engine:

• Cached faster 2D rendering
• 3D rendering support in 2D
• GUI editor for menu and particle systems
• Shader effects for 2D rendering including post filtering effect
• Packed file
• GUI editor for game data creation (map editor, level editor etc)
• Better font rendering and support for localization (support for Burmese language as well)
• Custom compressed image format
• Traditional 3D rendering support
• Cross-platform

I know there are a lot of engines that do exactly what I mention in the above requirement but there is no engine that does exactly those in my way So I gonna be writing my engine and here is the Brainiac!

Hi, this is my first entry for my development blog for a 3D engine that I will be making in the next 6 months or so called the Brainiac. Brainiac is the DC comics super villain in Superman comics who become more and more powerful with new upgrades every new appearances. So this is what I hope will happen to my engine – become better with every new version, updates and releases.

My reason for writing this engine is for myself . Right now, my current engine is not very efficient and require me to do a lot more work than necessary in a professional engine. Not to wonder, it is 4 years old So it is an old man who should be retired already And I hope this new baby Brainiac will be everything I hope it will be.

It will focus mainly on 2D rendering since I am writing 2D casual games for the time being but I will add 3D support as well in the future. Since line of 3D product likely to come out from my company is tycoon games, the engine will support tycoon type games only.

Well, that’s all for the first post. Hope to get start on this project as soon as possible…

By Christian Laforte

A sky is like the nature’s face. Looking at a sky, you can’t help but get strong emotions. A gloomy, dark sky causes depression. A bright sky with fluffy clouds is relaxing, opens our imagination and reminds us of vacations. So it’s no surprise that 3D experts have spent a lot of time over the years to recreate this phenomenon. Here’s a quick guide to some of the advances over the past few years. I’ll conclude with something I just discovered, that brings state-of-the-art algorithms at a price that can’t be beat.

1. Pre-historic techniques
The two typical, simple approaches that are still used in a lot of applications and games despite their visual shortcomings, are billboards and simple procedural approaches based on Perlin noise. These techniques produce flat and lifeless images. They really show their age so I’m not going to cover them.

2. Research by Dobashi and Nishita

From memory, these researchers did pioneering work on physically-plausible models to simulate scattering (the way light goes through and bounces on clouds and air particles). Their approaches produced good looking results but not fast enough for interactive applications.

http://nis-ei.eng.hokudai.ac.jp/~doba/

3. Research by Mark Harris

Mark Harris was the first to produce amazing clouds at real-time speed. He achieved this through a combination of techniques including impostors (fancy billboards, updated incrementally), OpenGL-based rendering and simulation, and much more.

4. Other real-time approaches
As Graphics Hardware became easier to program and faster, many algorithms applicable for games were published.

For example:

Fast Fluid Dynamics Simulation on the GPU, again by Mark Harris after he joined NVIDIA.

Volumetric Clouds and Mega Particles by Homam Bahnassi and Wessam Bahnassi

More links at GameDev.net

5. Clouds and Sky SDK

What if you’re in a rush, so you don’t have the time or expertise to implement these fancy algorithms? You could hire someone like us to get it done quickly, but someone brought to my attention a new solution that sounds too good and too cheap to be true. From their web site:

Simul Clouds is a C++ library which provides access to cloud data for real-time applications. Simul Clouds creates volumetric cloud data, and provides realtime access to that data via a lightweight API. The Simul Clouds library deals with pure volumetric data, it is cross platform and renderer-independent. The sample applications that come with the SDK show how realtime clouds can be rendered using the generated cloud data.

Here’s their promotional video:

What’s amazing to me is the almost ridiculously low price tag. They only charge a hundred bucks for something that must have taken them at least a couple of months to develop and optimize. There’s no way they can make a profit at this price while providing good support. My advice to this company: raise your price to at least a thousands dollars for the SDK, so you can afford to support your clients when they need help. But first, send me a copy so I can confirm it works as expected, and so we can integrate cool skies in our Feeling Engine.

The Alternativa Platform team has annouced yesterday the release of their Alternativa 3D Engine for Flash. The download is free for non-commercial use. They have also released documentation and tutorials so you can begin your own experiences and projects. Just let me know the link of your works and i will feature them here.

Hoy hemos descubierto el impresionante motor de gráficos 3D Euphoria de NaturalMotion. El lector pensará en primera instancia que se trata de un motor más, que simplemente calcula más rápido que el resto las reflexiones, las sombras o que incluye lo último en el cálculo de físicas, lo que nos permitirá ir más allá en lo que a destruir un escenario 3D se refiere.

Pues bien, va más allá de las mejoras clásicas, siendo su principal característica la animación generada en tiempo real (on-the-fly generated animation). Me explico. Resulta que hasta ahora, en un juego o película de animación 3D, la animación teníamos dos formas de generarla:

1. Mediante keyframing. El animador elige los fotogramas clave (key frames) donde posiciona el objeto o personaje de manera manual y el ordenador interpola los fotogramas intermedios.
2. Mediante Motion Capture. Se captura el objeto o personaje en movimiento mediante una cámara y luego se traslada esa animación grabada al ordenador de un modo más o menos automático.

Pues bien, con Euphoria definimos los personajes mediante huesos, músculos y un sistema nervioso motor, los colocamos en un escenario y los sometemos a diferentes fuerzas (gravedad, disparos, rocas caídas del cielo,…) y el personaje reacciona de manera automática tal y como lo haría en la vida real. Incluso sujetándose a los objetos que tiene alrededor si con eso evita una caída.

Euphoria ya se está utilizando en juegos de última generación, entre otros Grand Theft Auto IV, Star Wars: The Force Unleashed, Indiana Jones y Backbreaker.

Vídeo de presentación de Euphoria

Vídeo Backbreaker

[Más videos después del salto]

Vídeos Star Wars Force Unleashed

Vídeo Grand Theft Auto IV

My approach to creating a game is grounded in the I-don’t-know-enough-about-3d-graphics-to-design-an-engine philosophy; so, I went searching for an existing open-source engine.

I won’t hide my preference for projects which are object oriented. In fact, I’ll freely admit that I prefer object oriented solutions nearly to the exclusion of any other. I have let this preference be one of the primary guiding factors when choosing a 3d engine. In the end, I have two favorite engines: Ogre3d and jMonkey Engine.

I might as well also admit that I have a severe distaste for having to do my own memory management. Because of that loathing, I initially leaned towards the Java-based jMonkey Engine as opposed to the C++ Ogre3d. As it turns out, my choice of engines may depend on one other undecided factor: my choice of scripting language.

I simply must do my higher-level game logic and AI in some form of scripting language; everybody else is doing it – it’s the in thing to do. The way I see it, there are three reasons I might want to use a scripting language: scripting is more approachable; scripts offer on-the-fly reloading; and scripting is more productive.

As someone who has worked on game mods and level creation, I can certainly see the case for a scripting language being more approachable for modders; this extends to non-programmer content creators such as artists and level designers. Groovy is an excellent scripting language that integrates well with jME and Java, has easy-to-learn syntax and supported functionality for defining a domain-specific language. Now I want to use Groovy.

I can also see the case for on-the-fly changes — especially in light of interpreted languages that can be reloaded at runtime. It’s very exciting to think that it’s possible to write scripts in a way that allows the game actions to be recorded so when an error occurs I can stop, rewind, reload a modified script and continue from the point where the error showed up. Clearly this allows for swift bug fixes in the game and AI logic portion of the game. This blog entry about using a Lisp variant for game development highlights why this is a good thing. Now I want to use Clojure.

I readily bought into the first two reasons; it was the third reason I didn’t much understand. After all, I’m a programmer. I write code all the time and there’s nothing wrong with Java as a high-level language. How is a scripting language going to make me more productive? But as I delved deeper into information about scripting engines, I stumbled across this blog entry; although nearly three years old, the information seems to be relatively fresh. Now I want to use Stackless Python.

Because of the novelty, I think Stackless wins. In fact, its tipped the balance so much that now I’m willing to work with Ogre3d; because there isn’t an easy way to integrate Stackless with Java I’m willing to work with C++. Python integrates well with C++ and therefore with Ogre3d; in fact, there is already a set of Ogre3d bindings for Python (and therefore Stackless) in the form of the Python-Ogre project.

In the end, I want things to be simple. I love object oriented programming because it models the way the world works: we have objects, and they do things. I love the idea of modeling AI in Stackless because it allows me to make entities autonomous without the overhead of system threads and without the ugliness that comes with dealing these complicated algorithms during stolen rendering loop cycles.

This is all new to me; I’m still feeling out where the pitfalls might be. But, the way ahead looks clear for Stackless, Python-Ogre and Ogre3d – at least for proof of concept.

A Typing by eLse’s only programmer…

Introducing ELSE 3D  Game Engine 2007

 October 2007, a dumb dumb programmer start working on VERY BIG project. This project overwhelmed the programmer and pushed his head to wall several time during the so call ‘development period’.  Lucky that nothing nasty happened to this dumb dumb programmer and the first snap of ELSE engine completed at December 2007.

“There are no free 3D engine which allow me to program something suitable for eLse. I have to code an engine myself from ground up to fill my needs!” yelled by the dumb dumb programmer as people asked why he never bother to use other 3D game engine.

 Lets examine what this ELSE 2007 can do for us.

• It based on DirectX 9. Windows ONLY games.
• It can Load .X model, .X skinned Model, display 3D model, display 2D sprite (user interface), display billboard, handle Input, A free moving camera, Picking in game model, Painting on 3D model

Why “Painting on 3D model” is highlighted? According to dumb dumb programmer, this is the reason he want to program his own engine. ELSE engine 2007 supported clicking a mouse on a 3D model will eventually change the outlook of the texture, this make an illusion of “painting” on the 3D models.

Stay tune until this only programmer share for ELSE engine 2008!