OpenGL Matrix Library

OpenGL Mathematics (GLM) 

http://glm.g-truc.net/

http://people.inf.elte.hu/stbqaai/szGraf/GL/glm-0.9.B.1/

VSML

vsml in action

http://www.lighthouse3d.com/very-simple-libs/vsml/vsml-in-action/

vsml source code

vsml.h

/** ---------------------------------------------------------- * /class VSML * * Lighthouse3D * * VSML - Very Simple Matrix Library * * Full documentation at * http://www.lighthouse3d.com/very-simple-libs * * This class aims at easing geometric transforms, camera * placement and projection definition for programmers * working with OpenGL core versions. * * This lib requires: * * GLEW (http://glew.sourceforge.net/) * ---------------------------------------------------------------*/ #ifndef __VSML__ #define __VSML__ // uncomment this if you want VSML to always update // the matrices for you. Otherwise you'll have to call // a matrixTo* function to get them updated before // calling OpenGL draw commands //#define VSML_ALWAYS_SEND_TO_OPENGL #include <vector> #include <GL/glew.h> class VSML { public: /// Enumeration of the matrix types enum MatrixTypes{ MODELVIEW, PROJECTION } ; /// Singleton pattern static VSML* gInstance; /// Call this to get the single instance of VSML static VSML* getInstance (void); ~VSML(); /** Call this function to init the library for a particular * program shader if using uniform variables * * /param modelviewLoc location of the uniform variable * for the modelview matrix * * /param projLoc location of the uniform variable * for the projection matrix */ void initUniformLocs(GLuint modelviewLoc, GLuint projLoc); /** Call this function to init the library for a particular * program shader if using uniform blocks * * /param buffer index of the uniform buffer * /param modelviewOffset offset within the buffer of * the modelview matrix * /param projOffset offset within the buffer of * the projection matrix */ void initUniformBlock(GLuint buffer, GLuint modelviewOffset, GLuint projOffset); /** Similar to glTranslate*. Can be applied to both MODELVIEW * and PROJECTION matrices. * * /param aType either MODELVIEW or PROJECTION * /param x,y,z vector to perform the translation */ void translate(MatrixTypes aType, float x, float y, float z); /** Similar to glTranslate*. Applied to MODELVIEW only. * * /param x,y,z vector to perform the translation */ void translate(float x, float y, float z); /** Similar to glScale*. Can be applied to both MODELVIEW * and PROJECTION matrices. * * /param aType either MODELVIEW or PROJECTION * /param x,y,z scale factors */ void scale(MatrixTypes aType, float x, float y, float z); /** Similar to glScale*. Applied to MODELVIEW only. * * /param x,y,z scale factors */ void scale(float x, float y, float z); /** Similar to glTotate*. Can be applied to both MODELVIEW * and PROJECTION matrices. * * /param aType either MODELVIEW or PROJECTION * /param angle rotation angle in degrees * /param x,y,z rotation axis in degrees */ void rotate(MatrixTypes aType, float angle, float x, float y, float z); /** Similar to glRotate*. Applied to MODELVIEW only. * * /param angle rotation angle in degrees * /param x,y,z rotation axis in degrees */ void rotate(float angle, float x, float y, float z); /** Similar to glLoadIdentity. * * /param aType either MODELVIEW or PROJECTION */ void loadIdentity(MatrixTypes aType); /** Similar to glMultMatrix. * * /param aType either MODELVIEW or PROJECTION * /param aMatrix matrix in column major order data, float[16] */ void multMatrix(MatrixTypes aType, float *aMatrix); /** Similar to gLoadMatrix. * * /param aType either MODELVIEW or PROJECTION * /param aMatrix matrix in column major order data, float[16] */ void loadMatrix(MatrixTypes aType, float *aMatrix); /** Similar to glPushMatrix * * /param aType either MODELVIEW or PROJECTION */ void pushMatrix(MatrixTypes aType); /** Similar to glPopMatrix * * /param aType either MODELVIEW or PROJECTION */ void popMatrix(MatrixTypes aType); /** Similar to gluLookAt * * /param xPos, yPos, zPos camera position * /param xLook, yLook, zLook point to aim the camera at * /param xUp, yUp, zUp camera's up vector */ void lookAt(float xPos, float yPos, float zPos, float xLook, float yLook, float zLook, float xUp, float yUp, float zUp); /** Similar to gluPerspective * * /param fov vertical field of view * /param ratio aspect ratio of the viewport or window * /param nearp,farp distance to the near and far planes */ void perspective(float fov, float ratio, float nearp, float farp); /** Similar to glOrtho and gluOrtho2D (just leave the last two params blank). * * /param left,right coordinates for the left and right vertical clipping planes * /param bottom,top coordinates for the bottom and top horizontal clipping planes * /param nearp,farp distance to the near and far planes */ void ortho(float left, float right, float bottom, float top, float nearp=-1.0f, float farp=1.0f); /** Similar to glFrustum * * /param left,right coordinates for the left and right vertical clipping planes * /param bottom,top coordinates for the bottom and top horizontal clipping planes * /param nearp,farp distance to the near and far planes */ void frustum(float left, float right, float bottom, float top, float nearp, float farp); /** Similar to glGet * * /param aType either MODELVIEW or PROJECTION * /returns pointer to the matrix (float[16]) */ float *get(MatrixTypes aType); /** Updates the uniform buffer data * * /param aType either MODELVIEW or PROJECTION */ void matrixToBuffer(MatrixTypes aType); /** Updates the uniform variables * * /param aType either MODELVIEW or PROJECTION */ void matrixToUniform(MatrixTypes aType); /** Updates either the buffer or the uniform variables * based on which init* function was called last * * /param aType either MODELVIEW or PROJECTION */ void matrixToGL(MatrixTypes aType); protected: VSML(); /// Has an init* function been called? bool mInit; /// Using uniform blocks? bool mBlocks; ///brief Matrix stacks for modelview and projection matrices std::vector<float *> mMatrixStack[2]; /// The storage for the two matrices float mMatrix[2][16]; /// Storage for the uniform locations GLuint mUniformLoc[2]; /// Storage for the buffer index GLuint mBuffer; /// Storage for the offsets within the buffer GLuint mOffset[2]; /** Set a float* to an identity matrix * * /param size the order of the matrix */ void setIdentityMatrix( float *mat, int size=4); /** vector cross product * * res = a x b */ void crossProduct( float *a, float *b, float *res); /// normalize a vec3 void normalize(float *a); }; #endif 

vsml.cpp

/* -------------------------------------------------- Lighthouse3D VSML - Very Simple Matrix Library http://www.lighthouse3d.com/very-simple-libs ----------------------------------------------------*/ #include "vsml.h" #include <math.h> // This var keeps track of the single instance of VSML VSML* VSML::gInstance = 0; #define M_PI 3.14159265358979323846f static inline float DegToRad(float degrees) { return (float)(degrees * (M_PI / 180.0f)); }; // Singleton implementation // use this function to get the instance of VSML VSML* VSML::getInstance (void) { if (0 != gInstance) return gInstance; else gInstance = new VSML(); return gInstance; } // VSML constructor VSML::VSML(): mInit(false), mBlocks(false) { } // VSML destructor VSML::~VSML() { } // send the buffer data and offsets to VSML void VSML::initUniformBlock(GLuint buffer, GLuint modelviewOffset, GLuint projOffset) { mInit = true; mBlocks = true; mBuffer = buffer; mOffset[MODELVIEW] = modelviewOffset; mOffset[PROJECTION] = projOffset; } // send the uniform locations to VSML void VSML::initUniformLocs(GLuint modelviewLoc, GLuint projLoc) { mInit = true; mBlocks = false; mUniformLoc[MODELVIEW] = modelviewLoc; mUniformLoc[PROJECTION] = projLoc; } // glPushMatrix implementation void VSML::pushMatrix(MatrixTypes aType) { float *aux = (float *)malloc(sizeof(float) * 16); memcpy(aux, mMatrix[aType], sizeof(float) * 16); mMatrixStack[aType].push_back(aux); } // glPopMatrix implementation void VSML::popMatrix(MatrixTypes aType) { float *m = mMatrixStack[aType][mMatrixStack[aType].size()-1]; memcpy(mMatrix[aType], m, sizeof(float) * 16); mMatrixStack[aType].pop_back(); free(m); #ifdef VSML_ALWAYS_SEND_TO_OPENGL matrixToGL(aType); #endif } // glLoadIdentity implementation void VSML::loadIdentity(MatrixTypes aType) { setIdentityMatrix(mMatrix[aType]); #ifdef VSML_ALWAYS_SEND_TO_OPENGL matrixToGL(aType); #endif } // glMultMatrix implementation void VSML::multMatrix(MatrixTypes aType, float *aMatrix) { float *a, *b, res[16]; a = mMatrix[aType]; b = aMatrix; for (int i = 0; i < 4; ++i) { for (int j = 0; j < 4; ++j) { res[j*4 + i] = 0.0f; for (int k = 0; k < 4; ++k) { res[j*4 + i] += a[k*4 + i] * b[j*4 + k]; } } } memcpy(mMatrix[aType], res, 16 * sizeof(float)); #ifdef VSML_ALWAYS_SEND_TO_OPENGL matrixToGL(aType); #endif } // glLoadMatrix implementation void VSML::loadMatrix(MatrixTypes aType, float *aMatrix) { memcpy(mMatrix[aType], aMatrix, 16 * sizeof(float)); #ifdef VSML_ALWAYS_SEND_TO_OPENGL matrixToGL(aType); #endif } // glTranslate implementation with matrix selection void VSML::translate(MatrixTypes aType, float x, float y, float z) { float mat[16]; setIdentityMatrix(mat); mat[12] = x; mat[13] = y; mat[14] = z; multMatrix(aType,mat); #ifdef VSML_ALWAYS_SEND_TO_OPENGL matrixToGL(aType); #endif } // glTranslate on the MODELVIEW matrix void VSML::translate(float x, float y, float z) { translate(MODELVIEW, x,y,z); } // glScale implementation with matrix selection void VSML::scale(MatrixTypes aType, float x, float y, float z) { float mat[16]; setIdentityMatrix(mat,4); mat[0] = x; mat[5] = y; mat[10] = z; multMatrix(aType,mat); #ifdef VSML_ALWAYS_SEND_TO_OPENGL matrixToGL(aType); #endif } // glScale on the MODELVIEW matrix void VSML::scale(float x, float y, float z) { scale(MODELVIEW, x, y, z); } // glRotate implementation with matrix selection void VSML::rotate(MatrixTypes aType, float angle, float x, float y, float z) { float mat[16]; float radAngle = DegToRad(angle); float co = cos(radAngle); float si = sin(radAngle); float x2 = x*x; float y2 = y*y; float z2 = z*z; mat[0] = x2 + (y2 + z2) * co; mat[4] = x * y * (1 - co) - z * si; mat[8] = x * z * (1 - co) + y * si; mat[12]= 0.0f; mat[1] = x * y * (1 - co) + z * si; mat[5] = y2 + (x2 + z2) * co; mat[9] = y * z * (1 - co) - x * si; mat[13]= 0.0f; mat[2] = x * z * (1 - co) - y * si; mat[6] = y * z * (1 - co) + x * si; mat[10]= z2 + (x2 + y2) * co; mat[14]= 0.0f; mat[3] = 0.0f; mat[7] = 0.0f; mat[11]= 0.0f; mat[15]= 1.0f; multMatrix(aType,mat); #ifdef VSML_ALWAYS_SEND_TO_OPENGL matrixToGL(aType); #endif } // glRotate implementation in the MODELVIEW matrix void VSML::rotate(float angle, float x, float y, float z) { rotate(MODELVIEW,angle,x,y,z); } // gluLookAt implementation void VSML::lookAt(float xPos, float yPos, float zPos, float xLook, float yLook, float zLook, float xUp, float yUp, float zUp) { float dir[3], right[3], up[3]; up[0] = xUp; up[1] = yUp; up[2] = zUp; dir[0] = (xLook - xPos); dir[1] = (yLook - yPos); dir[2] = (zLook - zPos); normalize(dir); crossProduct(dir,up,right); normalize(right); crossProduct(right,dir,up); normalize(up); float m1[16],m2[16]; m1[0] = right[0]; m1[4] = right[1]; m1[8] = right[2]; m1[12] = 0.0f; m1[1] = up[0]; m1[5] = up[1]; m1[9] = up[2]; m1[13] = 0.0f; m1[2] = -dir[0]; m1[6] = -dir[1]; m1[10] = -dir[2]; m1[14] = 0.0f; m1[3] = 0.0f; m1[7] = 0.0f; m1[11] = 0.0f; m1[15] = 1.0f; setIdentityMatrix(m2,4); m2[12] = -xPos; m2[13] = -yPos; m2[14] = -zPos; multMatrix(MODELVIEW, m1); multMatrix(MODELVIEW, m2); #ifdef VSML_ALWAYS_SEND_TO_OPENGL matrixToGL(MODELVIEW); #endif } // gluPerspective implementation void VSML::perspective(float fov, float ratio, float nearp, float farp) { float projMatrix[16]; float f = 1.0f / tan (fov * (M_PI / 360.0f)); setIdentityMatrix(projMatrix,4); projMatrix[0] = f / ratio; projMatrix[1 * 4 + 1] = f; projMatrix[2 * 4 + 2] = (farp + nearp) / (nearp - farp); projMatrix[3 * 4 + 2] = (2.0f * farp * nearp) / (nearp - farp); projMatrix[2 * 4 + 3] = -1.0f; projMatrix[3 * 4 + 3] = 0.0f; multMatrix(PROJECTION, projMatrix); #ifdef VSML_ALWAYS_SEND_TO_OPENGL matrixToGL(PROJECTION); #endif } // glOrtho implementation void VSML::ortho(float left, float right, float bottom, float top, float nearp, float farp) { float m[16]; setIdentityMatrix(m,4); m[0 * 4 + 0] = 2 / (right - left); m[1 * 4 + 1] = 2 / (top - bottom); m[2 * 4 + 2] = -2 / (farp - nearp); m[3 * 4 + 0] = -(right + left) / (right - left); m[3 * 4 + 1] = -(top + bottom) / (top - bottom); m[3 * 4 + 2] = -(farp + nearp) / (farp - nearp); multMatrix(PROJECTION, m); #ifdef VSML_ALWAYS_SEND_TO_OPENGL matrixToGL(PROJECTION); #endif } // glFrustum implementation void VSML::frustum(float left, float right, float bottom, float top, float nearp, float farp) { float m[16]; setIdentityMatrix(m,4); m[0 * 4 + 0] = 2 * nearp / (right-left); m[1 * 4 + 1] = 2 * nearp / (top - bottom); m[2 * 4 + 0] = (right + left) / (right - left); m[2 * 4 + 1] = (top + bottom) / (top - bottom); m[2 * 4 + 2] = - (farp + nearp) / (farp - nearp); m[2 * 4 + 3] = -1.0f; m[3 * 4 + 2] = - 2 * farp * nearp / (farp-nearp); m[3 * 4 + 3] = 0.0f; multMatrix(PROJECTION, m); #ifdef VSML_ALWAYS_SEND_TO_OPENGL matrixToGL(PROJECTION); #endif } // returns a pointer to the requested matrix float * VSML::get(MatrixTypes aType) { return mMatrix[aType]; } /* ----------------------------------------------------- SEND MATRICES TO OPENGL ------------------------------------------------------*/ // to be used with uniform blocks void VSML::matrixToBuffer(MatrixTypes aType) { if (mInit && mBlocks) { glBindBuffer(GL_UNIFORM_BUFFER,mBuffer); glBufferSubData(GL_UNIFORM_BUFFER, mOffset[aType], 16 * sizeof(float), mMatrix[aType]); glBindBuffer(GL_UNIFORM_BUFFER,0); } } // to be used with uniform variables void VSML::matrixToUniform(MatrixTypes aType) { if (mInit && !mBlocks) { glUniformMatrix4fv(mUniformLoc[aType], 1, false, mMatrix[aType]); } } // universal void VSML::matrixToGL(MatrixTypes aType) { if (mInit) { if (mBlocks) { glBindBuffer(GL_UNIFORM_BUFFER,mBuffer); glBufferSubData(GL_UNIFORM_BUFFER, mOffset[aType], 16 * sizeof(float), mMatrix[aType]); glBindBuffer(GL_UNIFORM_BUFFER,0); } else { glUniformMatrix4fv(mUniformLoc[aType], 1, false, mMatrix[aType]); } } } // ----------------------------------------------------- // AUX functions // ----------------------------------------------------- // sets the square matrix mat to the identity matrix, // size refers to the number of rows (or columns) void VSML::setIdentityMatrix( float *mat, int size) { // fill matrix with 0s for (int i = 0; i < size * size; ++i) mat[i] = 0.0f; // fill diagonal with 1s for (int i = 0; i < size; ++i) mat[i + i * size] = 1.0f; } // res = a cross b; void VSML::crossProduct( float *a, float *b, float *res) { res[0] = a[1] * b[2] - b[1] * a[2]; res[1] = a[2] * b[0] - b[2] * a[0]; res[2] = a[0] * b[1] - b[0] * a[1]; } // Normalize a vec3 void VSML::normalize(float *a) { float mag = sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]); a[0] /= mag; a[1] /= mag; a[2] /= mag; }