source: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/vmi/src/interleave.cpp @ 983

#include <stdio.h>
#include <stdlib.h>

#include "../include/GL/glew.h"
#ifdef _WIN32
#include "../include/GL/wglew.h"
#endif
#include "../include/interleave.h"
#include "../include/global.h"

namespace       VMI
{

VertexIL *intertwined = NULL;

static Vertex_ *buf_vertices = NULL;
static Color   *buf_colors = NULL;

static GLuint vertex_buf = 0,
       color_buf = 0;
}

using namespace VMI;
       
void VMI::setupVertexArray(Mesh *mesh, Color *colors)
{
    GLuint i, v1, v2, v3, n = 0;
    GLubyte r, g, b, a;

    if (buf_vertices != NULL) free(buf_vertices);
    if (buf_colors != NULL) free(buf_colors);

    buf_vertices = (Vertex_ *)malloc(mesh->currentNumTriangles * 3 * sizeof(Vertex_));

    buf_colors = (Color *)malloc(mesh->currentNumTriangles * 3 * sizeof(Color));

    if (buf_vertices == NULL) {
        fprintf(stderr, "Error allocating memory\n");
        exit(1);
    }

    if (buf_colors == NULL) {
        fprintf(stderr, "Error allocating memory\n");
        exit(1);
    }

    for (i=0; i<mesh->numTriangles; i++) {
        
        if (mesh->triangles[i].enable == TRUE) {
            
            v1= mesh->triangles[i].indices[0];
            v2= mesh->triangles[i].indices[1];
            v3= mesh->triangles[i].indices[2];
            
            r = colors[i].r;
            g = colors[i].g;
            b = colors[i].b;
            a = colors[i].a;
            
            buf_colors[n].r = r;
            buf_colors[n].g = g;
            buf_colors[n].b = b;
            buf_colors[n].a = a;
            buf_vertices[n].x = mesh->vertices[v1].x;
            buf_vertices[n].y = mesh->vertices[v1].y;
            buf_vertices[n].z = mesh->vertices[v1].z;
            n++;
            
            buf_colors[n].r = r;
            buf_colors[n].g = g;
            buf_colors[n].b = b;
            buf_colors[n].a = a;
            buf_vertices[n].x = mesh->vertices[v2].x;
            buf_vertices[n].y = mesh->vertices[v2].y;
            buf_vertices[n].z = mesh->vertices[v2].z;
            n++;
            
            buf_colors[n].r = r;
            buf_colors[n].g = g;
            buf_colors[n].b = b;
            buf_colors[n].a = a;
            buf_vertices[n].x = mesh->vertices[v3].x;
            buf_vertices[n].y = mesh->vertices[v3].y;
            buf_vertices[n].z = mesh->vertices[v3].z;
            n++;
        }
    }
#ifdef VERTEX_ARRAY
    // Enable the buf_vertices vector
    glEnableClientState(GL_COLOR_ARRAY);
    glEnableClientState(GL_VERTEX_ARRAY);
    
    glColorPointer(4, GL_UNSIGNED_BYTE, 0, buf_colors);
    glVertexPointer(3, GL_FLOAT, 0, buf_vertices);
#endif
}

void VMI::setupVertexBufferObjects(Mesh *mesh, Color *colors) {
    
    setupVertexArray(mesh, colors);
    
    // Disable the vertex array functionality:
    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_COLOR_ARRAY);
    
    glDeleteBuffersARB(1, &vertex_buf);
    
    glGenBuffersARB(1, &vertex_buf);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertex_buf);
    glBufferDataARB(GL_ARRAY_BUFFER_ARB, mesh->currentNumTriangles * 3 * 3 * sizeof(float), buf_vertices, GL_STATIC_DRAW_ARB); //upload data
    
    glDeleteBuffersARB(1, &color_buf);
    
    glGenBuffersARB(1, &color_buf);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, color_buf);
    glBufferDataARB(GL_ARRAY_BUFFER_ARB, mesh->currentNumTriangles * 3 * sizeof(Color), buf_colors, GL_STATIC_DRAW_ARB); //upload data
    
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertex_buf);
    glVertexPointer(3, GL_FLOAT, 0,0);
    
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, color_buf);
    glColorPointer(4, GL_UNSIGNED_BYTE, 0, 0);
    
    // Enable the vertex array functionality:
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_COLOR_ARRAY);
    
    free(buf_vertices);
    buf_vertices = NULL;
    
    free(buf_colors);
    buf_colors = NULL;
}

void VMI::updateVertexArray(Mesh *mesh)
{
    GLuint i, v1, v2, v3, n = 0;

    if (buf_vertices != NULL) free(buf_vertices);

    buf_vertices = (Vertex_ *)malloc(mesh->currentNumTriangles * 3 * sizeof(Vertex_));

    if (buf_vertices == NULL) {
        fprintf(stderr, "Error allocating memory\n");
        exit(1);
    }

    for (i=0; i<mesh->numTriangles; i++) {
        
        if (mesh->triangles[i].enable == TRUE) {
            
            v1= mesh->triangles[i].indices[0];
            v2= mesh->triangles[i].indices[1];
            v3= mesh->triangles[i].indices[2];
            
            buf_vertices[n].x = mesh->vertices[v1].x;
            buf_vertices[n].y = mesh->vertices[v1].y;
            buf_vertices[n].z = mesh->vertices[v1].z;
            n++;
            
            buf_vertices[n].x = mesh->vertices[v2].x;
            buf_vertices[n].y = mesh->vertices[v2].y;
            buf_vertices[n].z = mesh->vertices[v2].z;
            n++;
            
            buf_vertices[n].x = mesh->vertices[v3].x;
            buf_vertices[n].y = mesh->vertices[v3].y;
            buf_vertices[n].z = mesh->vertices[v3].z;
            n++;
        }
    }
#ifdef VERTEX_ARRAY
    // Enable the buf_vertices vector
    glEnableClientState(GL_VERTEX_ARRAY);
    
    glVertexPointer(3, GL_FLOAT, 0, buf_vertices);
#endif
}

void VMI::updateVertexBufferObjects(Mesh *mesh) {
    
    updateVertexArray(mesh);
    
    // Disable the vertex array functionality:
    glDisableClientState(GL_VERTEX_ARRAY);
    
    glDeleteBuffersARB(1, &vertex_buf);
    
    glGenBuffersARB(1, &vertex_buf);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertex_buf);
    glBufferDataARB(GL_ARRAY_BUFFER_ARB, mesh->currentNumTriangles * 3 * 3 * sizeof(float), buf_vertices, GL_STATIC_DRAW_ARB); //upload data
    
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertex_buf);
    glVertexPointer(3, GL_FLOAT, 0,0);
    
    // Enable the vertex array functionality:
    glEnableClientState(GL_VERTEX_ARRAY);
    
    free(buf_vertices);
    buf_vertices = NULL;
}

void VMI::setupInterleave(Mesh *mesh, Color *colors)
{
    GLuint i, v1, v2, v3, n = 0;
    GLubyte r, g, b, a;
    
    if (intertwined != NULL) free(intertwined);
    
    intertwined = (VertexIL *)malloc(mesh->currentNumTriangles * 3 * sizeof(VertexIL));
    
    if (intertwined == NULL) {
        fprintf(stderr, "Error allocating memory\n");
        exit(1);
    }
    
    for (i=0; i<mesh->numTriangles; i++) {
        
        if (mesh->triangles[i].enable == TRUE) {
            v1= mesh->triangles[i].indices[0];
            v2= mesh->triangles[i].indices[1];
            v3= mesh->triangles[i].indices[2];
            
            r = colors[i].r;
            g = colors[i].g;
            b = colors[i].b;
            a = colors[i].a;
            
            intertwined[n].tx = 0.0f;
            intertwined[n].ty = 0.0f;
            intertwined[n].r = r;
            intertwined[n].g = g;
            intertwined[n].b = b;
            intertwined[n].a = a;
            intertwined[n].x = mesh->vertices[v1].x;
            intertwined[n].y = mesh->vertices[v1].y;
            intertwined[n].z = mesh->vertices[v1].z;
            n++;
            
            intertwined[n].tx = 0.0f;
            intertwined[n].ty = 0.0f;
            intertwined[n].r = r;
            intertwined[n].g = g;
            intertwined[n].b = b;
            intertwined[n].a = a;
            intertwined[n].x = mesh->vertices[v2].x;
            intertwined[n].y = mesh->vertices[v2].y;
            intertwined[n].z = mesh->vertices[v2].z;
            n++;
            
            intertwined[n].tx = 0.0f;
            intertwined[n].ty = 0.0f;
            intertwined[n].r = r;
            intertwined[n].g = g;
            intertwined[n].b = b;
            intertwined[n].a = a;
            intertwined[n].x = mesh->vertices[v3].x;
            intertwined[n].y = mesh->vertices[v3].y;
            intertwined[n].z = mesh->vertices[v3].z;
            n++;
        }
    }
}

void VMI::printInterleave(int numTriangles)
{
    int i;

    printf("\n");
    for (i=0; i<numTriangles * 3; i++) {
        printf("Interleave%d (%d, %d, %d ,%d, %f, %f ,%f)\n", i,
            intertwined[i].r, intertwined[i].g, intertwined[i].b, intertwined[i].a,
            intertwined[i].x , intertwined[i].y, intertwined[i].z);
    }
}

void VMI::updateAllColorInterleave(Mesh *mesh, Color *colors)
{
    GLuint i, n = 0;
    GLubyte r, g, b, a;

    for (i=1; i<=mesh->numTriangles; i++) { // Triangles start at 1

        r = colors[i].r;
        g = colors[i].g;
        b = colors[i].b;
        a = colors[i].a;

        intertwined[n].r = r;
        intertwined[n].g = g;
        intertwined[n].b = b;
        intertwined[n].a = a;
        n++;

        intertwined[n].r = r;
        intertwined[n].g = g;
        intertwined[n].b = b;
        intertwined[n].a = a;
        n++;

        intertwined[n].r = r;
        intertwined[n].g = g;
        intertwined[n].b = b;
        intertwined[n].a = a;
        n++;
    }
}

void VMI::updateColorInterleave(Mesh *mesh, Color *colors, GLuint begin, GLuint end)
{
    GLuint i, n;
    GLubyte r, g, b, a;

    if (end > mesh->numTriangles) return;

    for (i=begin; i<end; i++) {
        
        n = i * 3;

        r = colors[i].r;
        g = colors[i].g;
        b = colors[i].b;
        a = colors[i].a;

        intertwined[n].r = r;
        intertwined[n].g = g;
        intertwined[n].b = b;
        intertwined[n].a = a;

        n++;
        intertwined[n].r = r;
        intertwined[n].g = g;
        intertwined[n].b = b;
        intertwined[n].a = a;

        n++;
        intertwined[n].r = r;
        intertwined[n].g = g;
        intertwined[n].b = b;
        intertwined[n].a = a;
    }
}

void VMI::fillColorInterleave(Mesh *mesh, GLuint begin, GLuint end, GLubyte color)
{
    GLuint i, n;

    if (end > mesh->numTriangles) return;

    for (i=begin; i<end; i++) {
        
        n = i * 3;
        intertwined[n].r = color;
        intertwined[n].g = color;
        intertwined[n].b = color;
        intertwined[n].a = color;

        n++;
        intertwined[n].r = color;
        intertwined[n].g = color;
        intertwined[n].b = color;
        intertwined[n].a = color;

        n++;
        intertwined[n].r = color;
        intertwined[n].g = color;
        intertwined[n].b = color;
        intertwined[n].a = color;
    }
}