opengl/VertexBufferObject/VertexBufferObject.cpp

#include <stdio.h>

#include <ocean/GLvish/VRenderObject.hpp>
#include <ocean/plankton/VCreator.hpp>
#include <ocean/plankton/VTime.hpp>
#include <ocean/GLvish/BoundingBox.hpp>
#include <ocean/GLvish/ArrayTypes.hpp>

#include <stdio.h>

using namespace Wizt;


/*
 Render some object using vertex buffers.
 */
class   VertexBufferObject : public VRenderObject
{
        struct  MyState : State
        {
                double  complexity;

                MyState()
                : complexity(0.5)
                {}
        };

        override RefPtr<State> newState() const
        {
                return new MyState();
        }

        virtual void render(VRenderContext&Context) const;

public:
        TypedSlot<double>       Complexity;

        VertexBufferObject(const string&name, int p, const RefPtr<VCreationPreferences>&VP)
        : VRenderObject(name, p, VP)
        , Complexity(this, "complexity", 0.5)
        {}

        ~VertexBufferObject()
        {}
};

void VertexBufferObject::render(VRenderContext&Context) const
{
static  GLfloat Red[4]   = {0.9, 0.1, 0.1, 1.0 }; 

int     N = 300;
double  r = 1.0;

double  complexity = 0.5; 
        Complexity << Context >> complexity; 

double  dphi = 3.1415/ 10,
        zs   = 0.1 * complexity;


        glEnable( GL_COLOR_MATERIAL );
        glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
        SubObjectBegin(Context);
        vglColor4fv(Context, Red, 0.4); 

        glEnable(GL_DEPTH_TEST);

RefPtr<MyState> state = myState(Context);

        //
        // Define a parameter space for which VBO's need to be stored.
        // For each value of the parameters in this value set, there will
        // be one VBO, until we run out of memory.
        // In this example, the parameter space is empty.
        //
RefPtr<ValueSet> RenderParameterSpace = new ValueSet();

        //
        // Retrieve a Vertex Buffer Object relative to the Context
        // and call it if exists.
        //
RefPtr<VBO> myVBO;
        try
        {
                myVBO = Context(*state)(this)( RenderParameterSpace )( VERTEXBUFFER() );
        }
        catch(...){}
        if (myVBO && !myVBO->empty() && state->complexity == complexity)
        {
                if (myVBO->call() )
                        return;
        }

        //
        // We don't have a valid VBO, so need to create one.
        //
        myVBO = Context[*state][this][ RenderParameterSpace ]( VERTEXBUFFER() ); 
        // 
        // In case we had one, but need to re-create it, clear the one found. 
        //
        myVBO->clear(); 

        // 
        // Store the complexity value in the state object for further 
        // comparision. 
        //
        state->complexity = complexity; 

        //
        // Create a vertex array and a normal array
        //
        RefPtr<VertexArray> Points = new TypedVertexArray<point>();
        RefPtr<NormalArray> Normals = new TypedNormalArray<bivector>(); 

        // 
        // Compute the geometry and store them in the vertex and normal arrays. 
        //
        resetBBox(Context);
        {
        std::vector<point>    PointData;
        std::vector<bivector> NormalData; 
                PointData.resize(2*N); 
                NormalData.resize(2*N); 

                // 
                // The actual compution. Note that it is completely 
                // independent from OpenGL and could be done elsewhere, 
                // for instance in the object's update() function or 
                // within a thread. However, we need to take care to 
                // employ the caching system right, since this computation 
                // does not need to be performed if a valid VBO object 
                // already exists. The existence of a VBO object however 
                // requires an OpenGL context.
                //
                for (int i=0;i<N;i++) 
                {
                double  phi0 = i*dphi,
                        phi1 = (i+1/complexity)*dphi;

                point   A, B; 
                        A = r*cos(phi0), r*sin(phi0), phi0*zs; 
                        B = r*cos(phi0), r*sin(phi0), phi1*zs; 

                bivector N; 
                        N = cos(phi0), sin(phi0), 0; 

                        embrace( Context, A );
                        embrace( Context, B );

                        PointData[2*i  ] = A;
                        PointData[2*i+1] = B; 

                        NormalData[2*i  ] = N;
                        NormalData[2*i+1] = N;
                } 

                // 
                // Now load the data from RAM to the GPU.
                //
                Points ->load( PointData );
                Normals->load( NormalData );
        }
        closeBBox(Context); 

        // 
        // Tell the VBO to use these arrays 
        //
        myVBO->append(Points);
        myVBO->append(Normals);

        /*
          Define a Renderer object, as it will be used in the VBO.
          Here, the standard renderer will do, otherwise we could
          well derive from the DrawArrays class.
         */ 
        myVBO->setRenderer( new DrawArrays(GL::QUAD_STRIP, 2*N) ); 
        myVBO->call();
}

static Ref<VCreator<VertexBufferObject> > MyCreator("Tutorial/VertexBufferObject", 0);

/*
 This line needs to be contained in ONE source file of each
 VISH plugin module. It's not important which one.
 */
VISH_DEFAULT_INIT

---