glfx.h

/*-------------------------------------------------------------------------
This source code is part of GLfx library (OpenGL effect library)
For more information and updates see http://glfx.sourceforge.net/
Copyright (C) 2005-6 Tomek Rozen <trozen at users sourceforge net>

This library is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License,
or (at your option) any later version.

This library 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 Lesser General Public License
for more details.
-------------------------------------------------------------------------*/

#ifndef __GLFX_H__
#define __GLFX_H__

#ifdef _WIN32
#   ifdef GLFX_LIBRARY
#       define GLFX_EXPORT __declspec(dllexport)
#   else
#       define GLFX_EXPORT __declspec(dllimport)
#   endif
#else
#   define GLFX_EXPORT
#endif

#ifndef GLFX_LIBRARY
#   ifdef _MSC_VER
#       ifdef _DEBUG
#           pragma comment(lib, "glfx-dbg")
#       else
#           pragma comment(lib, "glfx")
#       endif
#   endif
#endif 

namespace GLFX {

// forward declarations
class EffectManager;

struct IObject
{
    virtual unsigned long AddRef() = 0;
    virtual unsigned long Release() = 0;

};

struct GLFX_EXPORT VertexComponent
{
    GLenum array;
    unsigned long index;
    unsigned long count;
    GLenum type;

    VertexComponent() {}
    VertexComponent(int arr, int id, int num, int tp) : array(arr), index(id), count(num), type(tp) {}
    static unsigned long GetByteSize(int type, int count);
    static unsigned long GetVertexSize(const VertexComponent* desc);
    static void EnableClientState(const VertexComponent* desc);
    static void DisableClientState(const VertexComponent* desc);
    static void SetPointers(const VertexComponent* desc, int stride, void* ptr);
    static const VertexComponent* FindComponentByArray(const VertexComponent* desc, GLenum array, int index);
    static unsigned long ComponentOffset(const VertexComponent* desc, const VertexComponent* component);

};

template<int ArrayT, int IndexT, int CountT, int TypeT>
struct VertexComponentGen : public VertexComponent
{
    VertexComponentGen() : VertexComponent(ArrayT, IndexT, CountT, TypeT) {}
    enum { IS_VALID = 1 };
};

struct VertexComponentInvalidGen : public VertexComponent
{
    VertexComponentInvalidGen() : VertexComponent(0, 0, 0, 0) {}
    enum { IS_VALID = 0 };
};

typedef VertexComponentGen<GL_VERTEX_ARRAY, 0, 2, GL_FLOAT> VC_VERTEX_2F;
typedef VertexComponentGen<GL_VERTEX_ARRAY, 0, 3, GL_FLOAT> VC_VERTEX_3F;
typedef VertexComponentGen<GL_VERTEX_ARRAY, 0, 4, GL_FLOAT> VC_VERTEX_4F;
typedef VertexComponentGen<GL_NORMAL_ARRAY, 0, 3, GL_FLOAT> VC_NORMAL_3F;
typedef VertexComponentGen<GL_COLOR_ARRAY, 0, 3, GL_FLOAT> VC_COLOR_3F;
typedef VertexComponentGen<GL_COLOR_ARRAY, 0, 4, GL_FLOAT> VC_COLOR_4F;
typedef VertexComponentGen<GL_COLOR_ARRAY, 0, 3, GL_UNSIGNED_BYTE> VC_COLOR_3UB;
typedef VertexComponentGen<GL_COLOR_ARRAY, 0, 4, GL_UNSIGNED_BYTE> VC_COLOR_4UB;
typedef VertexComponentGen<GL_SECONDARY_COLOR_ARRAY, 0, 3, GL_FLOAT> VC_SECONDARY_COLOR_3F;
typedef VertexComponentGen<GL_SECONDARY_COLOR_ARRAY, 0, 4, GL_FLOAT> VC_SECONDARY_COLOR_4F;
typedef VertexComponentGen<GL_SECONDARY_COLOR_ARRAY, 0, 3, GL_UNSIGNED_BYTE> VC_SECONDARY_COLOR_3UB;
typedef VertexComponentGen<GL_SECONDARY_COLOR_ARRAY, 0, 4, GL_UNSIGNED_BYTE> VC_SECONDARY_COLOR_4UB;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 0, 1, GL_FLOAT> VC_TEXTURE0_1F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 0, 2, GL_FLOAT> VC_TEXTURE0_2F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 0, 3, GL_FLOAT> VC_TEXTURE0_3F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 0, 4, GL_FLOAT> VC_TEXTURE0_4F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 1, 1, GL_FLOAT> VC_TEXTURE1_1F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 1, 2, GL_FLOAT> VC_TEXTURE1_2F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 1, 3, GL_FLOAT> VC_TEXTURE1_3F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 1, 4, GL_FLOAT> VC_TEXTURE1_4F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 2, 1, GL_FLOAT> VC_TEXTURE2_1F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 2, 2, GL_FLOAT> VC_TEXTURE2_2F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 2, 3, GL_FLOAT> VC_TEXTURE2_3F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 2, 4, GL_FLOAT> VC_TEXTURE2_4F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 3, 1, GL_FLOAT> VC_TEXTURE3_1F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 3, 2, GL_FLOAT> VC_TEXTURE3_2F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 3, 3, GL_FLOAT> VC_TEXTURE3_3F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 3, 4, GL_FLOAT> VC_TEXTURE3_4F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 4, 1, GL_FLOAT> VC_TEXTURE4_1F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 4, 2, GL_FLOAT> VC_TEXTURE4_2F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 4, 3, GL_FLOAT> VC_TEXTURE4_3F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 4, 4, GL_FLOAT> VC_TEXTURE4_4F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 5, 1, GL_FLOAT> VC_TEXTURE5_1F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 5, 2, GL_FLOAT> VC_TEXTURE5_2F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 5, 3, GL_FLOAT> VC_TEXTURE5_3F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 5, 4, GL_FLOAT> VC_TEXTURE5_4F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 6, 1, GL_FLOAT> VC_TEXTURE6_1F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 6, 2, GL_FLOAT> VC_TEXTURE6_2F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 6, 3, GL_FLOAT> VC_TEXTURE6_3F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 6, 4, GL_FLOAT> VC_TEXTURE6_4F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 7, 1, GL_FLOAT> VC_TEXTURE7_1F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 7, 2, GL_FLOAT> VC_TEXTURE7_2F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 7, 3, GL_FLOAT> VC_TEXTURE7_3F;
typedef VertexComponentGen<GL_TEXTURE_COORD_ARRAY, 7, 4, GL_FLOAT> VC_TEXTURE7_4F;
typedef VertexComponentInvalidGen VC_END;
template<int IndexT> struct VC_ATTRIBUTE_1F : public VertexComponentGen<GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB, IndexT, 1, GL_FLOAT> {};
template<int IndexT> struct VC_ATTRIBUTE_2F : public VertexComponentGen<GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB, IndexT, 2, GL_FLOAT> {};
template<int IndexT> struct VC_ATTRIBUTE_3F : public VertexComponentGen<GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB, IndexT, 3, GL_FLOAT> {};
template<int IndexT> struct VC_ATTRIBUTE_4F : public VertexComponentGen<GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB, IndexT, 4, GL_FLOAT> {};
template<int IndexT> struct VC_ATTRIBUTE_1UB : public VertexComponentGen<GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB, IndexT, 1, GL_UNSIGNED_BYTE> {};
template<int IndexT> struct VC_ATTRIBUTE_2UB : public VertexComponentGen<GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB, IndexT, 2, GL_UNSIGNED_BYTE> {};
template<int IndexT> struct VC_ATTRIBUTE_3UB : public VertexComponentGen<GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB, IndexT, 3, GL_UNSIGNED_BYTE> {};
template<int IndexT> struct VC_ATTRIBUTE_4UB : public VertexComponentGen<GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB, IndexT, 4, GL_UNSIGNED_BYTE> {};

template<class Comp0, class Comp1 = VC_END, class Comp2 = VC_END, class Comp3 = VC_END, class Comp4 = VC_END, class Comp5 = VC_END, class Comp6 = VC_END, class Comp7 = VC_END, class Comp8 = VC_END, class Comp9 = VC_END, class Comp10 = VC_END, class Comp11 = VC_END>
struct VertexFormat
{
private:
    typedef VertexFormat<Comp0, Comp1, Comp2, Comp3, Comp4, Comp5, Comp6, Comp7, Comp8, Comp9, Comp10, Comp11> MyType;
public:

    Comp0 c0;
    Comp1 c1;
    Comp2 c2;
    Comp3 c3;
    Comp4 c4;
    Comp5 c5;
    Comp6 c6;
    Comp7 c7;
    Comp8 c8;
    Comp9 c9;
    Comp10 c10;
    Comp11 c11;
    VC_END end;

    static VertexComponent* Desc() {
        static const MyType def;
        return (VertexComponent*)&(def.c0);
    }

    enum { Size = Comp0::IS_VALID + Comp1::IS_VALID + Comp2::IS_VALID + Comp3::IS_VALID + Comp4::IS_VALID + 
            Comp5::IS_VALID + Comp6::IS_VALID + Comp7::IS_VALID + Comp8::IS_VALID + Comp9::IS_VALID + 
            Comp10::IS_VALID + Comp11::IS_VALID };
};

struct ITechnique
{

    virtual bool Begin() = 0;
    virtual bool End() = 0;
    virtual bool BeginPass(int num) = 0;
    virtual bool EndPass() = 0;
    virtual long GetPassCount() = 0;
    virtual const char* GetName() = 0;

};

struct IEffect : public IObject
{

    virtual long GetTechniqueCount() = 0;
    virtual ITechnique* GetTechnique(long num) = 0;
    virtual ITechnique* FindTechnique(const char* name) = 0;
    virtual long GetParameterId(const char* name) = 0;
    virtual void SetParameterFloat(long id, GLsizei components, GLsizei count, float* value) = 0;
    virtual void SetParameterTexture(long id, GLuint texture) = 0;
    virtual void ReloadTextures() = 0;

};

struct IFramebuffer : public IObject
{

    virtual bool BeginCapture() = 0;
    virtual void EndCapture() = 0;
    virtual bool AttachTexture(long attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) = 0;
    virtual bool IsValid() = 0;
    virtual void SetDrawBuffer(long attachment) = 0;

};

struct IFont : public IObject
{

    enum {
        SINGLE_LINE,
        MULTI_LINE,
        CHAR_WRAP,
        WORD_WRAP
    };

    virtual GLuint GetTexture() = 0;
    virtual void DrawChar(float x, float y, float z, int c, float* bounds) = 0;
    virtual void DrawString(float x, float y, float z, const char* strBegin,
        const char* strEnd, unsigned long mode, float lineWidth, float* bounds) = 0;
    virtual unsigned long GetGlyphHeight() = 0;
    virtual unsigned long GetGlyphBaseLine() = 0;
    virtual float ComputeStringWidth(const char* strBegin, const char* strEnd,
        unsigned long mode, float lineWidth) = 0;
    virtual unsigned long ComputeStringLineCount(const char* strBegin, const char* strEnd,
        unsigned long mode, float lineWidth) = 0;
    virtual void SetTabSize(unsigned long horizontal) = 0;
    
};

struct IVertexBuffer : public IObject
{

    virtual unsigned long GetSize() = 0;

    virtual const VertexComponent* GetFormat() = 0;

    virtual void* Lock(GLenum access) = 0;

    virtual void Unlock() = 0;

    virtual void Bind() = 0;

    virtual void Unbind() = 0;

};

struct IIndexBuffer : public IObject
{

    virtual unsigned long GetSize() = 0;

    virtual GLenum GetType() = 0;

    virtual void* Lock(GLenum access) = 0;

    virtual void Unlock() = 0;

    virtual void Bind() = 0;

    virtual void Unbind() = 0;

    virtual void DrawElements(GLenum mode, GLsizei first, GLsizei count) = 0;

};

struct IMesh : public IObject
{
    virtual IVertexBuffer* GetVertexBuffer() = 0;

    virtual IIndexBuffer* GetIndexBuffer() = 0;

    virtual unsigned long GetPrimitiveGroupCount() = 0;

    virtual unsigned long GetPrimitiveGroupStartIndex(unsigned long group) = 0;

    virtual unsigned long GetPrimitiveGroupElementCount(unsigned long group) = 0;

    virtual GLenum GetPrimitiveType() = 0;

    virtual void SetPrimitiveGroup(unsigned long group, unsigned long start, unsigned long count) = 0;

    virtual void DrawPrimitiveGroup(unsigned long group) = 0;

};

struct ISceneBuilder
{

    enum {
        NODE_SIMPLE=0,
        NODE_STATIC_MESH,
        NODE_LIGHT,
        NODE_CAMERA,
    };

    enum {
        VERT_POSITION=0,
        VERT_NORMAL,
        VERT_COLOR,
        VERT_TEXTURE0,
        VERT_TEXTURE1,
        VERT_TEXTURE2,
        VERT_TEXTURE3,
        VERT_TEXTURE4,
        VERT_TEXTURE5,
        VERT_TEXTURE6,
        VERT_TEXTURE7
    };

    enum {
        ANIM_POSITION=0,
        ANIM_ROTATION,
        ANIM_SCALE,
    };

    // scene methods

    virtual bool Initialize(EffectManager* fxMgr) = 0;

    virtual bool Finalize() = 0;

    virtual int CreateNode(const char* nodeName, int type) = 0;

    virtual int CreateMaterial(const char* materialName) = 0;

    virtual int CreateAnimation(const char* animName) = 0;

    // node methods

    virtual void SetNodeParentByName(int nodeId, const char* parentName) = 0;

    virtual void SetNodeTM(int nodeId, const float* tm) = 0;

    // static mesh methods

    virtual void SetMeshParameters(int nodeId, GLenum primitiveType, unsigned long vertexCount, unsigned long indexCount, unsigned long primitiveGroupCount) = 0;

    virtual bool SetMeshVertexData(int nodeId, unsigned long type, unsigned long dim, const float* data) = 0;

    virtual bool SetMeshFaceIndices(int nodeId, const unsigned long* data) = 0;

    virtual void SetMeshPrimitiveGroup(int nodeId, unsigned long groupId, unsigned long start, unsigned long count) = 0;

    virtual void SetMeshMaterial(int nodeId, unsigned long groupId, int materialId) = 0;

    // light node methods

    virtual void SetLightColor(int nodeId, const float* color) = 0;

    virtual void SetLightAttenuation(int nodeId, float attnStart, float attnEnd) = 0;

    // camera node methods

    virtual void SetCameraFieldOfViewX(int nodeId, float fovx) = 0;

    // material methods

    virtual void SetMaterialAmbientColor(int materialId, const float* color) = 0;

    virtual void SetMaterialDiffuseColor(int materialId, const float* color) = 0;

    virtual void SetMaterialSpecularColor(int materialId, const float* color) = 0;

    virtual void SetMaterialSpecularLevel(int materialId, float level) = 0;

    virtual void SetMaterialTransparency(int materialId, float transparency) = 0;

    virtual void SetMaterialDiffuseMap(int materialId, const char* name) = 0;

    virtual void SetMaterialGlossMap(int materialId, const char* name) = 0;

    virtual void SetMaterialGlowMap(int materialId, const char* name) = 0;

    virtual void SetMaterialBumpMap(int materialId, const char* name) = 0;

    // animation methods

    virtual void SetAnimationParameters(int animId, float startTime, float frequency, unsigned long frameCount) = 0;

    virtual void SetAnimationNodeKeyframes(int animId, int nodeId, unsigned long type, float* data) = 0;

};

struct ISceneLoader : public IObject
{

    virtual bool Initialize(EffectManager* fxMgr) = 0;

    virtual bool IsFileSupported(const char* fileName) = 0;

    virtual bool LoadScene(const char* fileName, ISceneBuilder* sceneBuilder) = 0;

};

// internal implementation
namespace Impl {

class EffectPool;
class FontPool;
class Utility;
class TextureManager;
class SceneLoaderManager;

}

class GLFX_EXPORT EffectManager
{
public:

    enum {
        POOL_SOFTWARE=0,
        POOL_HARDWARE_VBO=1,
        POOL_HARDWARE=POOL_HARDWARE_VBO
    };

    enum {
        LOG_DEBUG=1000,
        LOG_INFO=1200,
        LOG_NOTICE=1500,
        LOG_WARN=1700,
        LOG_ERROR=2000
    };

    EffectManager();
    virtual ~EffectManager();

    bool Initialize(bool currentStateDefault);
    void Finalize();
    IEffect* LoadFX(const char* name);
    Impl::EffectPool* GetEffectPool();
    void MessageFormat(long level, const char* fmt, ...);
    IFramebuffer* CreateFramebuffer(long width, long height, long depthBits, long stencilBits);
#ifdef _DEBUG
    void CheckGLErrors(const char* location = 0);
#else
    void CheckGLErrors(const char* location = 0) {}
#endif
    Impl::FontPool* GetFontPool();
    IFont* LoadFont(const char* name, unsigned long fontSize);
    void UpdateFPS();
    float GetFPS();
    GLuint LoadTexture(GLenum target, const char* name);
    void DeleteTexture(GLuint texture);
    void ReloadTextures();
    void IncrTexRefCount(GLuint texture);
    IVertexBuffer* CreateVertexBuffer(VertexComponent* format, unsigned long size, GLenum usage, unsigned long pool);
    IIndexBuffer* CreateIndexBuffer(GLenum type, unsigned long size, GLenum usage, unsigned long pool);
    IMesh* CreateMesh(unsigned long numVert, unsigned long numIndex, unsigned long numGroup,
        GLenum primitiveType, VertexComponent* format, GLenum indexType, GLenum vertexUsage,
        GLenum indexUsage, unsigned long vertexPool, unsigned long indexPool);
    bool RegisterSceneLoader(ISceneLoader* sceneLoader);
    bool LoadScene(const char* fileName, ISceneBuilder* sceneBuilder);
    void LogGLInfo();

    virtual bool FillTextureData(GLenum target, const char* name);
    virtual const char* MakeAbsolutePath(const char* file, const char* referer);
    virtual void Message(long level, const char* message);
    virtual void* OpenFile(const char* name, bool writeFile);
    virtual long ReadFile(void* file, void* buffer, long bytes);
    virtual void CloseFile(void* file);
    virtual bool Eof(void* file);
    virtual long SeekFile(void* file, long offset, long origin);
    virtual long TellFile(void* file);

private:

    Impl::EffectPool* _effect;
    Impl::FontPool* _font;
    Impl::Utility* _util;
    Impl::TextureManager* _texture;
    Impl::SceneLoaderManager* _scene;

};

}

#endif // __GLFX_H__

---