Initial commit

1 files changed, 472 insertions, 0 deletions

diff --git a/src/glesrenderer.h b/src/glesrenderer.h
new file mode 100644
index 0000000..e5cc723
--- /dev/null
+++ b/src/glesrenderer.h
@@ -0,0 +1,472 @@
+/***************************************************************************
+ *   Copyright (C) 2012 by Walter Roth                                     *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#ifndef GLESRENDERER_H
+#define GLESRENDERER_H
+
+#include <QOpenGLShaderProgram>
+#include <QList>
+#include <QStack>
+
+#include "glcolorrgba.h"
+#include "gldefines.h"
+
+/** \brief A render program that can be used as a simple replacement for the OpenGL fixed
+  * function pipeline.
+  * \author Walter Roth, 2014
+  *
+  * GLESRenderer supports vertex, colors, normals, texCoords, textures and matrix manipulation.
+  * It owns a modelview and a projection matrix which can be used like in the old days of OpenGL 1.
+  * The vertex shader program needs to stick to the following variable names:
+  * attribute highp vec4 a_Vertex;
+  * attribute highp vec4 a_Color;
+  * attribute highp vec3 a_Normal;
+  * attribute highp vec2 a_TexCoord;
+  *
+  * uniform bool u_ColorArrayEnabled
+  * uniform bool u_LightingEnabled;
+  * uniform highp mat4 u_MvpMatrix;
+  * uniform highp mat3 u_NormalMatrix;
+  * uniform highp vec3 u_LightDirection;
+  * uniform highp vec4 u_AmbientAndDiffuseColor;
+  * uniform highp vec4 u_SpecularColor;
+  * uniform highp float u_Shininess;
+  * uniform mediump float int u_PointSize;
+  *
+  * The fragment shader texture variable must have the following name:
+  * uniform sampler2d s_Texture;
+  *
+  * These names are used to determine the locations of the varables in the shaders.
+  * If you need more variables, subclass GLESRenderer and add new variable(s) to
+  * location_XXX variables. Extend virtual intialize(), bind() and disableAttributeArrays() functions
+  * to support the new variable(s).
+  *
+  * The shader source should be in a separate file (e.g. added to the resources).
+  * Example shaders vshader1 and fshader1 emulate a simple fixed-function lighted OpenGL 1 scene.
+  *
+  * Call initialize, after a valid OpenGL context has been made current.
+  * Setup viewing with setViewport, setLookAt and setPerspective.
+  * Viewport coordinates must be given as
+  * GL-viewport coordinates, where lower left is (0,0).
+  * Call bind to bind the program and set the uniform values you need.
+  * After this, call activateAttributeLocation to enable the attribute arrays.
+  * To change attribute arrays, call disableAttributeArrays and then again activateAttributeLocations.
+  * Finally call release.
+  *
+  * GLESRenderer contains functions for projecting points from modelspace to screen and unprojecting points
+  * from screen to model space. These functions use the current matrix settings. Therefore, you have to
+  * (re)set the matrices to the values that are used to paint the model, before you call the project and
+  * unproject functions.
+  *
+  * For convenient mouse interaction, GLESRenderer supplies the calculateMousePoints(), distanceToMouseClick()
+  * and mouseIntersection() functions. These functions use the unproject functions and therefore do also need
+  * valid model painting matrix settings.
+  */
+class GLESRenderer  : public QObject
+{
+    Q_OBJECT
+public:
+    typedef enum{
+        VERTEX_LOCATION,
+        NORMAL_LOCATION,
+        COLOR_LOCATION,
+        TEXCOORD_LOCATION
+    }AttributeLocation;
+
+    explicit GLESRenderer(QObject *parent,
+                          const QString & vShaderFilename = ":/src/vshader.vsh",
+                          const QString & fShaderFilename = ":/src/fshader.fsh");
+
+    virtual ~GLESRenderer();
+
+    //=========================================================================
+    /**
+      * \name Initialization, binding and releasing
+      */
+    ///@{
+    /**
+      * Compile shaders, get attribute and uniform locations of shaders.
+      * This function needs an active OpenGL context.
+      * Returns false, if initialization failed.
+      */
+    virtual bool initialize();
+
+    /**
+      * Bind program and transfer attribute and uniform data to the shaders.
+      * Calls initialize, if not alraedy initialized.
+      * Returns false, if binding failed.
+      */
+    virtual bool bind();
+
+    /**
+      * Releases program. To be called, when all rendering is finished.
+      * Calls disableAttributeArrays and releases program.
+      */
+    void release();
+    ///@}
+
+    //=================================================================
+    /**
+      * \name Unproject, project and mouse interaction functions
+      */
+    ///@{
+    /**
+      * Uses viewport and matrix settings to reverse the vertex transformation chain.
+      * vWin x,y and z are the coordinates in window coordinates. Lower left of viewport
+      * is winX = 0, winY = 0. Use winZ = 0.0 for a point on near clipping plane
+      * and winZ = 1.0 for a point on far clipping plane.
+      * This function assumes, that the vertex shader computes gl_positon as v * mvpMatrix.
+      * Use a custom shader reverse function, if this is not true.
+      * Returns coordinate in object space.
+      */
+    QVector3D unProjectViewportPoint(const QVector3D & vWin);
+
+    /**
+      * Performs inverse viewport transform.
+      */
+    QVector3D viewportToClip(const QVector3D & v);
+
+    /**
+      * Returns the points on near and far clipping plane, that correspond to the
+      * mouseX and mouseY coordinates of a mouse click.
+      * mouseX and mouseY are coordinates as delivered by QMouseEvent or QDeclarativeMouseEvent.
+      */
+    void calculateMousePoints(QVector3D * nearPoint, QVector3D * farPoint, const QPoint &mousePos );
+
+    /**
+      * Calculate the distance of the "mouse ray line" to point p in model space.
+      * mouseX, mouseY are the coordinates of the mouse click as delivered by QMouseEvent.
+      * Returns distance.
+      */
+    float distanceToMouseClick(QVector3D p, const QPoint &mousePos);
+
+    /**
+      * Calculates intersection of "mouse ray line" with the plane defined by normal and d.
+      * mouseX, mouseY are the coordinates of the mouse click as delivered by QMouseEvent.
+      * Returns true, if intersection is in the visible frustum, else returns false.
+      * If return value is true, *intersection is the intersection of the mouse ray line with
+      * the plane normal*(x,y,z) + d = 0.
+      * If return value is false, *intersection is not modified.
+      */
+    bool mouseIntersection(QVector3D * intersection, QVector3D normal, float d, const QPoint &mousePos);
+    ///@}
+
+
+    //======================================================================================
+    ///@{
+
+      /** Getters and setters for uniforms
+       */
+    /**
+      * Set modelview matrix. Updates mvpMatrix and normalMatrix too.
+      * Call setPMatrix or setPerspective first.
+      */
+    void setMvMatrix(const QMatrix4x4 newVal);
+    /**
+      * Getter for debugging.
+      */
+    const QMatrix4x4 & getMvMatrix(){return m_mvMatrix;}
+     /**
+       * Getter for debugging.
+       */
+     const QMatrix3x3 & getNormalMatrix(){return m_normalMatrix;}
+
+    /**
+      * Sets mvMatrix to a lookAt transformation.
+      * Call setPMatrix or setPerspective first.
+      */
+    void setLookAt(const QVector3D & eye,const QVector3D & center,const QVector3D & up );
+
+    /**
+      * Set projection matrix. Call setMvMatrix after this.
+      */
+    void setPMatrix(const QMatrix4x4 newVal);
+    /**
+      * Getter for debugging.
+      */
+    const QMatrix4x4 & getPMatrix(){return m_pMatrix;}
+    /**
+      * Setup projection matrix. Call setMvMatrix after this.
+      */
+    void setPerspective(GLfloat fovy, GLfloat aspect, GLfloat nearClip, GLfloat farClip);
+    /**
+     * @brief setOrtho Set pMatrix to an orthogonal projection.
+     * @param left
+     * @param right
+     * @param bottom
+     * @param top
+     * @param nearPlane
+     * @param farPlane
+     */
+    void setOrtho(float left, float right, float bottom, float top, float nearPlane, float farPlane);
+    /**
+      * Set viewport
+      * Viewport coordinates must be given as
+      * GL-viewport coordinates, where lower left is (0,0).
+      */
+    void setViewport(int x, int y, int w, int h);
+    /**
+      * Get the present viewport settings from GL engine
+      */
+    void readGLViewportSettings();
+
+    /**
+      * Set the color for ambient and diffuse lighting (or no lighting).
+      * Alternatively use a color array and color attribute.
+      * Defaults to white.
+      */
+    void setAmbientAndDiffuseColor(const GLColorRgba newVal);
+    /**
+      * Set the dimming factor for ambient light.
+      * Defaults to 0.2.
+      */
+    void setAmbientLightBrightness(float newVal);
+
+    /**
+      * Set the color for specular lighting.
+      * Defaults to white.
+      */
+    void setSpecularColor(const GLColorRgba newVal);
+    /**
+      * Set the shininess (exponent) for specular lighting.
+      * Defaults to 200.
+      */
+    void setShininess(float newVal);
+
+    /**
+      * Enable / disable lighting.
+      * Defaults to false.
+      */
+    void setLightingEnabled(bool newVal);
+    /**
+      * Returns lighting flag.
+      */
+    bool isLightingEnabled(){return m_lightingEnabled;}
+    /**
+      * Enable / disable color array.
+      * Defaults to false.
+      */
+    void setColorArrayEnabled(bool newVal);
+    /**
+      * Returns lighting flag.
+      */
+    bool isColorArrayEnabled(){return m_colorArrayEnabled;}
+    /**
+      * Set the texture flag.
+      * Defaults to false.
+      */
+    void setTextureEnabled(bool newVal);
+    /**
+      * Returns texture flag;
+      */
+    bool isTextureEnabled(){return m_textureEnabled;}
+    /**
+      * Set light direction.
+      * Defaults to (1.0, 1.0, 1.0)
+      */
+    void setLightDirection(const QVector3D & newVal);
+    /**
+      * Getter.
+      */
+    const QVector3D getLightDirection(){return m_lightDirection;}
+
+    /**
+      * Set size of points drawn with GL_POINTS.
+      * Defaults to 2.0.
+      */
+    void setPointSize(int newVal);
+
+    /**
+      * Returns pointSize;
+      */
+    int getPointSize(){return m_pointSize;}
+
+    /**
+      * Pushes mvMatrix.
+      */
+    void pushMvMatrix(){m_mvMatrixStack.push(m_mvMatrix);}
+
+    /**
+      * Pops mvMatrix from stack and updates normalMatrix and mvpMatrix.
+      */
+    void popMvMatrix();
+
+    /**
+      * Translates mvMatrix by v
+      */
+    void translate(const QVector3D & v);
+    void translate(float x, float y, float z);
+    /**
+      * Rotates mvMatrix by angle around axis
+      */
+    void rotate(GLfloat angle, const QVector3D & axis);    
+    /**
+      * Rotates mvMatrix by angle around axis (x,y,z)
+      */
+    void rotate(float angle, float x, float y, float z);
+    void zoom(float zoomFactor);
+
+    /**
+     * @brief addTransformation
+     * Multiplies additionalTransformation to mvMatrix.
+     * @param additionalTransformation
+     */
+    void addTransformation(const QMatrix4x4 additionalTransformation);
+
+    /**
+      * Scales mvMatrix.
+      */
+    void scale(const QVector3D & v );
+
+    ///@}
+
+    //======================================================================================
+
+    ///@{
+    /**
+      * \name Attribute setters
+      */
+
+    /**
+      * Enables 2D Vertex, normal, color or texCoord arrays and sets start adresses of arrays
+      * Type may be: VERTEX_LOCATION, NORMAL_LOCATION, COLOR_LOCATION, TEXCOORD_LOCATION
+      */
+    bool activateAttributeArray (AttributeLocation location, const QVector2D * values, int stride = 0 );
+    /**
+      * Enables 3D Vertex, normal, color or texCoord arrays and sets start adresses of arrays
+      * Type may be: VERTEX_LOCATION, NORMAL_LOCATION, COLOR_LOCATION, TEXCOORD_LOCATION
+      */
+    bool activateAttributeArray (AttributeLocation location, const QVector3D * values, int stride = 0 );
+     /**
+      * Enables 4D Vertex or color arrays and sets start adresses of arrays
+      * Type may be: VERTEX_LOCATION, COLOR_LOCATION
+      */
+    bool activateAttributeArray (AttributeLocation location, const QVector4D * values, int stride = 0 );
+    /**
+      * Enables 3D Vertex, normal, color or texCoord buffer
+      * location may be: VERTEX_LOCATION, NORMAL_LOCATION, COLOR_LOCATION, TEXCOORD_LOCATION
+      * numbersPerElement: 3 for vertex, 2 or 3 for texture, 3 or 4 for color
+      */
+    bool activateAttributeBuffer (AttributeLocation location, int numbersPerElement, int bufferId);
+    /**
+      * Disables all enabled attribute arrays.
+      * To be called after rendering an object.
+      */
+    virtual void disableAttributeArrays();
+    ///@}
+
+    //==============================================================
+    ///@{
+
+    /**
+      * \name Debugging
+      */
+
+    /**
+      * Multiplies current mvp matrix with v. Mainly for debugging.
+      */
+    QVector3D modelToClip(const QVector3D & v);
+    /**
+      * Performs viewport transform. Mainly for debugging.
+      */
+    QVector3D clipToViewport(const QVector3D & v);
+    ///@}
+
+protected:
+
+    /**
+     * @brief activateAttributeArray
+     * Enables  Vertex, normal, color or texCoord arrays and sets start adresses of arrays
+     * location may be: VERTEX_LOCATION, NORMAL_LOCATION, COLOR_LOCATION, TEXCOORD_LOCATION
+     * @param location
+     * @param values Address of first number
+     * @param tupleSize Numbers per vertex
+     * @param stride Distance to next tuple
+     * @return
+     */
+    bool activateAttributeArray (AttributeLocation location, const float * values, int tupleSize, int stride = 0 );
+
+    bool m_initialized;
+    bool m_bound;
+
+    //Uniforms to be passed to the shader
+    //flags
+    bool m_lightingEnabled; // flag for lighting
+    bool m_colorArrayEnabled; //flag for a valid color array
+    bool m_textureEnabled; //flag for active texturing
+    bool m_invertedMvpMatrixValid; //flag for a valid inverted ModelViewProjection matrix
+    //matrices
+    QMatrix4x4 m_mvpMatrix; //combined modelview and projection matrix
+    //The inverted mvp matrix for unproject purposes
+    //Use the invertedMvpMatrixValid flag for calculating it when required.
+    QMatrix4x4 m_invertedMvpMatrix;
+    QStack <QMatrix4x4>m_mvMatrixStack;
+    QMatrix4x4 m_mvMatrix; //modelview matrix
+    QMatrix4x4 m_pMatrix;  //projection matrix
+    float m_fovy;
+    float m_aspect;
+    float m_nearClip; //near clipping plane
+    float m_farClip;  //far clipping plane
+    bool m_OrthoMode;
+    QMatrix3x3 m_normalMatrix; //matrix for normal transformation
+    //lighting
+    QVector3D m_lightDirection; //direction of directional light
+    QVector3D m_halfPlaneVector; //half plane vector for specular light calculation
+    GLColorRgba m_ambientAndDiffuseColor;
+    float m_ambientLightBrightness;
+    GLColorRgba m_specularColor;
+    float m_shininess;
+    //texturing
+    int m_pointSize;
+
+    //Shaders and program
+    QString m_vShaderFileName; //vertex shader
+    QString m_fShaderFileName; //fragment shader
+    QOpenGLShader * m_vShader; //vertex shader
+    QOpenGLShader * m_fShader; // fragment shader
+    QOpenGLShaderProgram * m_renderProgram;
+
+    // Locations of shader variables
+    int m_location_aVertex;
+    int m_location_aColor;
+    int m_location_aNormal;
+    int m_location_aTexCoord;
+    int m_location_uColorArrayEnabled;
+    int m_location_uLightingEnabled;
+    int m_location_uNormalMatrix;
+    int m_location_uMvpMatrix;
+    int m_location_uAmbientAndDiffuseColor;
+    int m_location_uAmbientLightBrightness;
+    int m_location_uSpecularColor;
+    int m_location_uShininess;
+    int m_location_uLightDirection;
+    int m_location_uHalfPlaneVector;
+    int m_location_uPointSize;
+    int m_location_uTextureSampler;
+    int m_location_uTextureEnabled;
+
+    //The list of enabled attribute locations
+    QList<int>m_activeAttributeLocations;
+    //viewport
+    int m_viewportX;
+    int m_viewportY;
+    int m_viewportW;
+    int m_viewportH;
+};
+
+#endif // GLESRENDERER_H