Subversion Repositories gelsvn

/*
 *  wireframe.cpp
 *  GEL
 *
 *  Created by J. Andreas Bærentzen on 05/08/08.
 *  Copyright 2008 __MyCompanyName__. All rights reserved.
 *
 */
#include <iostream>
#include <CGLA/Vec3f.h>
#include <GLGraphics/glsl_shader.h>
#include "wireframe.h"
#include <HMesh/FaceCirculator.h>

using namespace HMesh;
using namespace std;
using namespace CGLA;
using namespace GLGraphics;

namespace 
{
        GLuint wire_prog_hex, wire_prog_generic;
        GLuint texid=-1;
}

void initialize_generic()
{
        // Create shaders directly from file
        GLuint vs = create_glsl_shader(GL_VERTEX_SHADER, "/Users/jab/GEL/apps/MeshEdit", "wire-generic.vert");
        GLuint gs = create_glsl_shader(GL_GEOMETRY_SHADER_EXT, "/Users/jab/GEL/apps/MeshEdit", "wire-generic.geom");
        GLuint fs = create_glsl_shader(GL_FRAGMENT_SHADER, "/Users/jab/GEL/apps/MeshEdit", "wire-generic.frag");
        
        // Create the program
        wire_prog_generic = glCreateProgram();
        
        // Attach all shaders
        if(vs) glAttachShader(wire_prog_generic, vs);
        if(gs) glAttachShader(wire_prog_generic, gs);
        if(fs) glAttachShader(wire_prog_generic, fs);
        
        // Specify input and output for the geometry shader. Note that this must be
        // done before linking the program.
        glProgramParameteriEXT(wire_prog_generic,GL_GEOMETRY_INPUT_TYPE_EXT,GL_POINTS);
        glProgramParameteriEXT(wire_prog_generic,GL_GEOMETRY_VERTICES_OUT_EXT,20);
        glProgramParameteriEXT(wire_prog_generic,GL_GEOMETRY_OUTPUT_TYPE_EXT,GL_TRIANGLE_STRIP);
        
        // Link the program object and print out the info log
        glLinkProgram(wire_prog_generic);
        
        glGenTextures(1,&texid);
        glEnable(GL_TEXTURE_RECTANGLE_ARB);
        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, texid);
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP);
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP);
        
}

void initialize_hex()
{
        // Create shaders directly from file
        GLuint vs = create_glsl_shader(GL_VERTEX_SHADER, "/Users/jab/GEL/apps/MeshEdit", "wire-hex.vert");
        GLuint gs = create_glsl_shader(GL_GEOMETRY_SHADER_EXT, "/Users/jab/GEL/apps/MeshEdit", "wire-hex.geom");
        GLuint fs = create_glsl_shader(GL_FRAGMENT_SHADER, "/Users/jab/GEL/apps/MeshEdit", "wire-hex.frag");
        
        // Create the program
        wire_prog_hex = glCreateProgram();
        
        // Attach all shaders
        if(vs) glAttachShader(wire_prog_hex, vs);
        if(gs) glAttachShader(wire_prog_hex, gs);
        if(fs) glAttachShader(wire_prog_hex, fs);
        
        // Specify input and output for the geometry shader. Note that this must be
        // done before linking the program.
        glProgramParameteriEXT(wire_prog_hex,GL_GEOMETRY_INPUT_TYPE_EXT,GL_TRIANGLES_ADJACENCY_EXT);
        glProgramParameteriEXT(wire_prog_hex,GL_GEOMETRY_VERTICES_OUT_EXT,6);
        glProgramParameteriEXT(wire_prog_hex,GL_GEOMETRY_OUTPUT_TYPE_EXT,GL_TRIANGLE_STRIP);
        
        // Link the program object and print out the info log
        glLinkProgram(wire_prog_hex);   
}

void initialize_wireframe_shaders()
{
        static bool washere = false;
        if(!washere)
        {
                washere = true;
                initialize_generic();
                initialize_hex();
        }
}

void draw_as_wire(Manifold& m, bool per_vertex_norms)
{

        GLint vpdim[4];
        glGetIntegerv(GL_VIEWPORT,vpdim); 
        
        glUseProgram(wire_prog_hex);
        
        GLuint no_edges_attrib = glGetAttribLocationARB(wire_prog_hex, "no_edges");
        
        // Set the value of a uniform
        glUniform2f(glGetUniformLocation(wire_prog_hex,"WIN_SCALE"), 
                                static_cast<float>(vpdim[2]/2), static_cast<float>(vpdim[3]/2));

        glBegin(GL_TRIANGLES_ADJACENCY_EXT);
        for(FaceIter f=m.faces_begin(); f != m.faces_end(); ++f)
        {
                glNormal3fv(normal(f).get());
                glVertexAttrib1f(no_edges_attrib, no_edges(f));
                FaceCirculator fc(f);
                for(int i=0;i<6;++i)
                {
                        glVertex3fv(fc.get_vertex()->pos.get());
                        if(!fc.end()) ++fc;
                }
        }
        glEnd();
        glUseProgram(0);
        
        /*/
        int total_vertices = 0;
        for(FaceIter f=m.faces_begin(); f != m.faces_end(); ++f)
                total_vertices += no_edges(f);
        
        vector<Vec3f> mesh_tex(ceil(total_vertices*1.01/4096)*4096);
        vector<Vec3i> face_idx(m.no_faces());
        vector<Vec3f> normals(m.no_faces());
        int column=0;
        int row=0;
        for(FaceIter f=m.faces_begin(); f != m.faces_end(); ++f)
        {
                int N = no_edges(f);
                if( (N + column) >= 4096)
                {
                        ++row;
                        column = 0;
                }
                face_idx.push_back(Vec3i(column, row, N));
                normals.push_back(normal(f));
                for(FaceCirculator fc(f); !fc.end(); ++fc)
                {
                        mesh_tex[column + row * 4096] = fc.get_vertex()->pos;
                        ++column;                       
                }
        }
        
        GLint vpdim[4];
        glGetIntegerv(GL_VIEWPORT,vpdim); 
        
        glUseProgram(wire_prog_generic);
        
        // Set the value of a uniform
        glUniform2f(glGetUniformLocation(wire_prog_generic,"WIN_SCALE"), 
                                static_cast<float>(vpdim[2]/2), static_cast<float>(vpdim[3]/2));
        glUniform1iARB(glGetUniformLocationARB(wire_prog_generic, "mesh_tex"),0);
        glEnable(GL_TEXTURE_RECTANGLE_ARB);
        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, texid);
        glTexImage2D(GL_TEXTURE_RECTANGLE_ARB,0,GL_RGB32F_ARB,4096,row+1,0,GL_RGB,GL_FLOAT,&mesh_tex[0]);
        
        glBegin(GL_POINTS);
        for(int i=0;i<face_idx.size(); ++i)
        {
                glNormal3fv(normals[i].get());
                glVertex3iv((const GLint*)face_idx[i].get());
        }
        glEnd();
        glUseProgram(0);
        glDisable(GL_TEXTURE_RECTANGLE_ARB);
*/
}