Maybe the image (or frame) draws the polygon.

Try not making anything private. I don''t know why that statement even exists! You should be able to access any data in your program directly. Then you wont have to use those stupid pointless Get methods.

// God.c
void main() {
WORLD Earth;
LIFE People = Earth.CreateLife(HUMAN);
GiveHope(&People);
delete Earth;
EvilCackle();
}

IronFroggy,

The protected and private access specifiers (keywords) exist for a very good reason. Any proper OO-language should have them. It is a little something called encapsulation. By encapsulating data you ensure that it is only accessed via the methods you provide. Say you had a public pointer to the internal representation of a class. Any client of that class could just call delete on it and the actual object holding the pointer wouldn't know about it! That is very bad and one of the reasons C++ and Java have the public/protected/private keywords.

gorm,

If you make your rendering functions inline, there is a good chance the compiler will put the calls to the graphics API inline etc.


Another way to create the graphics engine hierarchy is to use the Bridge pattern. You create a class named Renderer which holds a reference/pointer to abstract class RendererImpl. RendererImpl's interface defines methods for rendering polygons/triangles, setting colors, lights etc. Then you declare your actual API specific rendering classes by deriving them from RendererImpl. These classes could be called D3D_Renderer and OpenGL_Renderer.

    ----------      --------------|Renderer|<>----|RendererImpl|----------      --------------                       ^                       |                       |                ---------------                |             |       --------------     -----------------       |D3D_Renderer|     |OpenGL_Renderer|       --------------     -----------------   

Many people complain about C++ being too slow when you use classes to represent vertexes or triangles. They often forget that in C you use structures to hold triangle information (3 verticies, normal, color, texture co-ords) etc. Well a structure in C++ is basically a class with all public members. The slowness of using a class is when you force the use of access modifiers. This access time can be negligible, or often reduced by make access methods inline (it doesn't guarantee inlining though).

One way to optimize vertex operations is to think of the vertex as a stream. If you use vertex arrays you could, for instance, have a triangle class that serializes it's internal data to the vertex array passed to it by the Renderer.

Example:

          class Renderer{    public:        Renderer(const std::string& api)        {            impl_ = RendererFactory::CreateInstance(api);        }        virtual ~Renderer()        {            impl_->Release();            impl_ = 0;        }                BeginScene()        {            impl_->BeginScene();        }        EndScene();        {            impl_->EndScene();        }        DrawTriangle(const Triangle& t)        {            impl_->DrawTriangle(t);        }        DrawVertexArray(const VertexArray& va)        {            impl->DrawVertexArray(va);        }    protected:        class RendererImpl;        RendererImpl* impl_;};class OpenGL_Renderer : public Renderer{    public:        BeginScene()        {            glBegin(GL_TRIANGLES);        }                EndScene()        {            glEnd();        }        DrawTriangle(const Triangle& t)        {            glVertex3f(t.x1(), t.y1(), t.z1());            glVertex3f(t.x2(), t.y2(), t.z2());            glVertex3f(t.x3(), t.y3(), t.z3());        }        DrawVertexArray(const VertexArray& va)        {            glVertexPointer(3, GL_FLOAT, 0, &(va.arrayptr()));            // call glNormalPointer() etc            glDrawArrays(GL_TRIANGLES, 0, va.count());        }};  

Hopefully this gives you a few ideas. The implementation above is off the top of my head (other than the Bridge pattern etc) so it may not be completely thought out

One last word:

If you want the polygons/triangles to draw themselves you should do something similiar to the following:

             class Triangle{    public:        Render(const Renderer& r)        {            r.Color(r, g, b);            r.Vertex3(x1, y1, z1);            r.Vertex3(x2, y2, z2);            r.Vertex3(x3, y3, z3);        }            protected:        // data};      

Basically, instead of the Renderer class providing top level methods like DrawTriangle, it provides the primitive methods like Vertex3, Color etc. It makes defining your Renderer interface a bit more complex because you need to find a common interface between DirectX Graphics (D3D) and OpenGL.

Best regards,


Dire Wolf
www.digitalfiends.com


Edited by - Dire.Wolf on July 4, 2001 1:59:57 PM

Edited by - Dire.Wolf on July 4, 2001 2:01:23 PM