include/cinder/gl/gl.h

Go to the documentation of this file.

/*
 Copyright (c) 2010, The Barbarian Group
 All rights reserved.

 Redistribution and use in source and binary forms, with or without modification, are permitted provided that
 the following conditions are met:

    * Redistributions of source code must retain the above copyright notice, this list of conditions and
    the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
    the following disclaimer in the documentation and/or other materials provided with the distribution.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
 WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
*/

#pragma once

#include "cinder/Cinder.h"

#if defined( CINDER_MAC )
    #include <OpenGL/gl.h>
    #include <OpenGL/glext.h>
#elif defined( CINDER_MSW )
    #include "cinder/gl/GLee.h"
#else
    #define CINDER_GLES
    #define CINDER_GLES1
#endif

#include "cinder/Exception.h"
#include "cinder/Quaternion.h"
#include "cinder/Matrix.h"
#include "cinder/Vector.h"
#include "cinder/Color.h"
#include "cinder/Rect.h"
#include "cinder/Font.h"
#include "cinder/PolyLine.h"
#include "cinder/AxisAlignedBox.h"

#if defined( CINDER_MSW )
    #include <windows.h>
    #undef min
    #undef max
    #include <gl/gl.h>
#elif defined( CINDER_COCOA_TOUCH )
    #include <OpenGLES/ES1/gl.h>
    #include <OpenGLES/ES1/glext.h>
#elif defined( CINDER_MAC )
    #include <OpenGL/gl.h>
#endif

// forward declarations
namespace cinder {
    class Camera; class TriMesh2d; class TriMesh; class Sphere;
    namespace gl {
         class VboMesh; class Texture;
         typedef std::shared_ptr<Texture>   TextureRef;
         typedef std::shared_ptr<VboMesh>   VboMeshRef;
    }
} // namespace cinder

namespace cinder { namespace gl {

bool isExtensionAvailable( const std::string &extName );

void clear( const ColorA &color = ColorA::black(), bool clearDepthBuffer = true );

void enableVerticalSync( bool enable = true );
inline void disableVerticalSync() { enableVerticalSync( false ); }
bool isVerticalSyncEnabled();

void setMatrices( const Camera &cam );
void setModelView( const Camera &cam );
void setProjection( const Camera &cam );
void pushModelView();
void popModelView();
void pushModelView( const Camera &cam );
void pushProjection( const Camera &cam );
void pushMatrices();
void popMatrices();
void multModelView( const Matrix44f &mtx );
void multProjection( const Matrix44f &mtx );
Matrix44f getModelView();
Matrix44f getProjection();

void setMatricesWindowPersp( int screenWidth, int screenHeight, float fovDegrees = 60.0f, float nearPlane = 1.0f, float farPlane = 1000.0f, bool originUpperLeft = true );
inline void setMatricesWindowPersp( const Vec2i &screenSize, float fovDegrees = 60.0f, float nearPlane = 1.0f, float farPlane = 1000.0f, bool originUpperLeft = true )
    { setMatricesWindowPersp( screenSize.x, screenSize.y, fovDegrees, nearPlane, farPlane ); }
void setMatricesWindow( int screenWidth, int screenHeight, bool originUpperLeft = true );
inline void setMatricesWindow( const Vec2i &screenSize, bool originUpperLeft = true ) { setMatricesWindow( screenSize.x, screenSize.y, originUpperLeft ); }

Area getViewport();
void setViewport( const Area &area );

void translate( const Vec2f &pos );
inline void translate( float x, float y ) { translate( Vec2f( x, y ) ); }
void translate( const Vec3f &pos );
inline void translate( float x, float y, float z ) { translate( Vec3f( x, y, z ) ); }

void scale( const Vec3f &scl );
inline void scale( const Vec2f &scl ) { scale( Vec3f( scl.x, scl.y, 1 ) ); }
inline void scale( float x, float y ) { scale( Vec3f( x, y, 1 ) ); }
inline void scale( float x, float y, float z ) { scale( Vec3f( x, y, z ) ); }

void rotate( const Vec3f &xyz );
void rotate( const Quatf &quat );
inline void rotate( float degrees ) { rotate( Vec3f( 0, 0, degrees ) ); }

#if ! defined( CINDER_GLES )

inline void begin( GLenum mode ) { glBegin( mode ); }
inline void end() { glEnd(); }
inline void vertex( const Vec2f &v ) { glVertex2fv( &v.x ); }
inline void vertex( float x, float y ) { glVertex2f( x, y ); }
inline void vertex( const Vec3f &v ) { glVertex3fv( &v.x ); }
inline void vertex( float x, float y, float z ) { glVertex3f( x, y, z ); }
inline void texCoord( float x, float y ) { glTexCoord2f( x, y ); }
inline void texCoord( const Vec2f &v ) { glTexCoord2f( v.x, v.y ); }
inline void texCoord( float x, float y, float z ) { glTexCoord3f( x, y, z ); }
inline void texCoord( const Vec3f &v ) { glTexCoord3f( v.x, v.y, v.z ); }
#endif // ! defined( CINDER_GLES )

inline void color( float r, float g, float b ) { glColor4f( r, g, b, 1.0f ); }
inline void color( float r, float g, float b, float a ) { glColor4f( r, g, b, a ); }
inline void color( const Color8u &c ) { glColor4ub( c.r, c.g, c.b, 255 ); }
inline void color( const ColorA8u &c ) { glColor4ub( c.r, c.g, c.b, c.a ); }
inline void color( const Color &c ) { glColor4f( c.r, c.g, c.b, 1.0f ); }
inline void color( const ColorA &c ) { glColor4f( c.r, c.g, c.b, c.a ); }

inline void enable( GLenum state ) { glEnable( state ); }
inline void disable( GLenum state ) { glDisable( state ); }

void enableAlphaBlending( bool premultiplied = false );
void disableAlphaBlending();
void enableAdditiveBlending();

void enableAlphaTest( float value = 0.5f, int func = GL_GREATER );
void disableAlphaTest();

#if ! defined( CINDER_GLES )

void enableWireframe();
void disableWireframe();
#endif // ! defined( CINDER_GLES )

void disableDepthRead();
void disableDepthWrite();
void enableDepthRead( bool enable = true );
void enableDepthWrite( bool enable = true );

inline void lineWidth( float width ) { glLineWidth( width ); }

void drawLine( const Vec2f &start, const Vec2f &end );
void drawLine( const Vec3f &start, const Vec3f &end );
void drawCube( const Vec3f &center, const Vec3f &size );
void drawColorCube( const Vec3f &center, const Vec3f &size );
void drawStrokedCube( const Vec3f &center, const Vec3f &size );
inline void drawStrokedCube( const AxisAlignedBox3f &aab ) { drawStrokedCube( aab.getCenter(), aab.getSize() ); }
void drawSphere( const Vec3f &center, float radius, int segments = 12 );
void draw( const class Sphere &sphere, int segments = 12 );
void drawSolidCircle( const Vec2f &center, float radius, int numSegments = 0 );
void drawStrokedCircle( const Vec2f &center, float radius, int numSegments = 0 );
void drawSolidEllipse( const Vec2f &center, float radiusX, float radiusY, int numSegments = 0 );
void drawStrokedEllipse( const Vec2f &center, float radiusX, float radiusY, int numSegments = 0 );
void drawSolidRect( const Rectf &rect, bool textureRectangle = false );
void drawStrokedRect( const Rectf &rect );
void drawSolidRoundedRect( const Rectf &r, float cornerRadius, int numSegmentsPerCorner = 0 );
void drawStrokedRoundedRect( const Rectf &r, float cornerRadius, int numSegmentsPerCorner = 0 );
void drawSolidTriangle( const Vec2f &pt1, const Vec2f &pt2, const Vec2f &pt3 );
void drawSolidTriangle( const Vec2f pts[3] );
void drawSolidTriangle( const Vec2f &pt1, const Vec2f &pt2, const Vec2f &pt3, const Vec2f &texPt1, const Vec2f &texPt2, const Vec2f &texPt3 );
void drawSolidTriangle( const Vec2f pts[3], const Vec2f texCoord[3] );
void drawStrokedTriangle( const Vec2f &pt1, const Vec2f &pt2, const Vec2f &pt3 );   
void drawStrokedTriangle( const Vec2f pts[3] );
void drawCoordinateFrame( float axisLength = 1.0f, float headLength = 0.2f, float headRadius = 0.05f );
void drawVector( const Vec3f &start, const Vec3f &end, float headLength = 0.2f, float headRadius = 0.05f );
void drawFrustum( const Camera &cam );
void drawTorus( float outterRadius, float innerRadius, int longitudeSegments = 12, int latitudeSegments = 12 );
void drawCylinder( float baseRadius, float topRadius, float height, int slices = 12, int stacks = 1 );
void draw( const class PolyLine<Vec2f> &polyLine );
void draw( const class PolyLine<Vec3f> &polyLine );
void draw( const class Path2d &path2d, float approximationScale = 1.0f );
void draw( const class Shape2d &shape2d, float approximationScale = 1.0f );

void drawSolid( const class Path2d &path2d, float approximationScale = 1.0f );
void drawSolid( const class Shape2d &shape2d, float approximationScale = 1.0f );
void drawSolid( const PolyLine2f &polyLine );

void draw( const TriMesh2d &mesh );
void drawRange( const TriMesh2d &mesh, size_t startTriangle, size_t triangleCount );
void draw( const TriMesh &mesh );
void drawRange( const TriMesh &mesh, size_t startTriangle, size_t triangleCount );

#if ! defined ( CINDER_GLES )

void draw( const VboMesh &vbo );
inline void draw( const VboMeshRef &vbo ) { draw( *vbo ); }
void drawRange( const VboMesh &vbo, size_t startIndex, size_t indexCount, int vertexStart = -1, int vertexEnd = -1 );
inline void drawRange( const VboMeshRef &vbo, size_t startIndex, size_t indexCount, int vertexStart = -1, int vertexEnd = -1 ) { drawRange( *vbo, startIndex, indexCount, vertexStart, vertexEnd ); }
void drawArrays( const VboMesh &vbo, GLint first, GLsizei count );
inline void drawArrays( const VboMeshRef &vbo, GLint first, GLsizei count ) { drawArrays( *vbo, first, count ); }
#endif

void drawBillboard( const Vec3f &pos, const Vec2f &scale, float rotationDegrees, const Vec3f &bbRight, const Vec3f &bbUp );
void draw( const Texture &texture );
inline void draw( const TextureRef &texture ) { draw( *texture ); }
void draw( const Texture &texture, const Vec2f &pos );
inline void draw( const TextureRef &texture, const Vec2f &pos ) { draw( *texture, pos ); }
void draw( const Texture &texture, const Rectf &rect );
inline void draw( const TextureRef &texture, const Rectf &rect ) { draw( *texture, rect ); }
void draw( const Texture &texture, const Area &srcArea, const Rectf &destRect );
inline void draw( const TextureRef &texture, const Area &srcArea, const Rectf &destRect ) { draw( *texture, srcArea, destRect ); }

void drawString( const std::string &str, const Vec2f &pos, const ColorA &color = ColorA( 1, 1, 1, 1 ), Font font = Font() );
void drawStringCentered( const std::string &str, const Vec2f &pos, const ColorA &color = ColorA( 1, 1, 1, 1 ), Font font = Font() );
void drawStringRight( const std::string &str, const Vec2f &pos, const ColorA &color = ColorA( 1, 1, 1, 1 ), Font font = Font() );


struct SaveTextureBindState {
    SaveTextureBindState( GLint target );
    ~SaveTextureBindState();
  private:
    GLint   mTarget;
    GLint   mOldID;
};

struct BoolState {
    BoolState( GLint target );
    ~BoolState();
  private:
    GLint       mTarget;
    GLboolean   mOldValue;
};

struct ClientBoolState {
    ClientBoolState( GLint target );
    ~ClientBoolState();
  private:
    GLint       mTarget;
    GLboolean   mOldValue;
};

struct SaveColorState {
    SaveColorState();
    ~SaveColorState();
  private:
    GLfloat     mOldValues[4];
};

struct SaveFramebufferBinding {
    SaveFramebufferBinding();
    ~SaveFramebufferBinding();
  private:
    GLint       mOldValue;
};

#if defined( CINDER_MSW )

void initializeGlee();
#endif

class Exception : public cinder::Exception {
};

class ExceptionUnknownTarget : public Exception {
};

} } // namespace cinder::gl 


#if ! defined( CINDER_GLES )
inline void glVertex2f( const cinder::Vec2f &v ) { glVertex2f( v.x, v.y ); }
inline void glVertex3f( const cinder::Vec3f &v ) { glVertex3f( v.x, v.y, v.z ); }
inline void glVertex4f( const cinder::Vec4f &v ) { glVertex4f( v.x, v.y, v.z, v.w ); }
inline void glNormal3f( const cinder::Vec3f &v ) { glNormal3f( v.x, v.y, v.z ); }
inline void glColor3f( const cinder::Color &c ) { glColor3f( c.r, c.g, c.b ); }
inline void glColor4f( const cinder::ColorA &c ) { glColor4f( c.r, c.g, c.b, c.a ); }
inline void glTexCoord2f( const cinder::Vec2f &v ) { glTexCoord2f( v.x, v.y ); }
inline void glTexCoord3f( const cinder::Vec3f &v ) { glTexCoord3f( v.x, v.y, v.z ); }
inline void glTexCoord4f( const cinder::Vec4f &v ) { glTexCoord4f( v.x, v.y, v.z, v.w ); }
// This style of definition conflicts with GLee
//inline void glMultiTexCoord2f( GLenum target, const cinder::Vec2f &v ) { glMultiTexCoord2f( target, v.x, v.y ); }
//inline void glMultiTexCoord3f( GLenum target, const cinder::Vec3f &v ) { glMultiTexCoord3f( target, v.x, v.y, v.z ); }
//inline void glMultiTexCoord4f( GLenum target, const cinder::Vec4f &v ) { glMultiTexCoord4f( target, v.x, v.y, v.z, v.w ); }
#endif // ! defined( CINDER_GLES )
inline void glTranslatef( const cinder::Vec3f &v ) { glTranslatef( v.x, v.y, v.z ); }
inline void glScalef( const cinder::Vec3f &v ) { glScalef( v.x, v.y, v.z ); }
inline void glRotatef( float angle, const cinder::Vec3f &v ) { glRotatef( angle, v.x, v.y, v.z ); }
inline void glRotatef( const cinder::Quatf &quat ) { cinder::Vec3f axis; float angle; quat.getAxisAngle( &axis, &angle ); glRotatef( cinder::toDegrees( angle ), axis.x, axis.y, axis.z ); }
inline void glMultMatrixf( const cinder::Matrix44f &m ) { glMultMatrixf( m.m ); }
inline void glLoadMatrixf( const cinder::Matrix44f &m ) { glLoadMatrixf( m.m ); }