CPPGPGPU Library - Reference (Doxygen)

---

Main Page | General Use | Reference | Examples Info | Get/Download CPPGPGPU | SF.net Page

---

OGLParts.h

Go to the documentation of this file.

#ifndef _OGL_PARTS_H
#define _OGL_PARTS_H

#ifdef WIN32
#include <windows.h>
#endif

#if defined(__APPLE__) || defined(MACOSX)
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif

#ifdef GLEXT
#include "GLEXTHandler.h"
#endif


#include <vector>
#include <string>
using namespace std;

enum TextureType
{
    TTGRAYSCALE = 0,
    TTRGB,
    TTRGBA,
    TTRGBA16,
    TTRGBA32,
    TTUNDEFINED
};


class Shader
{
public:
    Shader();
    ~Shader();


    bool LoadShader( const char * sShaderName );


    bool LoadShaderFrag( const char * sShaderCode );


    bool LoadShaderVert( const char * sShaderCode );


    bool LoadShaderGeom( const char * sShaderCode );


    bool LinkShaders();


    bool ActivateShader( vector< string > &vsAllSamplerLocs, vector< string > &vsUniformFloats, vector < float > & vfUniformFloats );

    bool ActivateShader( vector< string > &vsAllSamplerLocs);

    bool ActivateShader() { vector<string> st; return ActivateShader( st ); }

    bool ActivateShader( const string & s ) { vector<string> st; st.push_back( s ); return ActivateShader( st ); }

    bool DeactivateShader();

    void CheckForNewer( const char * sShaderName );

    GLhandleARB GetProgramID() { return iProgramID; }
private:
    /* This function takes on iOut as being where to put the last time the shader was modified.
       this value is system dependent and is necessiarly not linked to anything like seconds. */
    void GetTimeCodes( unsigned long * iOut, const char * sShaderName  );

    unsigned long   iTimeCode[3];

    GLhandleARB iProgramID;

    GLhandleARB geometryShader;

    GLhandleARB vertexShader;

    GLhandleARB fragmentShader;

    GLuint  vertexProgram;
    GLuint  fragmentProgram;
    bool bIsGLSLAsm;
};


class Texture
{
public:
    Texture() { iTexture = (GLuint)-1; }
    ~Texture();

    bool MakeDynamicTexture( int iWidth, int iHeight, TextureType tt );

    bool LoadTextureFile( const char * sFileName );

    bool LoadTexture( char * sRawData, int iWidth, int iHeight, TextureType tt );

    bool ActivateTexture( int iPlace = 0 );

    bool DeactivateTexture( int iPlace = 0 );

    unsigned int GetTexHandle() { return iTexture; }

    //already used the MakeDynamicTexture function.
    bool StripFromScreen( int x, int y, int width, int height );

    inline int GetWidth( ) { return mWidth; }

    inline int GetHeight( ) { return mHeight; }

    void ChangeFilter( bool bNearest );
private:
    GLuint iTexture;
    TextureType mtt;
    int mWidth, mHeight;
};


class RFBuffer
{
public:
    RFBuffer();
    ~RFBuffer();

    bool Setup( bool bUseDepthBuffer = true );

    bool ConfigureAndStart( int iWidth, int iHeight, int iTextures, Texture * TexturesToAttach, bool bClear = false );

    bool End( int iRegVPX, int iRegVPY );

    int GetWidth() { return mWidth; }

    int GetHeight() { return mHeight; }

    TextureType GetTT() { return mtt; }
private:
    bool m_bUseDepthBuffer;
    int mWidth, mHeight;
    TextureType mtt;

    GLuint iRenderbuffer;
    GLuint iOutputBuffer;
};

class VertexData;
class IndexData;


class VertexData
{
public:
    VertexData() { iVertexData = 0; }
    ~VertexData();

    void Init( float * Verts, int iNumVerts, int iStride = 3 );

    void UpdateData( float * Verts, int iNumVerts, int iStride = 3 );

    void StripFromFrameBuffer( int iWidth, int iHeight, TextureType tt );
private:
    int mStride;
    GLuint iVertexData;
    friend void DrawGeometry( VertexData ** vd, string * vsVertexNames, int iNumVertexDatas, IndexData * id, Shader * sShader );
    friend void DrawGeometrySolid( VertexData ** vd, string * vsVertexNames, 
        int iNumVertexDatas, IndexData * id, Shader * sShader, int facecount );
};


class IndexData
{
public:
    IndexData() { mIndexData = (GLuint*)-1; }
    ~IndexData();


    void Init( int * Indices, int iNumIndices );
private:
    GLuint mIndexCount;
    GLuint * mIndexData;
    friend void DrawGeometry( VertexData ** vd, string * vsVertexNames, 
        int iNumVertexDatas, IndexData * id, Shader * sShader );
    friend void DrawGeometrySolid( VertexData ** vd, string * vsVertexNames, 
        int iNumVertexDatas, IndexData * id, Shader * sShader, int facecount );
};

void DrawSquare();

void DrawGeometry( VertexData ** vd, string * vsVertexNames, int iNumVertexDatas, IndexData * id, Shader * sShader );


void DrawGeometrySolid( VertexData ** vd, string * vsVertexNames, int iNumVertexDatas, IndexData * id, Shader * sShader, int facecount );


void SetupForDataRun();
void PopFromDataRun();

void StripDataFromBuffer( int ix, int iy, int iwidth, int iheight, TextureType tt, char * buffer );


int OpenPPM( const char * sPPMName, unsigned char ** buffer, int * width, int * height );

#endif

/*
Copyright (c) 2005, 2006, 2007 Charles Lohr, David Chapman, Joshua Allen

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/

---

© 2005-2007 Charles Lohr, Joshua Allen, David Chapman, Andrew Lohr. All material including documentation under the MIT/X11 license.