SNCH_Object.h

Go to the documentation of this file.

#ifndef SNCH_OBJECT_H
#define SNCH_OBJECT_H

#include "SphereBVH_Object.h"
#include "SNCH_Object_Data.h"

#include <vrecko/SP_ObjectInterface.h>
#include <vrecko/MTLock.h>

using namespace vrecko;

namespace APSpacePartitioning {

// Flags for SNCH_Object::LocalMinimumDistance::dwFlags
#define SNCH_LMD_F_INTERSECTION         0x00000001
    // The returned points don't mean points of collision, but it is a part of the intersection polyline
#define SNCH_LMD_F_NEGATIVE_DISTANCE    0x00000002
    // The LMD points define negative distance, which (usually?) means largest intersection distance
    // in a local neigbourhood (and not smallest distance between surfaces).
    // This can arise only in localSearch and it depends on firstly finding the intersection.


/* 

// Flags for SNCH_Object::LocalMinimumDistance::closeFeatures and other

Not implemented (yet?)

#define SNCH_CF_VERTEX1             0x01
#define SNCH_CF_VERTEX2             0x02
#define SNCH_CF_VERTEX3             0x04
#define SNCH_CF_EDGE1               0x08
#define SNCH_CF_EDGE2               0x10
#define SNCH_CF_EDGE3               0x20

*/

#define SNCH_FLOAT_SMALL_NUM    0.00000001f
//#define SNCH_FLOAT_TOLERANCE  0.001f
#define SNCH_FLOAT_TOLERANCE    SNCH_FLOAT_SMALL_NUM



#define SP_OBJECT_INTERFACE_ID__SNCH            20
    

class SNCH_Object: public SphereBVH_Object {
public:
    //
    // constructors / destructors
    //
    SNCH_Object();
    ~SNCH_Object();

    virtual void preInitialize(void);

    float getForce(void);

    void setNCoeficient(double nc) {ncoeficient = nc;}
    double getNCoeficient(void) {return ncoeficient;}
    void setMaxForce(double mforce) {max_force = mforce;}
    double getMaxForce(void) {return max_force;}
    
    virtual bool getCollisions(CollisionParams * params, COLLISION_POINTS_VECTOR ** colPoints,
        unsigned long obj1ID, unsigned long obj2ID);
        // overriden method from SP_ObjectInterface

    typedef struct LocalMinimumDistance {
        unsigned long dwFlags; // Combination of SNCH_LMD_F_*
        unsigned long faces[2]; // indices of faces that are colliding
        osg::Vec3 pointsTrans[2];
            // Points transformed into world space. Exact meaning depends on [dwFlags].
            // It is either a possible-future-contact points pair or an intersection line.
        unsigned short closeFeatures[2];
            // The vertices and/or edges which are the closest one to the contact points.
            // Can have of of the values:
            //      0, 1, 2 - index of the respective vertex
            //      3, 4, 5 - index of the respective edge + 3
            //      0xFF - if all of the vertices are too far
        osg::Vec3 vecTriMaxNegDist;
            // Used only if [dwFlags] contains SNCH_LMD_F_NEGATIVE_DISTANCE.
    };
    typedef std::vector<LocalMinimumDistance> LMDvector;

    class LMDStore {
    public:
        LMDStore() { active_LMD = 0; bLMDValid[0] = bLMDValid[1] = false; }

        unsigned char active_LMD;
            // Which of the LMDs vector is used for local updates (strictly 0 or 1).
            // The other is for background calculation of global update.
        bool bLMDValid[2];
            // Is a particular LMD vector valid? (i.e. Have the initial calculations already ended?)
        LMDvector LMDs[2];

        // add a timestamp? (TODO?)

        MTLock LMDswitch;
            // TODO: This might create too many critical sections/mutexes.
            //          (one for each collision pair)
            // It's a critical section/mutex to protect switching [active_LMD] to the other vector.
    };

protected:
    double ncoeficient, max_force;

    typedef __int64 LMD_HASH; // May need some adjustments for Linux or non-MSVC compilers. (Now it has to be at least 64 bits long.)
    typedef Sgi::hash_map<LMD_HASH, LMDStore*> LMD_STORE_MAP;
    LMD_STORE_MAP lmd_store;
        // DON'T ACCESS THIS DIRECTLY !!! It has to have a multithread access protection.
        // USE the getLMDStore() method.
        // The KEY of this hash_map is composed of two object IDs.
        // Use calcLMDHash() method to calculate it.
    MTLock lmd_store_access;
    inline LMD_HASH calcLMDHash(unsigned long int id1, unsigned long int id2)
        { return (((LMD_HASH)id1) << 32) + (LMD_HASH)id2; }

    LMDStore* getLMDStore(LMD_HASH hash);
        // Gets a LMDStore for the given hash. Creates one if it doesn't exist.


    double reject_distance_for_surfaces, reject_distance_for_BS;
    double angle_tolerance; // LOD - plane detection (convex, concave surface)

    void globalSearch(SNCH_Object_Data *pOData1, SNCH_Object_Data *pOData2, LMDStore *lmds,
        CollisionParams *params);
    void localSearch(SNCH_Object_Data *pOData1, SNCH_Object_Data *pOData2, LMDStore *lmds,
        CollisionParams *params, int lmdIndex, int dbgWriterGLIndex = 0);
    bool testNodeNorec(SNCH_Object_Data::STNodeSNCH *pSTNode1, SNCH_Object_Data *pOData1, osg::Matrix *transf1,
                           SNCH_Object_Data::STNodeSNCH *pSTNode2, SNCH_Object_Data *pOData2, osg::Matrix *transf2,
                           LMDStore *lmds, CollisionParams * params);
        // no-recursion

    bool getObjectsTransformations(SNCH_Object_Data *pOData1, SNCH_Object_Data *pOData2, CollisionParams *params,
                                            osg::Matrix *transf1, osg::Matrix *transf2);


    struct InternalPointStruct {
        osg::Vec3 pos;
        osg::Vec3 normal;
    };
    class OneTri {
    public:
        OneTri() { reset(); };
        inline void reset() { planeNormal.x() = FLT_MAX; planeD = FLT_MAX; };

        inline void calcNormal() { 
            if (planeNormal.x() == FLT_MAX) { 
                planeNormal = (v[1].pos - v[0].pos) ^ (v[2].pos - v[0].pos);
                float len = planeNormal.length();

                bZeroNormal = true;
                if (len >= SNCH_FLOAT_SMALL_NUM) {
                    bZeroNormal = false;
                    planeNormal /= len;
                }
            }
        }

        inline void calcD() {
            if (planeD == FLT_MAX)
                planeD = -(v[0].pos.x() * planeNormal.x() + v[0].pos.y() * planeNormal.y() + v[0].pos.z() * planeNormal.z());
        }

        InternalPointStruct v[3];

        bool bZeroNormal; // if the [planeNormal] is zero, this will be set to "true".
        osg::Vec3 planeNormal;
        float planeD;
    };
    typedef OneTri TWO_TRIS[2];

    typedef enum {
        NoIntersection, // no intersection between the triangle cone and the other triangle
        OriginalTriangleIntersection, // intersection between the triangles
        ConeIntersection // intersection between the triangle cone and the other triangle
    } ProjectionIntersectionResult;

    ProjectionIntersectionResult triProjectionIntersection(
        OneTri *points0,
        OneTri *points1,
        osg::Vec3 *outIntersectionPoint0 = NULL,
        osg::Vec3 *outIntersectionPoint1 = NULL,

        bool bPerformPretests = true
        );
        // WARNING: This function is optimized and so it expects that it will be called twice
        // for two triangles (with reversed parameters).
        // This is due to some test at the beginning of the function.
        //
        // The idea:
        // Project vertices on [tri1] using the normals into the plane specified by [tri2].
        // Then the 2D triangles are tested for intersection.
        // If triangles lie on the same plane, they are intersecting in theory, but we will take
        // it as non-intersecting triangles with distance = 0.
        // [outIntersectionPoint0] and [outIntersectionPoint1] are filled only if the original triangles intersect.


    bool triIntersects(OneTri *points0, OneTri *points1, osg::Vec3 *outPoint0Trans = NULL, osg::Vec3 *outPoint1Trans = NULL,
        osg::Vec3 *outPoint0Tri0Cross = NULL, osg::Vec3 *outPoint1Tri0Cross = NULL, bool *bOutPointsTriCrossValid = NULL);
        // Returns if both triangles intersects in 3D space.
        // ASSUMES that the triangles DOES NOT lie on the same plane (this should be checked by the triProjectionIntersection() method)
        //      (SIDE NOTE: The method returns "false" if triangles are coplanar. This would be also OK for us
        //                  if they were on the same plane, so basically no assumption needed)
        // Therefore this method conculdes that if the triangles lie on the planes with
        // the same or opposite normal, then the triangles don't intersect.
        // If the triangles intersect, it can also return the middle point of intersection
        // [outPoint0Tri0Cross], [outPoint0Tri1Cross] are only calculated and outputted if requested.
        //      They represetns the points in space where [tri1] intersects the plane defined by [tri2].

    float triDistance(OneTri *points0, OneTri *points1, osg::Vec3 *outPoint1Trans = NULL, osg::Vec3 *outPoint2Trans = NULL,
        unsigned short *closeFeature0 = NULL, unsigned short *closeFeature1 = NULL);
        // Calculates the triangle distance in 3D space.
        // NOTE that it ASSUMES that the triangles DON'T INTERSECT. This should have been resolved before.
        // Can calculate points here the distance was achieved.
        // The points are already transformed into the world space.

    bool old_getTriLMD(
        SNCH_Object_Data::STNodeSNCH *pSTNode1, SNCH_Object_Data *pOData1, osg::Matrix *transf1, osg::Vec3 *center1,
        SNCH_Object_Data::STNodeSNCH *pSTNode2, SNCH_Object_Data *pOData2, osg::Matrix *transf2, osg::Vec3 *center2,
        osg::Vec3 point[2][7], unsigned long *index1, unsigned long *index2);
        // Getting the LMDs using the old algorithm.
        // [pSTNode1/2] and [center1/2] may be NULL - in that case the cones won't be used.
        // (Only the distance between those 7x7 points.)

};


}

#endif