opengl/VBOShader/VBOShader.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 <ocean/GLvish/Shader.hpp>

#include <stdio.h>

using namespace Wizt;


class   MyRenderObject : 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,
                                ScaleFactor;

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

        ~MyRenderObject()
        {}
};


/*
http://www.opengl.org/sdk/libs/OpenSceneGraph/glsl_quickref.pdf
 */

static const char vertexshader_src[] =
"\n"
""
"void main(void)\n"
"{\n"
"       gl_Position = ftransform();\n"
""
"\n"
"}\n";



static const char elevation_vertexshader_src[] =

#define SHADER_ELEVATION "elevation"

"attribute float "SHADER_ELEVATION";\n"
"uniform float scaleFactor;\n"
"\n"
""
"void main(void)\n"
"{\n"
"vec4   Pos     = gl_Vertex;\n"
"       Pos.x += 0.1*scaleFactor*"SHADER_ELEVATION";\n"
"       Pos.y += 0.1*scaleFactor*"SHADER_ELEVATION";\n"
"       Pos.z += 0.1*scaleFactor*"SHADER_ELEVATION";\n"
"vec4   V       = gl_ModelViewMatrix * Pos;\n"
"       gl_Position = gl_ProjectionMatrix * V;"
""
"\n"
"}\n";

static const char fragmentshader_src[] =
"\n"
"void main (void)\n"
"{\n"
"       gl_FragColor = gl_Color;\n"
"       gl_FragColor.g = 0.5+0.5*sin(gl_FragCoord.x*3.14/20);" // allows to modify pixel depending on pixel coordinates
"}\n"
;


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

int     N = 3000;
double  r = 1.0;

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

double  scalefactor = 1.0; 
        ScaleFactor << Context >> scalefactor;

double  dphi = 3.1415/ 80,
        zs   = 0.3 * 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);

RefPtr<Program> MyProgram;
        MyProgram = new Program();

RefPtr<VertexShader> VS = new VertexShader();
        VS->compile( elevation_vertexshader_src);
        MyProgram->attach(*VS);

RefPtr<FragmentShader> FS = new FragmentShader();
        FS->compile( fragmentshader_src );
        MyProgram->attach(*FS);

        MyProgram->link();

        if (!MyProgram->isValid() )
        {
                printf("VertexView: Shader: %s\n", MyProgram->InfoLog().c_str() ); 
                throw "Vertex Shader Compilation Error";
        }
        else
        {
                MyProgram->use();
                MyProgram->setUniformValuef( "scaleFactor", scalefactor);
        }

        // 
        // 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>(); 


        RefPtr<VertexAttribArray> Attribs = new TypedVertexAttribArray<float>( MyProgram->getAttribID( SHADER_ELEVATION ) );

        //
        // Compute the geometry and store them in the vertex and normal arrays. 
        //
        resetBBox(Context);
        {
        std::vector<point>      PointData;
        std::vector<bivector>   NormalData;
        std::vector<float>      AttribData;
                PointData.resize(2*N);
                NormalData.resize(2*N); 
                AttribData.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+5/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; 

                        AttribData[2*i  ] =
                        AttribData[2*i+1] = sin(10*phi0);
                } 

                // 
                // Now load the data from RAM to the GPU.
                //
                Points ->load( PointData  );
                Normals->load( NormalData ); 
                Attribs->load( AttribData );

        }
        closeBBox(Context); 

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

        /*
          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<MyRenderObject> > MyCreator("Tutorial/VertexShaderObject", 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

---