Subversion Repositories gelsvn

                                             bool smooth, 

                                             double max_val, float gamma): SimpleShaderRenderer(vss, fss)

    const string PeriodicScalarFieldRenderer::vss =

    "	attribute float scalar;\n"

    "	varying vec3 _normal;\n"

    "	varying float s;\n"

    "	\n"

    "	void main(void)\n"

    "	{\n"

    "		gl_Position =  ftransform();\n"

    "		_normal = normalize(gl_NormalMatrix * gl_Normal);\n"

    "		s=scalar;\n"

    "	}\n";

    const string PeriodicScalarFieldRenderer::fss = 	

    "	varying vec3 _normal;\n"

    "	varying float s;\n"

    "   uniform float gamma;\n"

    "	const vec3 light_dir = vec3(0,0,1);\n"

    "	\n"

    "	void main()\n"

    "	{\n"

    "       vec3 normal = normalize(_normal);\n"

    "		float dot_ln = max(0.0,dot(light_dir, normal));\n"

    "		\n"

    "		gl_FragColor = sin(s) * vec4(-1,0,1,0);\n"

    "       gl_FragColor *= dot_ln;\n"

    "       gl_FragColor.r = pow(gl_FragColor.r, 1.0/gamma);\n"

    "       gl_FragColor.g = pow(gl_FragColor.g, 1.0/gamma);\n"

    "       gl_FragColor.b = pow(gl_FragColor.b, 1.0/gamma);\n"

    "	}\n";

    PeriodicScalarFieldRenderer::PeriodicScalarFieldRenderer(const Manifold& m, 

                                             bool smooth, 

                                             VertexAttributeVector<double>& field, 

                                             float gamma): SimpleShaderRenderer(vss, fss)

    {

        GLint old_prog;

        glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);

        glUseProgram(prog);

        GLuint scalar_attrib = glGetAttribLocation(prog, "scalar");

        //    static float& gamma = CreateCVar("display.scalar_field_renderer.gamma",2.2f);

        glUniform1fARB(glGetUniformLocationARB(prog, "gamma"), gamma);

        glNewList(display_list,GL_COMPILE);

        for(FaceIDIterator f = m.faces_begin(); f != m.faces_end(); ++f){      

            if(!smooth) 

                glNormal3dv(normal(m, *f).get());

            if(no_edges(m, *f)== 3) 

                glBegin(GL_TRIANGLES);

            else 

                glBegin(GL_POLYGON);

            for(Walker w = m.walker(*f); !w.full_circle(); w = w.circulate_face_ccw()){

                Vec3d n(normal(m, w.vertex()));

                if(smooth) 

                    glNormal3dv(n.get());

                glVertexAttrib1d(scalar_attrib, field[w.vertex()]);

                glVertex3dv(m.pos(w.vertex()).get());

            }

            glEnd();

        }

        glEndList();	

        glUseProgram(old_prog);

    }

    const string CircleFieldRenderer::vss =

    "	attribute vec2 circlepos;\n"

    "	varying vec3 _normal;\n"

    "	varying vec2 s;\n"

    "	\n"

    "	void main(void)\n"

    "	{\n"

    "		gl_Position =  ftransform();\n"

    "		_normal = normalize(gl_NormalMatrix * gl_Normal);\n"

    "		s=circlepos;\n"

    "	}\n";

    const string CircleFieldRenderer::fss =

    "	varying vec3 _normal;\n"

    "	varying vec2 s;\n"

    "   uniform float gamma;\n"

    "	const vec3 light_dir = vec3(0,0,1);\n"

    "	\n"

    "	void main()\n"

    "	{\n"

    "       vec3 normal = normalize(_normal);\n"

    "		float dot_ln = max(0.0,dot(light_dir, normal));\n"

    "		\n"

    "       vec2 _s = normalize(s);\n"

    "       float a = atan(_s.y,_s.x);\n"

    "		gl_FragColor = sin(32.0*a) * vec4(-.7,0,.7,0)+vec4(0.3);\n"

    "       gl_FragColor *= dot_ln*length(s);\n"

    "       gl_FragColor.r = pow(gl_FragColor.r, 1.0/gamma);\n"

    "       gl_FragColor.g = pow(gl_FragColor.g, 1.0/gamma);\n"

    "       gl_FragColor.b = pow(gl_FragColor.b, 1.0/gamma);\n"

    "	}\n";

    CircleFieldRenderer::CircleFieldRenderer(const Manifold& m,

                                                             bool smooth,

                                                             VertexAttributeVector<Vec2d>& field,

                                                             float gamma): SimpleShaderRenderer(vss, fss)

    {

        GLint old_prog;

        glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);

        glUseProgram(prog);

        GLuint scalar_attrib = glGetAttribLocation(prog, "circlepos");

        //    static float& gamma = CreateCVar("display.scalar_field_renderer.gamma",2.2f);

        glUniform1fARB(glGetUniformLocationARB(prog, "gamma"), gamma);

        glNewList(display_list,GL_COMPILE);

        for(FaceIDIterator f = m.faces_begin(); f != m.faces_end(); ++f){

            if(!smooth)

                glNormal3dv(normal(m, *f).get());

            if(no_edges(m, *f)== 3)

                glBegin(GL_TRIANGLES);

            else

                glBegin(GL_POLYGON);

            for(Walker w = m.walker(*f); !w.full_circle(); w = w.circulate_face_ccw()){

                Vec3d n(normal(m, w.vertex()));

                if(smooth)

                    glNormal3dv(n.get());

                glVertexAttrib2dv(scalar_attrib, field[w.vertex()].get());

                glVertex3dv(m.pos(w.vertex()).get());

            }

            glEnd();

        }

        glEndList();

        glUseProgram(old_prog);

    }

    SimpleShaderRenderer(vss,fss)

            if(!smooth) 

                glNormal3dv(normal(m, *f).get());

                if(smooth) 

    SimpleShaderRenderer(vss,fss), r(_r)

            if(!smooth) 

                glNormal3dv(normal(m, *f).get());

                if(smooth) 

    void LineFieldRenderer::draw()

    {

        GLint old_prog;

        glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);

        glUseProgram(prog);

        glBindTexture(GL_TEXTURE_3D, get_noise_texture_id());

        glCallList(display_list);

        glBindTexture(GL_TEXTURE_3D, 0);

        glUseProgram(old_prog);	

    }

    const string DualVertexRenderer::vss = 

    "#version 120\n"

    "#extension GL_EXT_gpu_shader4 : enable\n"

    "varying vec4 diffuseIn;\n"

    "varying vec3 _normalIn;\n"

    "void main(void)\n"

    "{\n"

    "   diffuseIn = gl_Color;\n"

    "   _normalIn = normalize(gl_NormalMatrix*gl_Normal);\n"

    "   gl_Position =  ftransform();\n"

    "}\n";

    const string DualVertexRenderer::gss = 

    "#version 120\n"

    "#extension GL_EXT_gpu_shader4 : enable\n"

    "#extension GL_EXT_geometry_shader4 : enable\n"

    "\n"

    "varying in vec4 diffuseIn[3];\n"

    "varying in vec3 _normalIn[3];\n"

    "varying vec4 diffuse[3];\n"

    "varying float f;\n"

    "varying vec3 _normal;\n"

    "void main(void)\n"

    "{\n"

    "  diffuse[0] = diffuseIn[0];\n"

    "  diffuse[1] = diffuseIn[1];\n"

    "  diffuse[2] = diffuseIn[2];\n"

    "\n"

    "  f = diffuseIn[0].a;\n"

    "  gl_Position = gl_PositionIn[0];\n"

    "  _normal = _normalIn[0];\n"

    "  EmitVertex();\n"

    "	\n"

    "  f = diffuseIn[1].a;\n"

    "  gl_Position = gl_PositionIn[1];\n"

    "  _normal = _normalIn[1];\n"

    "  EmitVertex();\n"

    "\n"

    "  f = diffuseIn[2].a;\n"

    "  gl_Position = gl_PositionIn[2];\n"

    "  _normal = _normalIn[2];\n"

    "  EmitVertex();\n"

    "\n"

    "  EndPrimitive();\n"

    "}\n";

    const string DualVertexRenderer::fss =

    "#version 120\n"

    "#extension GL_EXT_gpu_shader4 : enable\n"

    "\n"

    "varying float f;\n"

    "varying vec4 diffuse[3];\n"

    "varying vec3 _normal;\n"

    "\n"

    "void main(void)\n"

    "{\n"

    "   vec3 normal = normalize(_normal);\n"

    "   float col_idx=0;\n"

    "   if(f>diffuse[0].g && f<diffuse[0].b)\n"

    "      col_idx = diffuse[0].r;\n"

    "   else if(f>diffuse[1].g && f<diffuse[1].b)\n"

    "      col_idx = diffuse[1].r;\n"

    "   else if(f>diffuse[2].g && f<diffuse[2].b)\n"

    "      col_idx = diffuse[2].r;\n"

    "   vec4 col = col_idx < .5 ? vec4(1,0,0,0) : vec4(0,0,1,0);\n"

    "\n"

    " 	gl_FragColor =col*dot(normal, vec3(0,0,1));\n"

    "}\n";

    DualVertexRenderer::DualVertexRenderer(const HMesh::Manifold& m, VertexAttributeVector<Vec4d>& field)

    {		

        // Create the program

        static GLuint prog = glCreateProgram();

        static bool was_here = false;

        if(!was_here)

        {

            was_here = true;

            // Create s	haders directly from file

            static GLuint vs = create_glsl_shader(GL_VERTEX_SHADER, vss);

            static GLuint gs = create_glsl_shader(GL_GEOMETRY_SHADER_EXT, gss);

            static GLuint fs = create_glsl_shader(GL_FRAGMENT_SHADER, fss);

            // Attach all shaders

            if(vs) glAttachShader(prog, vs);

            if(gs) glAttachShader(prog, gs);

            if(fs) glAttachShader(prog, fs);

            // Specify input and output for the geometry shader. Note that this must be

            // done before linking the program.

            glProgramParameteriEXT(prog,GL_GEOMETRY_INPUT_TYPE_EXT,GL_TRIANGLES);

            glProgramParameteriEXT(prog,GL_GEOMETRY_VERTICES_OUT_EXT,3);

            glProgramParameteriEXT(prog,GL_GEOMETRY_OUTPUT_TYPE_EXT,GL_TRIANGLE_STRIP);

            // Link the program object and print out the info log

            glLinkProgram(prog);

        }

        GLint old_prog;

        glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);

        glNewList(display_list,GL_COMPILE);

        glUseProgram(prog);

        for(FaceIDIterator f = m.faces_begin(); f != m.faces_end(); ++f){

            if(no_edges(m, *f) != 3) 

                continue;

            else 

                glBegin(GL_TRIANGLES);

            for(Walker w = m.walker(*f); !w.full_circle(); w = w.circulate_face_ccw()){

                Vec3d n(normal(m, w.vertex()));

                glNormal3dv(n.get());

                glColor4dv(field[w.vertex()].get());

                glVertex3dv(m.pos(w.vertex()).get());

            }

            glEnd();

        }

        glUseProgram(old_prog);

        glEndList();	

    }