Re: [osg-users] Generating a cube using geometry shaders

[Ahmed Hesham]

CPP file:

Code:
#include "osgDB/ReadFile"
#include "osgViewer/Viewer"

struct ModelViewProjectionMatrixCallback : public osg::Uniform::Callback {
    ModelViewProjectionMatrixCallback(osg::Camera *fCamera) :
        _camera(fCamera) {
    }

    virtual void operator()(osg::Uniform *uniform, osg::NodeVisitor *nv) {
        osg::Matrixd viewMatrix = _camera->getViewMatrix();
        osg::Matrixd modelMatrix = osg::computeLocalToWorld(nv->getNodePath());
        osg::Matrixd modelViewProjectionMatrix = modelMatrix * viewMatrix * 
_camera->getProjectionMatrix();
        uniform->set(modelViewProjectionMatrix);
    }

    osg::Camera *_camera;
};

osg::ref_ptr<osg::Program> createProgram(std::string fProgramName, std::string 
fVertexShader, std::string fGeometryShader, std::string fFragmentShader)
{
    osg::ref_ptr<osg::Shader> vertexShader = 
osgDB::readShaderFile(fVertexShader);
    osg::ref_ptr<osg::Shader> geometryShader = 
osgDB::readShaderFile(fGeometryShader);
    osg::ref_ptr<osg::Shader> fragmentShader = 
osgDB::readShaderFile(fFragmentShader);

    osg::ref_ptr<osg::Program> program = new osg::Program;
    program->setName(fProgramName);
    program->addShader(vertexShader);
    program->addShader(geometryShader);
    program->addShader(fragmentShader);

    return program.release();
}

int main(int argc, char **argv)
{
    // Program
    osg::ref_ptr<osg::Program> program = createProgram("SinglePass", 
"singlepass.vert", "singlepass.geom", "singlepass.frag");

    // Vertices
    osg::ref_ptr<osg::Vec3Array> vertices = new osg::Vec3Array;
    vertices->push_back(osg::Vec3(0.5f, 0.0f, 0.5f));

    // Geometry
    osg::ref_ptr<osg::Geometry> geom = new osg::Geometry;
    geom->setUseDisplayList(false);
    geom->setVertexArray(vertices);
    geom->setVertexAttribArray(0, vertices);
    geom->addPrimitiveSet(new osg::DrawArrays(GL_POINTS, 0, vertices->size()));

    // Geode
    osg::ref_ptr<osg::Geode> screenGeode = new osg::Geode;
    screenGeode->addDrawable(geom);

    // State set
    osg::StateSet *geomStateSet = geom->getOrCreateStateSet();
    geomStateSet->setAttribute(program);
    osg::ref_ptr<osg::Point> point = new osg::Point;
    point->setSize(5.0f);
    geomStateSet->setAttribute(point);

    // Viewer
    osgViewer::Viewer viewer;
    viewer.setSceneData(screenGeode.get());
    viewer.setUpViewInWindow(50, 50, 800, 600, 0);
    viewer.getCamera()->setViewport(0, 0, 800, 600);
    viewer.getCamera()->setClearMask(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    viewer.getCamera()->setClearColor(osg::Vec4(0.2f, 0.2f, 0.2f, 1.0f));

    // MVP
    osg::ref_ptr<osg::Uniform> MVP = new osg::Uniform(osg::Uniform::FLOAT_MAT4, 
"ModelviewProjection");
    MVP->setUpdateCallback(new 
ModelViewProjectionMatrixCallback(viewer.getCamera()));
    geomStateSet->addUniform(MVP);

    return viewer.run();
}



Vertex shader:

Code:
#version 330

in vec4 Position;
out vec4 vPosition;
uniform mat4 ModelviewProjection;

void main()
{
    gl_Position = ModelviewProjection * Position;
    vPosition = Position;
}



Geometry shader:

Code:
#version 330

layout(points) in;
layout(triangle_strip, max_vertices = 24) out;

in vec4 vPosition[1];

uniform mat4 ModelviewProjection;
uniform mat4 ProjectionMatrix;
uniform mat4 ViewMatrix;
uniform mat4 Modelview;

vec4 objCube[8]; // Object space coordinate of cube corner
vec4 ndcCube[8]; // Normalized device coordinate of cube corner
ivec4 faces[6]; // Vertex indices of the cube faces

void emit_vert(int vert)
{
    gl_Position = ndcCube[vert];
    EmitVertex();
}

void emit_face(int face)
{
    emit_vert(faces[face][1]); emit_vert(faces[face][0]);
    emit_vert(faces[face][3]); emit_vert(faces[face][2]);
    EndPrimitive();
}

void main()
{
        faces[0] = ivec4(0,1,3,2); faces[1] = ivec4(5,4,6,7);
        faces[2] = ivec4(4,5,0,1); faces[3] = ivec4(3,2,7,6);
        faces[4] = ivec4(0,3,4,7); faces[5] = ivec4(2,1,6,5);

        vec4 P = vPosition[0];
        vec4 I = vec4(0.25,0,0,0);
        vec4 J = vec4(0,0.25,0,0);
        vec4 K = vec4(0,0,0.25,0);

        objCube[0] = P+K+I+J; objCube[1] = P+K+I-J;
        objCube[2] = P+K-I-J; objCube[3] = P+K-I+J;
        objCube[4] = P-K+I+J; objCube[5] = P-K+I-J;
        objCube[6] = P-K-I-J; objCube[7] = P-K-I+J;

        // Transform the corners of the box:
        for (int vert = 0; vert < 8; vert++)
                ndcCube[vert] = ModelviewProjection * objCube[vert];

        // Emit the six faces:
        for (int face = 0; face < 6; face++)
                emit_face(face);
}



Fragment shader:

Code:
#version 330

out vec4 FragColor;

void main()
{
        FragColor = vec4(1.0, 0.0, 0.0, 1.0);
}



------------------
Read this topic online here:
http://forum.openscenegraph.org/viewtopic.php?p=61030#61030





_______________________________________________
osg-users mailing list
osg-users@lists.openscenegraph.org
http://lists.openscenegraph.org/listinfo.cgi/osg-users-openscenegraph.org