Hello folks :) Well first of all I'm not an engine/framework-lover and I'm not going to make a mega engine or something else, just want to wrap some things (like Initialization, some drawing functions and etc) into one class that will be my so called "Graphics engine". Well wrapping things into class not a problem, the problem is presented here: I want to have some objects, actually not "few" but only 3. One object will be some basic things like cube, sphere, parallelepiped and etc. The second one going to be an MD2 (quake2 model format) object, and the last one is BSP (quake/half-life map format) object. The problem that everyone of them will have a different Render method. A cube will be rendered as vertices, MD2 will be rendered using OpenGL commands found inside the file itself, and BSP don't know yet :) I assume it will be vertex arrays. And finally the problem: I can add to every object his own Render() method, but then they become isolated from the engine, I mean engine MUST render object, not the object itself.. The second option is to add Render methods to Engine, things like RenderObject(Object& o), RenderMD2(MD2Model& md2), RenderBSP(BSPModel& bsp). This suits more to the structure of "engine must render objects". But it this case objects not managed through engine (good or bad I don't know). The last one I used it in my last project, Is to create std::list of base class Object, and every model that need to be rendered added to this list and then the Render() method of my engine simply run over the list and call Render() method of object. This Is the options I came with. Can someone help to decide what model is the best? How you do it? How others do it? Thanks a lot :)

Hi,

I don't have a load of time at the moment, but I can provide an idea to getting a nice way to render. It's called the visitor design pattern, and it serves as a solution to extending a class without modifying the class a lot, especially each time you add a new renderable object. Here's how it works.

We have an object that is dedicated to doing the rendering of these objects from their data. This object is called the visitor. When we get to rendering we 'send' this object to everything that can be rendered. The object then calls a method on this visitor with itself as the parameter - sending itself back to the visitor. Seems a bit pointless right? Well, the magic is that with polymorphic languages this causes different code paths to be executed, depending on the class.

Let's have a look at an example:



Looks pretty cool so far! Now we have a lot of common functionality grouped together, we hopefully starts making our code more organised. We can go even further now by making both BSPModel & MD2 inherit from a base class, maybe Renderable. Then, we all our renderable objects in a list, and it's very easy to render them all now. Let's see that:



You can go even further in some languages that allow for nice meta-programming (you might be able to do it in C++ with templates, but my knowledge of C++ is a bit rusty atm), like in Python you could add a class decorator to save you having to write that accept method.

I hope this sheds some light on your problem :)

[Edited by - Cycles on December 4, 2007 6:31:50 PM]

ldeej
Well I don't really got your idea. You mean every object have render attribute that the renderer grad and operate with it?
If yes than its sound pretty cool cause I can change the render method of object.

Cycles
Nice idea! Looks nice and pretty configurable.

Oh well there are another problem. If the renderable object registered in engines so called "render list" how should I operate with this object? I mean objects class can have functions to control objects animation (Like the design I did for MD2). How should I control the animation? Using some method in engine like getObject(ID).setAnimation(someAnim);? Or operating on the outside pointer?
Sec Ill write code.



Hmm actually its quite obvious that easier and better to use option 2.

I am open to another solutions/support of already given solutions.
Well actually would be nice to know how "pro" do it, I mean how big engines designed, maybe someone know and ready to share.

Thanks again.

jpetrie
Well I agree with you, but those files was created to serve their needs. MD2 was made to hold Animated character format and BSP was made to hold level data format.
I can't convert one to another (well actually I can).
Of course quite possible that in future when Ill work on my own game I will develop my own file format, for now I'm learning the API (OpenGL).
Thanks again :)

All those file formats store things as triangles, one way or another. For example, the ,md2 file has a list of vertices, and a list of triangles. Each triangle has 3 vertex references. The same is true of the .bsp file format, which has a series of brushes each containing a list of triangles, and a series of brush references stating where each brush is to be drawn.

The cube is a seperate problem. You won't find yourself using cubes once you program your game to load meshes from file, so put that code separately.

Everything else uses triangles. Start from the bottom up, writing low level functions first.

Firstly, create a triangle class and program the renderer to receive a triangle and render it.

Then create a camera class, consisting of a position and a view vector and some methods to move it around. Program your renderer to receive a camera and set the view frustum accordingly.

Give your renderer class the ability to store different textures inside an std::map and write some methods to switch between the textures loaded. Writ a method to get the OpenGL texture ID number when you pass in a string.

Then modify your triangle class so that it has a texture ID. The renderer should switch between the textures it has loaded automatically. Your triangle class should use the get_tex_id method to choose which texture ID it has.

Then, give the renderer the ability to recieve an std::vector of triangles and sort-copy them into some kind of optimized storage structure, e.g. octrees. It would do this for all the triangles it recieves.

What you then do is pass in an std::vector or triangles and render them in the order they are received.

Then write methods inside the .md2 model class to pass the triangles to the renderer as an std::vector, and then remove all GL code from the MD2 class. Do the same for your other mesh formats.

So, your draw code would look like this:

renderer.apply_camera( character_1.get_camera() );
character_1.send_triangles( renderer );
bsp_level1.send_triangles ( renderer );

renderer.optimize_triangles();
renderer.render_scene();
renderer.flip_buffers();

Got you thanks :)
If someone have something to add, Ill glad to hear :)