Dig! I've been working with scene-oriented stuff too. Three lines to implement a blending mode: very cool! But what if the 3D card doesn't handle this kind of blending?

I like the torus knot too: my fave test object :)

I think it will be very difficult to keep it as generic as you describe, but I wish you the best of luck anyhow :-)

Daan.

I would like to know how OGRE handles the fallback cases. If it can handle them elegantly I would REALLY REALLY like to see the material/texture handling stuff seperated out into a seperate library. (So us peeps with an existing engine can use OGREs smart stuff)

Benedict

I use the following way to do much the same :

first i have a material class :

// kaae@daimi.au.dk
#pragma once

#include "textureimage.h"

class Material
{
protected:
enum
{
RENDER_TEXTUREMAP,
RENDER_ENVMAP,
RENDER_WIRE,
RENDER_PARTICLE,
RENDER_FLAT,
RENDER_TRANSPARENT,
RENDER_TRANSPARENT_ADDITIV,
RENDER_ALPHA_MASK,
RENDER_SEE_THROUGH,
CULL_FRONT,
CULL_BACK,
CULL_NONE
};

char RenderTexturemap;
char RenderEnvmap;
char RenderWire;
char RenderParticle;
char RenderFlat;
char RenderTransparent;
char RenderTransparentAdditiv;
char RenderAlphaMask;
char RenderSeeThrough;
char CullFront, CullBack, CullNone;

float *SolidColor; // rgba
float *WireColor;

float ParticleSize;

TextureImage *Texture;
TextureImage *Envmap;

public:
Material();

void Enable(int what); // enable one of the RENDER_? features
void Disable(int what); // disable - - - - -

void SetSolidColor(float r, float g, float b, float a); // set the solid color for this material

void SetWireColor(float r, float g, float b, float a);

void SetTexture(TextureImage *texture); // set texture
void SetEnvmap(TextureImage *envmap); // set envmap


void SetParticleSize(float s);

friend class Object;
};





secondly i (ofcourse) have my object class :

// kaae@daimi.au.dk
#pragma once

#define WIN32_LEAN_AND_MEAN
#include <windows.h>

#include "vector.h"
#include "material.h"
#include "texturecoord.h"


class Object
{
protected:
int displaylist;


Vector *normals;
Vector *vertices;
TextureCoord *mapping;
unsigned long numVertices;

unsigned long *faces;
unsigned long numFaces;
Vector *faceNormals;

Material *material;

Vector pivot;
Vector rotation;
Vector translate;


struct _bbox
{
Vector min, max;
} BoundingBox;

struct _bsphere
{
Vector center;
float radius;
} BoundingSphere;


Vector scale;

char name[255];
public:

Object();
Object(unsigned long nverts, unsigned long nfaces);

~Object();


void Clone(Object *o); // copy another object


void Allocate(unsigned long nverts, unsigned long nfaces);

void CalcPivot(); // finds the center of this object

void SetPivot(Vector pivot); // sets - - - - -
void SetRotation(Vector rotation); // sets the rotation
void SetRotation(float rx, float ry, float rz); // - - -

void SetScale(Vector scale); // scaling
void SetScale(float sx, float sy, float sz);
void SetScale(float s);

void SetTranslation(Vector trans); // set translation point
void SetTranslation(float x, float y, float z); // - - -


void SetMaterial(Material *mat); // set the material
void virtual Paint(); // paint!

void SetName(char *name); // set this object's name
char NameEquals(char *name); // ask if this object's name is the same as input


void CalculateBoundingSphere(); // sphere ;-)

void PaintBoundingBox();
void CalculateBoundingBox();

void CalculateFaceNormals();
void CalculateNormals();

private:
void UploadVertices();

void virtual PaintTexture();
void virtual PaintEnvmap();
void virtual PaintTextureEnvmap();
void virtual PaintParticle();
void virtual PaintFlat();
void virtual PaintWire();

void EnableCulling();
void DisableCulling();

void EnableTransparency();
void DisableTransparency();

void EnableRotation();
void DisableRotation();

void EnableScaling();
void DisableScaling();

void EnableTranslation();
void DisableTranslation();

void EnableAlphaMask();
void DisableAlphaMask();

void EnableSeeThrough();
void DisableSeeThrough();
};





My object::paint() looks like this :

void Object::Paint()
{
if (material==NULL) return;

EnableCulling();
EnableTranslation();
EnableRotation();
EnableScaling();


if (material->RenderSeeThrough) EnableSeeThrough();

if (material->RenderAlphaMask) EnableAlphaMask();

if (material->RenderTransparent || material->RenderTransparentAdditiv) EnableTransparency();

if (material->RenderWire) PaintWire();

if (material->RenderFlat) PaintFlat();

if (material->RenderTexturemap && material->RenderEnvmap) PaintTextureEnvmap();
else
{
if (material->RenderEnvmap) PaintEnvmap();
if (material->RenderTexturemap) PaintTexture();
}

if (material->RenderParticle) PaintParticle();

if (material->RenderTransparent || material->RenderTransparentAdditiv) DisableTransparency();

if (material->RenderAlphaMask) DisableAlphaMask();

if (material->RenderSeeThrough) DisableSeeThrough();

DisableScaling();
DisableRotation();
DisableTranslation();
DisableCulling();
}




And finally a little code snippet for using it :

...
Object *object = ObjectGenerator::Pyramid(Vector(0.0f,0.0f,0.0f), 50.0);
Material *material = new Material;
material->Enable(Material::RENDER_TEXTUREMAP);
material->Enable(Material::RENDER_ENVMAP);
material->Enable(Material::CULL_NONE);
material->Enable(Material::RENDER_TRANSPARENT);
material->SetTexture(TextureImage::DetectAndLoad("data/texture.jpg"));
material->SetTexture(TextureImage::DetectAndLoad("data/env.jpg"));
object->SetMaterial(material);
object->CalculateNormals();
...
while (1)
{
...
object->Paint();
...
}




i like it (sorry for the long post).

Very nice... Don't be discouraged by the misbelief, C++ is the ideal tool for platform independance and optimisation if you make proper use of OO (And from your code sample it looks as though you have). I was tinkering with the idea of doing a C++ raytracing wrapper where you implemented the objects as derived classes, using a very similar ideology as you have adopted.

Keep up the good work, I'm sick of API's continually using 'C' or lazy, memory leaking, non-OO C++...

I like the name, especially the way you abbreviate Object Orienter Rendering Engine (OORE) to OGRE :-)

If the card doesn't support the blending at all, you get the top-most texture layer. Otherwise if the card supports blending but for a subset of modes only, I believe the underlying API gives you the nearest available (I may be wrong here - I only have cards which support all or nowt!)

Keeping it generic is very tough, I'm doing my best but I bet people will find ways where it doesn't work. I'm interested to hear about these cases so I can factor it in to a later version.

Torus knots are just sweet for environment map effects, lots of sweeping normals. ;)

OGRE falls back nicely on cards with less than required numbers of texture units by just building up as many layers as there are units for each pass, terminating when it runs out of layers.

As I mentioned in my reply to the above post, lack of any blending modes on the card will result in the topmost layer being displayed (it just multi-passes from lowest to highest texture), I haven't implemented any smart software modes.

LeD, at the site you can read that OGRE stands for Object-Oriented Graphics Rendering Engine so he obviously made a typo in his IOTD post. :)

Anyway, I like the image, and I like it even more that it takes only 3 lines!

You forgot 'Graphics' hence the 'G'. I pretended Object-oriented is one word if you use a hyphen, cos no-one knows what an OOGRE is. ;)

Oops, ok *I* forgot the 'Graphics' part in my original post. My bad. ;)

I implemented materials using quake3-style textfile shaders. I also developed a MAX plug-in that automatically generates shader code and binds surfaces to materials. At loading time the shaders are interpreted and the layers are collapsed or removed matching graphics card capabilities. Clearly everything is done in a object oriented and platform independent way.
Obviously the coder can use C++ functions to add layers and set blending operations, but it's a little more complicated than the 3-lines method you describe. :-)

spikeD

not too spectacular image you say?
pah
i've always liked torus knots
don't forget the stencilbuffer shadow casting
i'm addicted to it

keep it up

Emil

What does the BSP-here variable do?

What kind of game do you plan to do with your library ?

Is it just me or did someone just posted the whole windows source code in the middle of this thread :(

Looks great, anyhow. I'd be happy to use it.

WOW! IMPRESSIVE !!!
ITS REALLY AMAZING !!!

nt

*sigh*

Thats intense.

I know you're referring to the code posted in the message rather than mine, but I think you'll find it's short for BoundingSphere rather han being BSP related.

BTW the classes starting with 'Bsp' in the OgreEngineIndoor module are work-in-progress implementations of BSP-based rendering, data being loaded from Quake3 files.

I'm hoping other people will use it to make their own games/demos and feed back their experiences to me - I don't think I'll have time to develop the library and build a game with it as well. I'll obviously be producing test beds which will have game-like features just to test that my ideas work, but a full game is probably out of the question in the short term.

I hope to find time to build a demo with it later on though.

And all that you do with it are CUBES... coool :)

kb
http://kebby.org

and hairballs for tp2001 ;-)