OvglMesh.h

Go to the documentation of this file.

// Forward declare external classes
class NxActor;

namespace Ovgl
{
        enum Clean { CLEAN_ALL, STRAY_VERTICES, CLOSE_VERTICES, BROKEN_FACES };

        class Vertex;
        class Face;
        class Bone;
        class Joint;
        class Animation;
        class Frame;
        class Key;
        class CMesh;
        class Mesh;
        class Instance;
        class Scene;
        class Matrix44;

        extern "C"
        {
                class __declspec(dllexport) Vertex
                {
                public:
                        Ovgl::Vector3 position;
                        Ovgl::Vector3 normal;
                        Ovgl::Vector2 texture;
                        Ovgl::Vector4 weight;
                        Ovgl::Vector4 indices;
                        bool operator == (const Vertex&) const;
                        bool operator != (const Vertex&) const;
                };
                class __declspec(dllexport) Face
                {
                public:
                        DWORD indices[3];
                        Face Flip();
                };

                class __declspec(dllexport) Key
                {
                public:
                        DWORD index;
                        Vector4 rotation;
                };

                class __declspec(dllexport) Frame
                {
                public:
                        DWORD time;
                        std::vector<Key> keys;
                };

                class __declspec(dllexport) Animation
                {
                public:
                        std::vector<Joint*>                                     joints;
                        DWORD                                                           animationState;
                        float                                                           currentTime;
                        float                                                           startTime;
                        float                                                           endTime;
                        float                                                           stepTime;
                        void play( float speed, bool repeat );
                        void stop();
                        void pause();
                        void set( float time );
                };

                class __declspec(dllexport) Bone
                {
                public:
                        NxConvexMesh*                                           convex;
                        Mesh*                                                           mesh;
                        Matrix44                                                        matrix;
                        float                                                           length;
                        Ovgl::Vector3                                           min;
                        Ovgl::Vector3                                           max;
                        DWORD                                                           parent;
                        std::vector<DWORD>                                      childen;
                };

                class __declspec(dllexport) CMesh
                {
                public:
                        Scene* scene;
                        NxActor* actor;
                        void setPose( Matrix44* matrix );
                        Matrix44 getPose();
                        void Release();
                };

                class __declspec(dllexport) Mesh
                {
                public:
                        Instance*                                                       Inst;
                        std::vector<Vertex>                                     vertices;
                        std::vector<Face>                                       faces;
                        std::vector<DWORD>                                      attributes;
                        std::vector<Bone*>                                      bones;
                        std::vector<Frame*>                                     keyframes;
                        DWORD                                                           subset_count;
                        DWORD                                                           root_bone;
                        ID3D10Buffer*                                           VertexBuffer;
                        ID3D10Buffer**                                          IndexBuffers;
                        void Save( const std::string& file );
                        void GenerateBoneMeshes();
                        void GenerateVertexNormals();
                        void CubeCloud( float sx, float sy, float sz, int count );
                        void QuickHull();
                        void Simplify( DWORD max_faces, DWORD max_vertices );
                        void Clean( float min, DWORD flags  );
                        void ConnectVertex( std::vector<DWORD>& faceList, DWORD vertex );
                        void MergeVerices( std::vector<DWORD>& vertexList, DWORD flag );
                        Ovgl::Vector3 ComputeFaceNormal( DWORD face );
                        void Update();
                        void Release();
                };
        }
}