Cinder

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_COCOA_TOUCH )
    #include "cinder/gl/GLee.h"
#else
    #define CINDER_GLES
    #define CINDER_GLES1
#endif

#include "cinder/Quaternion.h"
#include "cinder/Matrix.h"
#include "cinder/Vector.h"
#include "cinder/Color.h"
#include "cinder/Rect.h"
#include "cinder/Font.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 TriMesh; class Sphere;
    namespace gl {
         class VboMesh; class Texture;
    }
} // namespace cinder

namespace cinder { namespace gl {

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

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 );
inline void setMatricesWindowPersp( const Vec2i &screenSize, float fovDegrees = 60.0f, float nearPlane = 1.0f, float farPlane = 1000.0f )
    { 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 );
void translate( const Vec3f &pos );
void scale( const Vec3f &scale );
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 vertex( const Vec2f &v ) { glVertex2fv( &v.x ); }
inline void vertex( const Vec3f &v ) { glVertex3fv( &v.x ); }
inline void color( const Color &c ) { glColor3f( c.r, c.g, c.b ); }
inline void color( const ColorA &c ) { glColor4f( c.r, c.g, c.b, c.a ); }
#endif // ! defined( CINDER_GLES )

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 );

void drawCube( const Vec3f &center, const Vec3f &size );
void drawColorCube( const Vec3f &center, const Vec3f &size );
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 drawSolidRect( const Rectf &rect, bool textureRectangle = false );
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 );

#if ! defined( CINDER_GLES )

void draw( const TriMesh &mesh );
void drawRange( const TriMesh &mesh, size_t startTriangle, size_t triangleCount );
void draw( const VboMesh &vbo );
void drawRange( const VboMesh &vbo, size_t startIndex, size_t indexCount, int vertexStart = -1, int vertexEnd = -1 );
void drawArrays( const VboMesh &vbo, GLint first, GLsizei count );
#endif // ! defined( CINDER_GLES )

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

#if ! defined( CINDER_COCOA_TOUCH )

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() );

#endif // ! defined( CINDER_COCOA_TOUCH )


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

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

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

void initializeGlee();

} } // 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 ); }