OvglScene.h

Go to the documentation of this file.

// Forward declare external classes
class NxScene;
class NxCapsuleController;
class NxCapsuleControllerDesc;
class NxD6Joint;

namespace Ovgl
{
        extern "C"
        {
                class Actor;
                class Camera;
                class Light;
                class Prop;
                class Scene;
                class Mesh;
                class CMesh;
                class AudioEmitter;
                class AudioVoice;
                class Instance;
                class Effect;
                class Joint;
                class Vector3;

                class __declspec(dllexport) RayHit
                {
                public:
                        DWORD type;
                        Ovgl::CMesh* cmesh;
                        Ovgl::Prop* prop;
                        Ovgl::Actor* actor;
                        Ovgl::Vector3 loc_point;
                        Ovgl::Vector3 ws_point;
                };

                class __declspec(dllexport) Joint
                {
                public:
                        Scene* scene;
                        NxD6Joint* joint;
                        void Release();
                };

                class __declspec(dllexport) Camera
                {
                public:
                        Scene* scene;
                        CMesh* cmesh;
                        Matrix44 projMat;
                        std::vector<AudioVoice*> voices;
                        void setPose( Matrix44* matrix );
                        Matrix44 getPose();
                        void Release();
                };
                
                class __declspec(dllexport) Light
                {
                public:
                        Scene* scene;
                        CMesh* cmesh;
                        Vector3 color;
                        DWORD type;
                        void setPose( Matrix44* matrix );
                        Matrix44 getPose();
                        void Release();
                };
                
                class __declspec(dllexport) Prop
                {
                public:
                        Scene*                                                                  scene;
                        Mesh*                                                                   mesh;
                        std::vector<CMesh*>                                             bones;
                        std::vector<Effect*>                                    subsets;
                        std::vector<Matrix44>                                   matrices;
                        std::vector<Joint*>                                             joints;
                        std::vector<Animation*>                                 animations;
                        void Update( int bone, Matrix44* matrix );
                        void CreateJoints( DWORD bone );



                        Animation* CreateAnimation( float current, float start, float end );
                        void setPose( Matrix44* matrix );
                        Matrix44 getPose();
                        void Release();
                };
        
                class __declspec(dllexport) Object
                {
                public:
                        Scene* scene;
                        CMesh* cmesh;
                        Mesh* mesh;
                        std::vector<Effect*> subsets;
                        void setPose( Matrix44* matrix );
                        Matrix44 getPose();
                        void Release();
                };
        
                class __declspec(dllexport) Emitter
                {
                public:
                        Scene*                                                                  scene;
                        CMesh*                                                                  cmesh;
                        void setPose( Matrix44* matrix );
                        Matrix44 getPose();
                        void Release();
                };

                class __declspec(dllexport) Actor
                {
                public:
                        NxCapsuleController* controller;
                        NxCapsuleControllerDesc* desc;
                        Scene* scene;
                        Camera* camera;
                        CMesh* cmesh;
                        Mesh* mesh;
                        Vector3 trajectory;
                        Vector3 direction;
                        Vector3 velocity;
                        RayHit hit;
                        bool crouch;
                        bool grounded;
                        void SetTrajectory( Vector3 vec );
                        void SetDirection( Vector3 vec );
                        void Jump( float force );
                        void Release();
                };

                class __declspec(dllexport) Scene
                {
                public:
                        Instance*                                                               Inst;
                        NxScene*                                                                physics_scene;
                        std::vector<Object*>                                    objects;
                        std::vector<Light*>                                             lights;
                        std::vector<Camera*>                                    cameras;
                        std::vector<Prop*>                                              props;
                        std::vector<Actor*>                                             actors;
                        std::vector<Emitter*>                                   emitters;
                        Light* CreateLight( Matrix44* matirx, Vector4* color );
                        Camera* CreateCamera( Matrix44* view_matrix );
                        Actor* CreateActor( Mesh* mesh, float radius, float height, Matrix44* matirx );
                        Prop* CreateProp( Mesh* mesh, Matrix44* matrix);
                        Object* CreateObject( Mesh* mesh, Matrix44* matrix);
                        Emitter* CreateEmitter( Matrix44* matrix );
                        void Update( DWORD update_time );
                        void Save( const std::string& file, DWORD flags );
                        void Load( const std::string& file, DWORD flags );
                        void Import_FBX( const std::string& file, DWORD flags );
                        void Release();
                };
        }
}