glfxscene.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 __GLFXSCENE_H__
#define __GLFXSCENE_H__

#include "glfxvec.h"

#include <vector>
#include <map>

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4251) // 'member' : class 'class' needs to have dll-interface to be used by clients of class 'class'
#endif

namespace GLFX {
namespace Scene {

class Node
{
public:

    enum {
        TYPE_NODE=0,
        TYPE_STATIC_MESH,
        TYPE_CAMERA,
        TYPE_LIGHT,
        TYPE_USER_NODE=1024
    };

    Node() : _dirty(true), _disabled(false), _parent(0), _nodeTM(1.0f) {
    }

    Node(const Node& node) {
        _dirty = true;
        _disabled = node._disabled;
        _parent = 0;
        _nodeTM = node._nodeTM;
        _name = node._name;
        for(unsigned long i = 0; i < GetChildCount(); i++) {
            AddChild(GetChild(i)->Clone());
        }
    }

    virtual ~Node() {
        for(int i = 0; i < (int)_children.size(); i++) {
            Node* child = _children[i];
            delete child;
        }
        _children.clear();
    }

    virtual Node* Clone() {
        return new Node(*this);
    }

    virtual int GetType() {
        return TYPE_NODE;
    }

    virtual void UpdateTM(bool clearDirty) {
        if(_dirty) {
            if(_parent) {
                _worldTM = _nodeTM * _parent->GetWorldTM();
            } else {
                _worldTM = _nodeTM;
            }
        }
        for(NodeVecIt i = _children.begin(); i != _children.end(); i++) {
            Node* node = *i;
            node->UpdateTM(clearDirty);
        }
        if(clearDirty) {
            _dirty = false;
        }
    }
    
    unsigned long GetChildCount() const {
        return (int)_children.size();
    }

    Node* GetChild(unsigned long num) const {
        assert(num >= 0 && num < (int)_children.size());
        return _children[num];
    }

    void RemoveChild(unsigned long num) {
        assert(num >= 0 && num < (int)_children.size());
        delete _children[num];
        _children.erase(_children.begin() + num);
    }

    Node* DetachChild(unsigned long num) {
        assert(num >= 0 && num < (int)_children.size());
        Node* child = _children[num];
        _children.erase(_children.begin() + num);
        child->SetParent(0);
        return child;
    }

    unsigned long AddChild(Node* node) {
        _children.push_back(node);
        SetDirty();
        node->SetParent(this);
        return (unsigned long)_children.size() - 1;
    }

    const char* GetName() const {
        return _name.c_str();
    }

    void SetName(const char* name) {
        _name = name;
    }

    Matrix4& GetTM() {
        return _nodeTM;
    }

    const Matrix4& GetTM() const {
        return _nodeTM;
    }

    void SetTM(const Matrix4& tm) {
        _nodeTM = tm;
        SetDirty();
    }

    void ResetLocalTM() {
        _nodeTM = 1.0f;
        _dirty = true;
        for(unsigned long i = 0; i < GetChildCount(); i++) {
            GetChild(i)->ResetLocalTM();
        }
    }

    const Matrix4& GetWorldTM() const {
        return _worldTM;
    }

    bool IsDirty() const {
        return _dirty;
    }

    void SetDirty() {
        _dirty = true;
    }

    bool IsDisabled() const {
        return _disabled;
    }

    void SetDisabled(bool disabled) {
        _disabled = disabled;
    }

    Node* GetParent() {
        return _parent;
    }

protected:

    void SetParent(Node* node) {
        _parent = node;
        SetDirty();
    }

private:

    typedef std::vector<Node*> NodeVec;
    typedef NodeVec::iterator NodeVecIt;

    bool _disabled;
    bool _dirty;

    Matrix4 _nodeTM;            // relative to parent
    Matrix4 _worldTM;           // absolute world transform

    std::string _name;
    Node* _parent;
    NodeVec _children;

};

class Material : public IObject
{
public:

    Material(EffectManager* fxMgr) : _fxMgr(fxMgr) {
        ambient = Vec4(0, 0, 0, 1);
        diffuse = Vec4(1, 1, 1, 1);
        specular = Vec4(1, 1, 1, 1);
        level = 0.0f;
        transparency = 0.0f;
        _diffuseTex = 0;
        _refCount = 1;
    }

    virtual ~Material() {
        DeleteTextures();
    }

    unsigned long AddRef() {
        return ++_refCount;
    }

    unsigned long Release() {
        _refCount--;
        if(_refCount == 0) {
            delete this;
            return 0;
        }
        return _refCount;
    }

    const char* GetName() {
        return _name.c_str();
    }

    void SetName(const char* name) {
        _name = name;
    }

    GLuint GetDiffuseTexture() {
        return _diffuseTex;
    }

    const char* GetDiffuseMap() {
        if(_diffuseMap.length() == 0) {
            return 0;
        }
        return _diffuseMap.c_str();
    }

    void SetDiffuseMap(const char* mapName) {
        _diffuseMap = mapName;
    }

    const char* GetGlossMap() {
        if(_glossMap.length() == 0) {
            return 0;
        }
        return _glossMap.c_str();
    }

    void SetGlossMap(const char* mapName) {
        _glossMap = mapName;
    }

    const char* GetGlowMap() {
        if(_glowMap.length() == 0) {
            return 0;
        }
        return _glowMap.c_str();
    }

    void SetGlowMap(const char* mapName) {
        _glowMap = mapName;
    }

    const char* GetBumpMap() {
        if(_bumpMap.length() == 0) {
            return 0;
        }
        return _bumpMap.c_str();
    }

    void SetBumpMap(const char* mapName) {
        _bumpMap = mapName;
    }

    virtual void LoadTextures() {
        if(_diffuseTex) {
            _fxMgr->DeleteTexture(_diffuseTex);
            _diffuseTex = 0;
        }
        const char* mapName = GetDiffuseMap();
        if(mapName) {
            _diffuseTex = _fxMgr->LoadTexture(GL_TEXTURE_2D, mapName);
        }
    }

    virtual void DeleteTextures() {
        if(_diffuseTex) {
            _fxMgr->DeleteTexture(_diffuseTex);
            _diffuseTex = 0;
        }
    }

public:

    Vec4 ambient;
    Vec4 diffuse;
    Vec4 specular;
    float level;
    float transparency;

private:

    unsigned long _refCount;
    EffectManager* _fxMgr;
    std::string _name;
    std::string _diffuseMap;
    std::string _glossMap;
    std::string _glowMap;
    std::string _bumpMap;
    GLuint _diffuseTex;
};

class MeshNode : public Node
{
public:

    MeshNode() {
        _mesh = 0;
    }

    MeshNode(const MeshNode& node) {
        _mesh = node._mesh;
        if(_mesh) {
            _mesh->AddRef();
        }
        _materials.resize(node._materials.size());
        for(size_t i = 0; i < _materials.size(); i++) {
            _materials[i] = node._materials[i];
            if(_materials[i]) {
                _materials[i]->AddRef();
            }
        }
    }

    ~MeshNode() {
        if(_mesh) {
            _mesh->Release();
            _mesh = 0;
        }
        for(size_t i = 0; i < _materials.size(); i++) {
            if(_materials[i]) {
                _materials[i]->Release();
                _materials[i] = 0;
            }
        }
    }

    virtual Node* Clone() {
        return new MeshNode(*this);
    }

    virtual int GetType() {
        return TYPE_STATIC_MESH;
    }

    void SetMesh(IMesh* m) {
        if(_mesh) {
            _mesh->Release();
        }
        _mesh = m;
        if(_mesh) {
            _mesh->AddRef();
        }
    }

    IMesh* GetMesh() const {
        return _mesh;
    }

    void SetMaterialCount(int num) {
        _materials.resize(num);
        std::fill(_materials.begin(), _materials.end(), (Material*)0);
    }

    int GetMaterialCount() const {
        return (int)_materials.size();
    }

    void SetMaterial(int num, Material* material) {
        if(_materials[num]) {
            _materials[num]->Release();
            _materials[num] = 0;
        }
        _materials[num] = material;
        if(_materials[num]) {
            _materials[num]->AddRef();
        }
    }

    Material* GetMaterial(int num) const {
        return _materials[num];
    }

private:

    IMesh* _mesh;
    std::vector<Material*> _materials;

};

class CameraNode : public Node
{
public:

    CameraNode() {
        _fovx = 60.0f;
    }

    CameraNode(const CameraNode& node) {
        _fovx = node._fovx;
    }

    virtual Node* Clone() {
        return new CameraNode(*this);
    }

    virtual int GetType() {
        return TYPE_CAMERA;
    }

    Matrix4 GetCameraTM() const {
        return Inverse(GetWorldTM());
    }

    float GetFOV() const {
        return _fovx;
    }

    void SetFOV(float fovx) {
        _fovx = fovx;
    }

private:

    float _fovx;

};

class LightNode : public Node
{
public:

    LightNode() {
        _attnStart = 0.0f;
        _attnEnd = 0.0f;
        _color = Vec4(1, 1, 1, 1);
    }

    LightNode(const LightNode& node) {
        _attnStart = node._attnStart;
        _attnEnd = node._attnEnd;
        _color = node._color;
    }

    virtual Node* Clone() {
        return new LightNode(*this);
    }

    virtual int GetType() {
        return TYPE_LIGHT;
    }

    void SetColor(const Vec4& color) {
        _color = color;
    }

    const Vec4& GetColor() const {
        return _color;
    }

    void SetAttenuation(float start, float end) {
        _attnStart = start;
        _attnEnd = end;
    }

    float GetAttenuationStart() const {
        return _attnStart;
    }

    float GetAttenuationEnd() const {
        return _attnEnd;
    }

private:

    Vec4 _color;
    float _attnStart;
    float _attnEnd;

};

struct Frame
{
    Vec3 pos;
    Quat rot;
    Vec3 scl;

    bool IsRotationOnly() const {
        return pos.Equal(Vec3(0.0f)) && scl.Equal(Vec3(1.0f));
    }

    void Blend(Frame& result, const Frame& other, float otherWeight) const {
        result.pos = Lerp(pos, other.pos, otherWeight);
        result.rot = Slerp(rot, other.rot, otherWeight, true);
        result.scl = Lerp(scl, other.scl, otherWeight);
    }

    void BlendRotation(Quat& result, const Frame& other, float otherWeight) const {
        result = Slerp(rot, other.rot, otherWeight, true);
    }

    void ComputeTM(Matrix4& tm) const {
        tm = MatrixScaling(scl) *
            MatrixRotationQuaternion(rot) *
            MatrixTranslation(pos);
    }

};

class Animation
{
public:

    Animation() {
    }

    ~Animation() {
    }

    void SetLength(unsigned long frameCount, float startTime, float frequency) {
        _startTime = startTime;
        _frequency = frequency;
        _frameCount = frameCount;
    }

    void Initialize(unsigned long nodeCount) {
        _nodeCount = nodeCount;
        _frames.resize(_nodeCount * _frameCount);
        for(size_t i = 0; i < _frames.size(); i++) {
            _frames[i].pos = Vec3(0.0f);
            _frames[i].rot = Quat(0.0f);
            _frames[i].scl = Vec3(1.0f);
        }
    }

    void SetName(const char* name) {
        _name = name;
    }

    const char* GetName() const {
        return _name.c_str();
    }

    float GetStartTime() const {
        return _startTime;
    }

    float GetEndTime() const {
        return _startTime + (float)_frameCount / _frequency;
    }

    float GetLength() const {
        return (float)_frameCount / _frequency;
    }

    unsigned long GetFrameCount() const {
        return _frameCount;
    }

    unsigned long GetNodeCount() const {
        return _nodeCount;
    }

    Frame& GetFrame(unsigned long frame, unsigned long node) {
        return _frames[frame * _nodeCount + node];
    }

    const Frame& GetFrame(unsigned long frame, unsigned long node) const {
        return _frames[frame * _nodeCount + node];
    }

    void ApplyAnimation(Node* node, float time) const {
        node->ResetLocalTM();
        MultAnimation(node, time);
    }

    void ConvertTimeToFrameInterp(float time, unsigned long& frame,
        float& interp) const
    {
        long frameNum = (int)((time - _startTime) * _frequency);
        if(frameNum < 0) {
            frameNum = 0;
            interp = 0.0f;
        } else if(frameNum >= (int)_frameCount - 1) {
            frameNum = (int)_frameCount - 1;
            interp = 0.0f;
        } else {
            interp = fmod((time - _startTime) * _frequency, 1.0f);
            if(interp < 0.0f) {
                interp += 1.0f;
            }
        }
        assert(frameNum >= 0);
        frame = (unsigned long)frameNum;
    }

    void MultAnimation(Node* node, float time) const {
        unsigned long nodeNum = 0;
        unsigned long frameNum;
        float interp;
        ConvertTimeToFrameInterp(time, frameNum, interp);
        MultAnimationR(node, frameNum, interp, nodeNum);
        assert(nodeNum == _nodeCount);
    }

    void ApplyAnimationBlend(Node* node, float time,
        const Animation* otherAnim, float otherTime, float otherWeight)
    {
        node->ResetLocalTM();
        MultAnimationBlend(node, time, otherAnim, otherTime, otherWeight);
    }

    void MultAnimationBlend(Node* node, float time,
        const Animation* otherAnim, float otherTime, float otherWeight)
    {
        unsigned long nodeNum = 0;
        unsigned long frameNum, otherFrameNum;
        float interp, otherInterp;
        ConvertTimeToFrameInterp(time, frameNum, interp);
        otherAnim->ConvertTimeToFrameInterp(otherTime, otherFrameNum, otherInterp);
        MultAnimationBlendR(node, frameNum, interp, otherAnim, otherFrameNum,
            otherInterp, otherWeight, nodeNum);
        assert(nodeNum == _nodeCount);
    }

private:

    void ComputeFrame(Frame& frame, unsigned long frameNum, float interp,
        unsigned long nodeNum) const
    {
        if(interp == 0.0f) {
            frame = GetFrame(frameNum, nodeNum);
        } else {
            const Frame& frame1 = GetFrame(frameNum, nodeNum);
            const Frame& frame2 = GetFrame(frameNum + 1, nodeNum);
            frame1.Blend(frame, frame2, interp);
        }
    }

    void MultAnimationR(Node* node, unsigned long frameNum, float interp,
        unsigned long& nodeNum) const
    {
        Frame frame;
        ComputeFrame(frame, frameNum, interp, nodeNum);
        Matrix4 tm;
        frame.ComputeTM(tm);
        node->SetTM(node->GetTM() * tm);
        nodeNum++;
        for(unsigned long i = 0; i < node->GetChildCount(); i++) {
            Node* child = node->GetChild(i);
            MultAnimationR(child, frameNum, interp, nodeNum);
        }
    }

    void MultAnimationBlendR(Node* node, unsigned long frameNum, float interp,
        const Animation* otherAnim, unsigned long otherFrameNum,
        float otherInterp, float otherWeight, unsigned long& nodeNum) const
    {
        Frame frame, otherFrame, blendFrame;
        ComputeFrame(frame, frameNum, interp, nodeNum);
        otherAnim->ComputeFrame(otherFrame, otherFrameNum, otherInterp, nodeNum);
        frame.Blend(blendFrame, otherFrame, otherWeight);
        Matrix4 tm;
        blendFrame.ComputeTM(tm);
        node->SetTM(node->GetTM() * tm);
        nodeNum++;
        for(unsigned long i = 0; i < node->GetChildCount(); i++) {
            Node* child = node->GetChild(i);
            MultAnimationR(child, frameNum, interp, nodeNum);
        }
    }

    std::string _name;
    float _startTime;
    float _frequency;
    unsigned long _frameCount;
    unsigned long _nodeCount;
    std::vector<Frame> _frames;

};

class AnimationSet
{
public:

    AnimationSet() {
    }

    virtual ~AnimationSet() {
        for(AnimVecIt i = _anims.begin(); i != _anims.end(); i++) {
            delete *i;
        }
    }

    void AddAnimation(Animation* anim) {
        _anims.push_back(anim);
        _animMap[anim->GetName()] = anim;
    }

    unsigned long GetAnimationCount() const {
        return (unsigned long)_anims.size();
    }

    const Animation* GetAnimation(unsigned long number) const {
        return _anims[number];
    }

    const Animation* FindAnimationByName(const char* name) const {
        AnimMapCIt i = _animMap.find(name);
        if(i == _animMap.end()) {
            return 0;
        }
        return i->second;
    }

private:

    struct cstr_less
    {
        bool operator()(const char* a, const char* b) const {
            return strcmp(a, b) < 0;
        }
    };

    typedef std::vector<Animation*> AnimVec;
    typedef AnimVec::iterator AnimVecIt;
    typedef std::map<const char*, Animation*, cstr_less> AnimMap;
    typedef AnimMap::const_iterator AnimMapCIt;

    AnimVec _anims;
    AnimMap _animMap;

};

#pragma pack(4)

struct DefaultVertex
{
    Vec3 position;
    Vec3 normal;
    Vec2 texture;

    typedef VertexFormat<VC_VERTEX_3F, VC_NORMAL_3F, VC_TEXTURE0_2F> Format;
};

#pragma pack()

class GLFX_EXPORT DefaultSceneBuilder : public ISceneBuilder
{
public:

    DefaultSceneBuilder();
    virtual ~DefaultSceneBuilder();

    // public interface
    bool Initialize(EffectManager* fxMgr);
    bool Finalize();
    int CreateNode(const char* nodeName, int type);
    int CreateMaterial(const char* materialName);
    int CreateAnimation(const char* animName);
    void SetNodeParentByName(int nodeId, const char* parentName);
    void SetNodeTM(int nodeId, const float* tm);
    void SetMeshParameters(int nodeId, GLenum primitiveType, unsigned long vertexCount, unsigned long indexCount, unsigned long primitiveGroupCount);
    bool SetMeshVertexData(int nodeId, unsigned long type, unsigned long dim, const float* data);
    bool SetMeshFaceIndices(int nodeId, const unsigned long* data);
    void SetMeshPrimitiveGroup(int nodeId, unsigned long groupId, unsigned long start, unsigned long count);
    void SetMeshMaterial(int nodeId, unsigned long groupId, int materialId);
    void SetLightColor(int nodeId, const float* color);
    void SetLightAttenuation(int nodeId, float attnStart, float attnEnd);
    void SetCameraFieldOfViewX(int nodeId, float fovx);
    void SetMaterialAmbientColor(int materialId, const float* color);
    void SetMaterialDiffuseColor(int materialId, const float* color);
    void SetMaterialSpecularColor(int materialId, const float* color);
    void SetMaterialSpecularLevel(int materialId, float level);
    void SetMaterialTransparency(int materialId, float transparency);
    void SetMaterialDiffuseMap(int materialId, const char* name);
    void SetMaterialGlossMap(int materialId, const char* name);
    void SetMaterialGlowMap(int materialId, const char* name);
    void SetMaterialBumpMap(int materialId, const char* name);
    void SetAnimationParameters(int animId, float startTime, float frequency, unsigned long frameCount);
    void SetAnimationNodeKeyframes(int animId, int nodeId, unsigned long type, float* data);

    // specific members

    EffectManager* GetEffectManager();

    Node* GetRootNode();

    AnimationSet* GetAnimationSet();

protected:

    virtual Node* AllocNode(int type) {
        switch(type) {
        case Node::TYPE_NODE:
            return new Node();
        case Node::TYPE_STATIC_MESH:
            return new MeshNode();
        case Node::TYPE_CAMERA:
            return new CameraNode();
        case Node::TYPE_LIGHT:
            return new LightNode();
        }
        return 0;
    }

    virtual void DeleteNode(Node* node) {
        delete node;
    }

    virtual IMesh* CreateMesh(GLenum primitiveType, unsigned long vertexCount,
        unsigned long indexCount, unsigned long primitiveGroupCount);

    virtual bool IsMeshNode(Node* node);

    virtual bool IsLightNode(Node* node);

    virtual bool IsCameraNode(Node* node);

    virtual Material* AllocMaterial() {
        return new Material(GetEffectManager());
    }

    virtual Animation* AllocAnimation() {
        return new Animation();
    }

    virtual void DeleteAnimation(Animation* anim) {
        delete anim;
    }

    virtual AnimationSet* AllocAnimationSet() {
        return new AnimationSet();
    }

    virtual void DeleteAnimationSet(AnimationSet* animSet) {
        delete animSet;
    }

private:

    struct NodeAnim
    {
        std::vector<Vec3> pos;
        std::vector<Quat> rot;
        std::vector<Vec3> scl;
    };

    typedef std::map<int, NodeAnim*> NodeAnimMap;

    struct NodeInfo
    {
        Node* node;
        std::string nodeName;
        std::string parentName;
        bool topLevel;
        std::vector<char> vertexData;
        std::vector<int> mats;
        NodeAnimMap anims;
    };

    typedef std::vector<NodeInfo*> NodeVec;
    typedef NodeVec::iterator NodeVecIt;
    typedef std::map<std::string, NodeInfo*> NodeMap;
    typedef NodeMap::iterator NodeMapIt;
    typedef std::vector<Material*> MatVec;
    typedef MatVec::iterator MatVecIt;
    typedef std::vector<Animation*> AnimVec;
    typedef AnimVec::iterator AnimVecIt;
    typedef std::map<Node*, int> NodeIdMap;

    void _CreateNodeIdMapR(Node* node, int& id, NodeIdMap& idMap);

    int _refCount;
    EffectManager* _fxMgr;
    NodeVec _nodes;
    NodeMap _nodeMap;
    MatVec _mats;
    Node* _root;
    AnimationSet* _animSet;
    AnimVec _anims;

};

}}

#ifdef _MSC_VER
#pragma warning(pop)
#endif

#endif // __GLFXSCENE_H__

---