RTVolumeRendering/Source/Cube.cpp

Go to the documentation of this file.

#include <assert.h>
#include <stdio.h>
#include <limits>
#include "Error.h"
#include "Vector3.h"
#include "Cube.h"

struct PlaneVertex
{
        float x, y, z; // position
        float s, t, r; // texture coordinate
};

// The offset in bits to the start of the texture data.
const short PLANEVERTEX_TEX_OFFSET = sizeof(float)*3;

const int CUBE_FACE_VERTS_COUNT = 24;
const Vector3f CUBE_FACE_VERTS[] = 
{
        // front
        Vector3f(-1.0f, -1.0f,  1.0f),
        Vector3f( 1.0f, -1.0f,  1.0f),
        Vector3f( 1.0f,  1.0f,  1.0f),
        Vector3f(-1.0f,  1.0f,  1.0f),
        
        // back
        Vector3f(-1.0f,  1.0f, -1.0f),
        Vector3f( 1.0f,  1.0f, -1.0f),
        Vector3f( 1.0f, -1.0f, -1.0f),
        Vector3f(-1.0f, -1.0f, -1.0f),
        
        // right
        Vector3f( 1.0f, -1.0f,  1.0f),
        Vector3f( 1.0f, -1.0f, -1.0f),
        Vector3f( 1.0f,  1.0f, -1.0f),
        Vector3f( 1.0f,  1.0f,  1.0f),
        
        // left
        Vector3f(-1.0f,  1.0f,  1.0f),
        Vector3f(-1.0f,  1.0f, -1.0f),
        Vector3f(-1.0f, -1.0f, -1.0f),
        Vector3f(-1.0f, -1.0f,  1.0f),
        
        // top
        Vector3f(-1.0f,  1.0f,  1.0f),
        Vector3f( 1.0f,  1.0f,  1.0f),
        Vector3f( 1.0f,  1.0f, -1.0f),
        Vector3f(-1.0f,  1.0f, -1.0f),
        
        // bottom
        Vector3f(-1.0f, -1.0f, -1.0f),
        Vector3f( 1.0f, -1.0f, -1.0f),
        Vector3f( 1.0f, -1.0f,  1.0f),
        Vector3f(-1.0f, -1.0f,  1.0f)
};

//----------------------------------------------------------
Cube::Cube()
:
mainColor(0.0f, 0.0f, 1.0f, 0.2f),
outlineColor(0.0f, 0.0f, 1.0f, 1.0f),
planeColor(0.5f, 0.5f, 0.5f, 0.5f),
numberOfPlanes(START_PLANE_COUNT),
triangleCount(0),
dir(1.0f, 0.0f, 0.0f),
facesVbo(0),
linesVbo(0),
planeVertsVbo(0),
planeIndicesVbo(0)
{}

//----------------------------------------------------------
Cube::~Cube()
{
        if(facesVbo)
                glDeleteBuffers(1, &facesVbo);
        
        if(linesVbo)
                glDeleteBuffers(1, &linesVbo);
        
        if(planeVertsVbo)
                glDeleteBuffers(1, &planeVertsVbo);
        
        if(planeIndicesVbo)
                glDeleteBuffers(1, &planeIndicesVbo);
}

//----------------------------------------------------------
void Cube::Init()
{
        // Creates the cube frame
        CubeDef c;
        c.c = Point3f(0.0f, 0.0f, 0.0f);
        c.dim = 2.0f;
        
        frame = CreateFrame(c);
        planes = CreatePlanes(c);
        
        // Initializes the cube VBOs
        glGenBuffers(1, &facesVbo);
        glBindBuffer(GL_ARRAY_BUFFER, facesVbo);
        glBufferData(GL_ARRAY_BUFFER, sizeof(CUBE_FACE_VERTS), (void*)CUBE_FACE_VERTS, GL_STATIC_DRAW);
        
        glGenBuffers(1, &linesVbo);
        glBindBuffer(GL_ARRAY_BUFFER, linesVbo);
        glBufferData(GL_ARRAY_BUFFER, sizeof(CubeFrame), (void*)&frame.line, GL_STATIC_DRAW);
        
        // Initializes the plane VBOs
        glGenBuffers(1, &planeVertsVbo);
        glBindBuffer(GL_ARRAY_BUFFER, planeVertsVbo);
        glBufferData(GL_ARRAY_BUFFER, sizeof(PlaneVertex)*MAX_PLANES*6, NULL, GL_DYNAMIC_DRAW);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        
        glGenBuffers(1, &planeIndicesVbo);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, planeIndicesVbo);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned short)*MAX_PLANES*12, NULL, GL_DYNAMIC_DRAW);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
        
        UpdatePlanes();
}

//----------------------------------------------------------
void Cube::Draw()
{
        // Draws cube faces
        glEnableClientState(GL_VERTEX_ARRAY);
        
        glBindBuffer(GL_ARRAY_BUFFER, facesVbo);
        glVertexPointer(3, GL_FLOAT, 0, 0);
        
        glColor4f(mainColor.r, mainColor.g, mainColor.b, mainColor.a);
        glDrawArrays(GL_QUADS, 0, CUBE_FACE_VERTS_COUNT);       
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        
        glDisableClientState(GL_VERTEX_ARRAY);
        glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
}

//----------------------------------------------------------
void Cube::DrawOutline()
{
        // Draws the cube outline
        glEnableClientState(GL_VERTEX_ARRAY);
        
        glBindBuffer(GL_ARRAY_BUFFER, linesVbo);
        glVertexPointer(3, GL_FLOAT, 0, 0);
        
        glColor4f(outlineColor.r, outlineColor.g, outlineColor.b, outlineColor.a);
        glDrawArrays(GL_LINES, 0, (sizeof(CubeFrame) / sizeof(LineSegment)) * 2);
        
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        
        glDisableClientState(GL_VERTEX_ARRAY);
        glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
}

//----------------------------------------------------------
void Cube::DrawPlanes()
{
        if(numberOfPlanes > 0)
        {
                glEnableClientState(GL_VERTEX_ARRAY);
                glEnableClientState(GL_TEXTURE_COORD_ARRAY);
                
                glBindBuffer(GL_ARRAY_BUFFER, planeVertsVbo);
                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, planeIndicesVbo);
                glVertexPointer(3, GL_FLOAT, sizeof(PlaneVertex), 0);
                glTexCoordPointer(3, GL_FLOAT, sizeof(PlaneVertex), (const void*)PLANEVERTEX_TEX_OFFSET);
                
                glColor4f(planeColor.r, planeColor.g, planeColor.b, planeColor.a);
                glDrawElements(GL_TRIANGLES, triangleCount*3, GL_UNSIGNED_SHORT, 0);
                
                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
                glBindBuffer(GL_ARRAY_BUFFER, 0);
                
                glDisableClientState(GL_TEXTURE_COORD_ARRAY);
                glDisableClientState(GL_VERTEX_ARRAY);
                glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
        }
}

//----------------------------------------------------------
void Cube::SetNumberOfPlanes(int n)
{
        if(n < 1)
                n = 1;
        else if(n > MAX_PLANES)
                n = MAX_PLANES;
        
        numberOfPlanes = n;
        UpdatePlanes();
}

//----------------------------------------------------------
void Cube::UpdatePlanes()
{
        assert(numberOfPlanes > 0 && numberOfPlanes <= MAX_PLANES);
        
        // finds the half distance from the cubes center along the view direction
        LineSegment line;
        line.p1 = Point3f(0.0f, 0.0f, 0.0f);
        line.p2 = line.p1 + dir;
        
        float halfLen = 1.0f;
        float len = 2.0f;
        
        float min = std::numeric_limits<float>::max();
        
        for(int i = 0; i < 6; i++)
        {
                float t;
                if( Intersect(line, planes.plane[i], t) && t >= 0.0f && t < min)
                {
                        min = t;
                }
        }
        
        Vector3f d = dir * min;
        halfLen = d.Length();
        len = halfLen * 2.0f;
        
        // constructs the new planes
        PlaneVertex verts[MAX_PLANES*6];
        unsigned short indices[MAX_PLANES*12];
        
        Plane p;
        p.n = dir;
        
        triangleCount = 0;
        
        int count = 0;
        int index = 0;
        
        //const float dz = 2.0f / (numberOfPlanes + 1);
        //float z = 1.0f - dz;
        
        const float dz = len / (numberOfPlanes + 1);
        float z = halfLen - dz;
        
        for(int i = 0; i < numberOfPlanes; i++)
        {
                p.p = Point3f(0.0f, 0.0f, 0.0f) + z*dir;
                
                Point3f points[6];
                int n = Intersect(p, frame, points);
                SortPoints(points, n, dir);
                
                for(int j = 0; j < n; j++)
                {
                        int idx = count + j;
                        verts[idx].x = points[j].x; verts[idx].y = points[j].y;  verts[idx].z = points[j].z;
                        
                        verts[idx].s = (points[j].x + 1.0f) / 2.0f; 
                        verts[idx].t = (points[j].y + 1.0f) / 2.0f;  
                        verts[idx].r = (points[j].z + 1.0f) / 2.0f;
                }
                
                int tris = n - 2;
                for(int j = 0; j < tris; j++)
                {
                        indices[index++] = (unsigned short)(count        );
                        indices[index++] = (unsigned short)(count + 1 + j);
                        indices[index++] = (unsigned short)(count + 2 + j);
                }
                
                triangleCount += tris;
                count += n;
                
                z = z - dz;
        }
        
        glBindBuffer(GL_ARRAY_BUFFER, planeVertsVbo);
        glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(PlaneVertex)*count, (void*)verts);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, planeIndicesVbo);
        glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, sizeof(unsigned short)*index, (void*)indices);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}

---