aesop-physics.h

Go to the documentation of this file.

/*
 * aesop-physics.h
 *
 * Copyright (C) 2008,2009  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#ifndef AESOP_PHYSICS_H__
#define AESOP_PHYSICS_H__

// includes --------------------------------------------------------------------
#include "common/common.h"

#include "typeinst/typeinst.h"
#include "geometry/geometry_3d.h"
#include "geometry/quaternion.h"


// forward declarations
class Datahash;
namespace hfield {
        class Heightfield;
};      // hfield namespace
namespace trimesh {
        class Trimesh;
};      // trimesh namespace


namespace aesop {




void getVectorFromEulerAngles(IN const point3d_t& euler,
                                OUT point3d_t& vector) throw();


void getVectorFromQuaternion(IN const quaternion_t& rotation,
                                OUT point3d_t& vector) throw();


class PhysicsShape {
public:
        // virtual destructor --------------------------------------------------
        virtual ~PhysicsShape(void) throw();

        // aesop::PhysicsShape class interface methods -------------------------
        virtual void setContext(IN void * ctx) throw() = 0;
        virtual void * getContext(void) throw() = 0;
};


// primitives to create basic collision shapes
smart_ptr<PhysicsShape> createBoxShape(IN const point3d_t& dimensions);
smart_ptr<PhysicsShape> createCubeShape(IN float edge_length);
smart_ptr<PhysicsShape> createCapsuleShape(IN float height, IN float radius);
smart_ptr<PhysicsShape> createTrimeshShape(IN const trimesh::Trimesh * trimesh);
smart_ptr<PhysicsShape> createHeightfieldShape(IN const hfield::Heightfield * field);



class PhysicsObject;

typedef void (*object_iteration_fn)(IN smart_ptr<PhysicsObject>& obj,
                                IN void * context);


class PhysicsObject {
public:
        // public enums --------------------------------------------------------
        enum eFlags {
                eFlag_Ghost             = 0x0001, 
                eFlag_Moveable          = 0x0002, 
                eFlag_Events            = 0x0004, 
                eFlag_NoCollisions      = 0x0008, 
                eFlag_Remove            = 0x0010, 
                eFlag_Static            = 0x0020, 

                // keep this last!
                eFlag_Invalid           = 0x8000
        };

        // virtual destructor --------------------------------------------------
        virtual ~PhysicsObject(void) throw();

        // aesop::PhysicsObject class interface methods ------------------------

        virtual dword_t getId(void) const throw() = 0;

        virtual int getFlags(void) const throw() = 0;

        virtual void dump(IN const char * txt) const throw() = 0;

        virtual point3d_t getPosition(void) const throw() = 0;

        virtual rect3d_t getBoundingBox(void) const throw() = 0;

        virtual quaternion_t getOrientation(void) const throw() = 0;

        virtual point3d_t getLinearVelocity(void) const throw() = 0;

        virtual point3d_t getAngularVelocity(void) const throw() = 0;

        virtual void setOrientation(IN const quaternion_t& orient) = 0;
        virtual void setLinearVelocity(IN const point3d_t& linear) = 0;
        virtual void setAngularVelocity(IN const point3d_t& angular) = 0;

        virtual void requestMove(IN const point3d_t& delta,
                                IN float dt) = 0;

        virtual void setPosition(IN const point3d_t& pos) = 0;

        virtual float getMass(void) const throw() = 0;

        virtual void iterateOverlappingObjects(IN object_iteration_fn fn,
                                IN void * context) = 0;

        virtual void setUserPointer(void * userPointer) throw() = 0;

        virtual void * getUserPointer(void) const throw() = 0;
};


smart_ptr<PhysicsObject> getPhysicsObjectById(IN dword_t id);


struct physics_meta_t {
        // constructor, manipulator
        physics_meta_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        shape = NULL;
                        mass = 0;
                        objectFlags = 0;
                }
        void dump(IN const char * msg) const throw() {
                        DPRINTF("%s: physics_meta_t", msg);
                        DPRINTF("      shape: %p", (const PhysicsShape *) shape);
                        DPRINTF("      mass: %f", mass);
                        DPRINTF("      flags: 0x%08x", objectFlags);
                }

        // data fields
        smart_ptr<PhysicsShape>         shape;
        float                           mass;
        int                             objectFlags;
};



smart_ptr<PhysicsObject> createObject(IN const physics_meta_t& meta,
                                IN const placement_t& placement);



class PhysicsWorld {
public:
        // public typedefs -----------------------------------------------------
        struct object_iterator_t {
        private:
                byte_t          opaque[6 * sizeof(long)];
        };

        struct collision_iterator_t {
        private:
                byte_t          opaque[4 * sizeof(long)];
        };

        struct collision_record_t {
                collision_record_t(void) throw() { this->clear(); }
                void clear(void) throw() {
                                obj1 = NULL;
                                obj2 = NULL;
                        }

                // data fields
                smart_ptr<PhysicsObject>        obj1;
                smart_ptr<PhysicsObject>        obj2;
        };

        // virtual destructor --------------------------------------------------
        virtual ~PhysicsWorld(void) throw();

        // aesop::PhysicsWorld class interface methods -------------------------
        virtual void addObject(IN smart_ptr<PhysicsObject>& o) = 0;
        virtual void removeObject(IN PhysicsObject * obj) = 0;
        virtual long getObjectCount(void) throw() = 0;
        virtual void tick(IN float seconds) = 0;

        virtual void getObjectIterator(OUT object_iterator_t& i) = 0;
        virtual bool getNextObject(IO object_iterator_t& i,
                                OUT smart_ptr<PhysicsObject>& obj) = 0;

        virtual void getCollisionIterator(OUT collision_iterator_t& i) = 0;
        virtual bool getNextCollision(IO collision_iterator_t& i,
                                OUT collision_record_t& cr) = 0;

        virtual smart_ptr<PhysicsObject> rayTest(IN const point3d_t& from,
                                IN const point3d_t& to) = 0;

        // static factory methods ----------------------------------------------
        static smart_ptr<PhysicsWorld> create(IN const Datahash * params);
};



// primitives + debugging

smart_ptr<PhysicsObject> getObjectHitFromPlacement(IN PhysicsWorld * world,
                                IN const placement_t& placement,
                                IN float half_extent);

void dumpWorld(IN PhysicsWorld * world) throw();


};      // aesop namespace

#endif  // AESOP_PHYSICS_H__