sphere.hpp

Go to the documentation of this file.

#ifndef __SPHERE__
#define __SPHERE__

#include <tucano/mesh.hpp>
#include <Eigen/Dense>
#include <cmath>

namespace Tucano
{

namespace Shapes
{

const string sphere_fragment_code = "\n"
        "#version 430\n"
        "in vec4 color;\n"
                "in vec3 normal;\n"
                "in vec4 vert;\n"
        "out vec4 out_Color;\n"
                "uniform mat4 lightViewMatrix;\n"
        "void main(void)\n"
        "{\n"
                "   vec3 eyeDirection = -normalize(vert.xyz);\n"
        "   if (dot(normal, eyeDirection) < 0.0) discard;\n"
                "   vec3 lightDirection = (lightViewMatrix * vec4(0.0, 0.0, 1.0, 0.0)).xyz;\n"
                "   lightDirection = normalize(lightDirection);\n"
                "   vec3 lightReflection = reflect(-lightDirection, normal);\n"
                "   float shininess = 100.0;\n"
                "       vec4 ambientLight = color * 0.4;\n"
                "       vec4 diffuseLight = color * 0.6 * max(dot(lightDirection, normal),0.0);\n"
                "       vec4 specularLight = vec4(1.0) *  max(pow(dot(lightReflection, eyeDirection), shininess),0.0);\n"
                "       out_Color = vec4(ambientLight.xyz + diffuseLight.xyz + specularLight.xyz, color.w);\n"
        "}\n";

const string sphere_vertex_code = "\n"
        "#version 430\n"
                "layout(location=0) in vec4 in_Position;\n"
        "out vec4 color;\n"
                "out vec3 normal;\n"
                "out vec4 vert;\n"
        "uniform mat4 modelMatrix;\n"
        "uniform mat4 viewMatrix;\n"
        "uniform mat4 projectionMatrix;\n"
        "uniform vec4 in_Color;\n"
        "void main(void)\n"
        "{\n"
                "   mat4 modelViewMatrix = viewMatrix * modelMatrix;\n"
                "   mat4 normalMatrix = transpose(inverse(modelViewMatrix));\n"
                "   normal = normalize(vec3(normalMatrix * vec4(in_Position.xyz,0.0)).xyz);\n"
                "   vert = modelViewMatrix * in_Position;\n"
        "   gl_Position = projectionMatrix * modelViewMatrix * in_Position;\n"
        "   color = in_Color;\n"
        "}\n";


class Sphere : public Tucano::Mesh {

private:

        // Shader to render sphere
        Tucano::Shader sphere_shader;

public:

        Sphere(int subdivisions = 4)
        {
                resetModelMatrix();
                createGeometry(subdivisions);

                default_color << 1.0, 0.48, 0.16, 1.0;

                sphere_shader.setShaderName("sphereShader");
                sphere_shader.initializeFromStrings(sphere_vertex_code, sphere_fragment_code);

                #ifdef TUCANODEBUG
                Tucano::Misc::errorCheckFunc(__FILE__, __LINE__, "sphere constructor");
                #endif
        }

        void render (const Tucano::Camera& camera, const Tucano::Camera& light)
        {
                Eigen::Vector4f viewport = camera.getViewport();
                glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);

                sphere_shader.bind();

        sphere_shader.setUniform("modelMatrix", model_matrix);
                sphere_shader.setUniform("viewMatrix", camera.getViewMatrix());
        sphere_shader.setUniform("projectionMatrix", camera.getProjectionMatrix());
                sphere_shader.setUniform("lightViewMatrix", light.getViewMatrix());
        sphere_shader.setUniform("in_Color", default_color);

                this->setAttributeLocation(&sphere_shader);

                this->bindBuffers();
                this->renderElements();
                this->unbindBuffers();

        sphere_shader.unbind();

                #ifdef TUCANODEBUG
                Misc::errorCheckFunc(__FILE__, __LINE__);
                #endif
        }

private:


        void createGeometry (int subdivisions)
        {
                vector< Eigen::Vector4f > vert;
                vector< GLuint > faces;
        
                vert.push_back ( Eigen::Vector4f( 1.0, 0.0, 0.0, 1.0) );
                vert.push_back ( Eigen::Vector4f(-1.0, 0.0, 0.0, 1.0) );
                vert.push_back ( Eigen::Vector4f( 0.0, 1.0, 0.0, 1.0) );
                vert.push_back ( Eigen::Vector4f( 0.0,-1.0, 0.0, 1.0) );
                vert.push_back ( Eigen::Vector4f( 0.0, 0.0, 1.0, 1.0) );
                vert.push_back ( Eigen::Vector4f( 0.0, 0.0,-1.0, 1.0) );

                int a[24] = { 0, 4, 2, 2, 4, 1, 1, 4, 3, 3, 4, 0, 0, 2, 5, 2, 1, 5, 1, 3, 5, 3, 0, 5 };
                faces.insert(faces.end(), a, a+24);
        
                // now subdivide, divide each triangle into 4
                for (int s = 0; s < subdivisions; ++s)
                {
                        vector< GLuint > sub_faces;
                        for (int i = 0; i < (int)faces.size(); i=i+3)
                        {
                                Eigen::Vector4f p0 = vert[faces[i+0]];
                                Eigen::Vector4f p1 = vert[faces[i+1]];
                                Eigen::Vector4f p2 = vert[faces[i+2]];

                                Eigen::Vector4f p3 = (p0 + p1)*0.5;
                                Eigen::Vector4f p4 = (p0 + p2)*0.5;
                                Eigen::Vector4f p5 = (p1 + p2)*0.5;
                                p3.head(3).normalize();
                                p4.head(3).normalize();
                                p5.head(3).normalize();
                        
                                vert.push_back(p3);
                                vert.push_back(p4);
                                vert.push_back(p5);

                                int ind = vert.size()-3;
                                // new faces are: (p0, p4, p3), (p4, p1, p5), (p3, p4, p5), (p3, p5, p2)
                                int b[12] = {(int)faces[i+0], ind, ind+1, ind+1, ind+2, (int)faces[i+2], ind, ind+2, ind+1, ind, (int)faces[i+1], ind+2};
                                sub_faces.insert(sub_faces.end(), b, b+12);  
                        }
                        faces.clear();
                        faces = sub_faces;
                }

                loadVertices(vert);
                loadIndices(faces);

                setDefaultAttribLocations();
                
        }

};
}
}
#endif