cylinder.hpp

Go to the documentation of this file.

#ifndef __CYLINDER__
#define __CYLINDER__

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

namespace Tucano
{

namespace Shapes
{

const string cylinder_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"
        "uniform int with_cap;\n"
        "void main(void)\n"
        "{\n"
                "   vec3 eyeDirection = -normalize(vert.xyz);\n"
        "   if (with_cap == 1 && 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 cylinder_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 Cylinder : public Tucano::Mesh {

private:

        Tucano::Shader cylinder_shader;

        float cylinder_height = 2.0;

        float cylinder_radius = 1.0;
    
    bool with_cap = true;

public:

        Cylinder(float r = 1.0, float h = 2.0, int subs_xy = 32, int subs_z = 8, bool cap = true)
        {
        with_cap = cap;
                resetModelMatrix();
        cylinder_radius = r;
        cylinder_height = h;
                createGeometry(subs_xy, subs_z);

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

                cylinder_shader.setShaderName("cylinderShader");
                cylinder_shader.initializeFromStrings(cylinder_vertex_code, cylinder_fragment_code);

        #ifdef TUCANODEBUG
        Tucano::Misc::errorCheckFunc(__FILE__, __LINE__, "cylinder 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]);

                cylinder_shader.bind();

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

                this->setAttributeLocation(&cylinder_shader);

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

        cylinder_shader.unbind();

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

        float getHeight (void)
        {
                return cylinder_height;
        }

        float getRadius (void)
        {
                return cylinder_radius;
        }

private:


        void createGeometry (int subs_xy, int subs_z)
        {

                vector< Eigen::Vector4f > vert;
                vector< Eigen::Vector3f > norm;
                vector< GLuint > faces;

                float x, y, theta;

                // create vertices for rings
        for (int j = 0; j <= subs_z + 1; ++j)
        {
            float z = j * (cylinder_height / (float)(subs_z+1));
            for (int i = 0; i < subs_xy; ++i)
            {
                theta = 2.0*M_PI*i/(float)subs_xy;
                x = sin(theta)*cylinder_radius;
                y = cos(theta)*cylinder_radius;
                vert.push_back(Eigen::Vector4f(x, y, z, 1.0));
                norm.push_back(Eigen::Vector3f(x, y, 0.0));
            }
        }

                // create a face with every three vertices between two rings
        // every vertice creates a tringle with two vertices from lower ring and top ring, and another with two vertices from top ring and one from lower
        for (int j = 0; j <= subs_z; ++j)
        {
                    for (int i = 0; i < subs_xy; ++i)
                    {
                            faces.push_back(i + j*subs_xy); // current vertex
                faces.push_back(i + (j+1)*subs_xy); // same vertex on lower ring
                faces.push_back(((i+1)%subs_xy) + (j+1)*subs_xy); // next vertex on lower ring
                faces.push_back((i+subs_xy-1)%subs_xy + j*subs_xy); // previous vertex on current ring
                faces.push_back(i + (j+1)*subs_xy); // same vertex on lower ring
                            faces.push_back(i + j*subs_xy); // current vertex
                    }
        }

        if (with_cap)
        {
            // create top cap
            vert.push_back(Eigen::Vector4f(0.0, 0.0, cylinder_height, 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 < subs_xy; ++i)
            {
                theta = 2.0*M_PI*i/(float)subs_xy;
                x = sin(theta)*cylinder_radius;
                y = cos(theta)*cylinder_radius;
                vert.push_back(Eigen::Vector4f(x, y, cylinder_height, 1.0));
                norm.push_back(Eigen::Vector3f(0.0, 0.0,  1.0));
            }

            for (int i = 0; i < subs_xy; ++i)
            {
                faces.push_back(i+offset);
                faces.push_back((i+1)%(subs_xy) + offset);
                faces.push_back(center_index);
            }
            // 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));
            center_index = vert.size()-1;
            offset = vert.size();
            for (int i = 0; i < subs_xy; ++i)
            {
                theta = 2.0*M_PI*i/(float)subs_xy;
                x = sin(theta)*cylinder_radius;
                y = cos(theta)*cylinder_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 < subs_xy; ++i)
            {
                faces.push_back(i+offset);
                faces.push_back(center_index);
                faces.push_back((i+1)%(subs_xy) + offset);
            }
        }

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

                setDefaultAttribLocations();
                
        }

};
}
}
#endif