arrow.hpp

Go to the documentation of this file.

#ifndef __ARROW__
#define __ARROW__

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

namespace Tucano
{

namespace Shapes
{

const string arrow_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 lightDirection = (lightViewMatrix * vec4(0.0, 0.0, 1.0, 0.0)).xyz;\n"
                "   lightDirection = normalize(lightDirection);\n"
                "   vec3 lightReflection = reflect(-lightDirection, normal);\n"
                "   vec3 eyeDirection = -normalize(vert.xyz);\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 arrow_vertex_code = "\n"
        "#version 430\n"
                "in vec4 in_Position;\n"
                "in vec4 in_Normal;\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_Normal.xyz,0.0)).xyz);\n"
                "   vert = modelViewMatrix * in_Position;\n"
        "   gl_Position = projectionMatrix * modelViewMatrix * in_Position;\n"
        "   color = in_Color;\n"
        "}\n";



class Arrow : public Tucano::Mesh {

private:

        Tucano::Shader arrow_shader;

        Eigen::Vector4f color;

        float body_height;
        
        float head_height;

        float body_radius;

        float head_radius;

public:

        Arrow(float rcyl = 0.05, float hcyl = 1.0, float rcon = 0.1, float hcon = 0.15, int subs = 32 )
        {
                resetModelMatrix();

                body_height = hcyl;
                head_height = hcon;
                body_radius = rcyl;
                head_radius = rcon;
                createGeometry(subs);

                setColor(Eigen::Vector4f(0.0, 0.7, 0.7, 1.0));

                arrow_shader.setShaderName("arrowShader");
                arrow_shader.initializeFromStrings(arrow_vertex_code, arrow_fragment_code);

        cout << "created arrow" << endl;

        }

        void setColor (const Eigen::Vector4f c)
        {
                color = c;
        }

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

                arrow_shader.bind();

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

                this->setAttributeLocation(&arrow_shader);

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

        arrow_shader.unbind();

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

private:

        void createGeometry (int subdivisions)
        {
                vector< Eigen::Vector4f > vert;
                vector< Eigen::Vector3f > norm;
                vector< GLuint > faces;

                float x, y, theta;
                // create vertices for top and bottom caps
                for (int i = 0; i < subdivisions; ++i)
                {
                        theta = 2.0*M_PI*i/(float)subdivisions;
                        x = sin(theta)*body_radius;
                        y = cos(theta)*body_radius;
                        vert.push_back(Eigen::Vector4f(x, y, body_height, 1.0) );
                        vert.push_back(Eigen::Vector4f(x, y, 0.0, 1.0));
                        norm.push_back(Eigen::Vector3f(x, y, 0.0));
                        norm.push_back(Eigen::Vector3f(x, y, 0.0));
                }
                
                // create a face with every three vertices for arrow body
                for (int i = 0; i < subdivisions*2; ++i)
                {
                        faces.push_back(i);
                        faces.push_back((i+1)%(subdivisions*2));
                        faces.push_back((i+2)%(subdivisions*2));
                }

                // create bottom cap
                vert.push_back(Eigen::Vector4f(0.0, 0.0, 0.0, 1.0));
                norm.push_back(Eigen::Vector3f(0.0, 0.0, -1.0));
                int center_index = vert.size()-1;
                int offset = vert.size();
                for (int i = 0; i < subdivisions; ++i)
                {
                        theta = 2.0*M_PI*i/(float)subdivisions;
                        x = sin(theta)*body_radius;
                        y = cos(theta)*body_radius;
                        vert.push_back(Eigen::Vector4f(x, y, 0.0, 1.0));
                        norm.push_back(Eigen::Vector3f(0.0, 0.0, -1.0));
                }

                for (int i = 0; i < subdivisions; ++i)
                {
                        faces.push_back(i+offset);
                        faces.push_back((i+1)%(subdivisions) + offset);
                        faces.push_back(center_index);
                }

                // create vertices for arrow head 
                offset = vert.size();
                for (int i = 0; i < subdivisions; ++i)
                {
                        theta = 2.0*M_PI*i/(float)subdivisions;
                        x = sin(theta)*head_radius;
                        y = cos(theta)*head_radius;
                        vert.push_back(Eigen::Vector4f(x, y, body_height, 1.0));
                        norm.push_back(Eigen::Vector3f(x, y, 0.0));
                }

                // apex vertex
                vert.push_back(Eigen::Vector4f(0.0, 0.0, body_height+head_height, 1.0));
                norm.push_back(Eigen::Vector3f(0.0, 0.0, 1.0));

        
                // create a face with every two vertices and apex
                for (int i = 0; i < subdivisions; ++i)
                {
                        faces.push_back(i+offset);
                        faces.push_back((i+1)%(subdivisions) + offset);
                        faces.push_back(vert.size()-1);
                }

                // create head cap
                vert.push_back(Eigen::Vector4f(0.0, 0.0, body_height, 1.0));
                norm.push_back(Eigen::Vector3f(0.0, 0.0, -1.0));
                center_index = vert.size()-1;
                offset = vert.size();
                for (int i = 0; i < subdivisions; ++i)
                {
                        theta = 2.0*M_PI*i/(float)subdivisions;
                        x = sin(theta)*head_radius;
                        y = cos(theta)*head_radius;
                        vert.push_back(Eigen::Vector4f(x, y, body_height, 1.0));
                        norm.push_back(Eigen::Vector3f(0.0, 0.0, -1.0));
                }

                for (int i = 0; i < subdivisions; ++i)
                {
                        faces.push_back(i+offset);
                        faces.push_back((i+1)%(subdivisions) + offset);
                        faces.push_back(center_index);
                }

                loadVertices(vert);
                loadNormals(norm);
                loadIndices(faces);

                setDefaultAttribLocations();
                
        }

};
}
}
#endif