bulletUtil.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2023 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/



#pragma once

#include <vantageTerrainImplementation/vantageTerrainImplementationDefines.h>
#include <btBulletCollisionCommon.h>
#include <geometry/point.h>
#include <geometry/surface.h>
#include <vrfutil/vrfChordIntersectionRecord.h>
#include <matrix/vlVector.h>
#include <list>
#include <terrainInterface/terrainPagingGeometry.h>
#include <tbb/spin_rw_mutex.h>
#include <vrvUtil/DtCoordinateSystem.h>

#include <terrainCS/serializableUtmCS.h>

#include <boost/optional.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>

#include <LinearMath/btTransform.h>
#include <LinearMath/btMatrix3x3.h>

#include <osg/Matrix>
#include <osg/Vec3>

class DtChord;
class DtSphere;
class DtLocalVertexList;
class DtVrfChordIntersectRecordList;
class DtCollisionObjectInterface;
class Coordinate_System;

#define LONG_FUDGE_FACTOR 1e-6
#define SETNORTH(u,n)   (u).setNorth((n))
#define SETEAST(u,e) (u).setEast((e))
#define SETUP(u,upp) (u).setUp((upp))


typedef std::list< boost::shared_ptr<btCollisionObject> > DtCollisionObjectList;

class DT_DLL_vantageTerrainImplementation DtCollisionObjectInterface
   : public boost::enable_shared_from_this<DtCollisionObjectInterface>
{
public:
   typedef std::vector< boost::shared_ptr<makVrv::DtDynamicTerrainFeature> > DynamicFeatures;

   virtual ~DtCollisionObjectInterface();

   virtual boost::shared_ptr<btCollisionShape> bulletCollisionShape() const = 0;

   virtual const btTransform& worldTransform() const = 0;

   virtual bool buildBvh() = 0;

   virtual bool isBvhBuilt() const = 0;

   virtual bool enabled() const = 0;

   virtual unsigned int numberOfTriangles() const = 0;

   virtual double radius() const = 0;

   virtual DtSurface triangleSurface(unsigned int triangleIndex) const = 0;

   virtual DynamicFeatures dynamicFeatures() const = 0;
};

class DtSerializableUtmCS_ext : public DtSerializableUtmCS
{
public:
   DtSerializableUtmCS_ext(
      const DtDegMinSec& refLatitude,
      const DtDegMinSec& refLongitude,
      int standardOffsets,
      DtUtmReferencePoint* refPoint,
      long zone = 0,
      bool setUseDynamicSceneOrigin = false,
      double dynamicSceneOriginDeadband = 0.0,
      double scaleFactor = 0.9996);

   virtual ~DtSerializableUtmCS_ext();;

protected:
   void init2RefLatLon(const DtDegMinSec& refLatitude,
      const DtDegMinSec& refLongitude, int standardOffsets, long zone,
      bool setUseDynamicSceneOrigin, double dynamicSceneOriginDeadband,
      double scaleFactor, DtUtmReferencePoint* refPoint);;

   DtUtmReferencePoint* myUtemRefPoint;
};


inline btVector3 DtPoint2btVector3(const DtPoint& p)    { return btVector3(p.x(), p.y(), p.z()); }
inline btVector3 DtVector2btVector3(const DtVector& v)  { return btVector3(v.x(), v.y(), v.z()); }
inline DtPoint btVector32DtPoint(const btVector3& v)    { return DtPoint(v.x(), v.y(), v.z()); }
inline DtVector btVector32DtVector(const btVector3& v)  { return DtVector(v.x(), v.y(), v.z()); }
bool DT_DLL_vantageTerrainImplementation btVectorIsZero(const btVector3& v);

bool DT_DLL_vantageTerrainImplementation chordSphereVolumetricIntersect(
   const DtChord& chord,
   const DtSphere& sphere);

bool DT_DLL_vantageTerrainImplementation sphereSphereVolumetricIntersect(
   const DtSphere& sphere1,
   const DtSphere& sphere2);

bool DT_DLL_vantageTerrainImplementation shapeSphereVolumetricIntersect(
   const Coordinate_System&,
   const DtLocalVertexList& shape,
   const DtSphere& sphere);

bool DT_DLL_vantageTerrainImplementation geometrySphereVolumetricIntersect(
   const Coordinate_System&,
   DtTerrainPagingGeometryPtr geometry,
   const DtSphere& sphere);

struct DT_DLL_vantageTerrainImplementation DtBulletRayResultCallback
   : public btCollisionWorld::RayResultCallback
{
   struct RayResultRecord
   {
      explicit RayResultRecord(btCollisionWorld::LocalRayResult& rayResult, bool normalInWorldSpace);

      DtVrfChordIntersectionRecord getRecord(
         DtIntersectionRecord::DtIntersectionType irtFlag,
         const btVector3& rayFromWorld, const btVector3& rayToWorld) const;

      boost::shared_ptr<const DtCollisionObjectInterface> object;
      btScalar intersectionTime;
      btVector3 normal;
      boost::optional<btTransform> normalTransform;
      int triangleIndex;
   };

   explicit DtBulletRayResultCallback(
      DtIntersectionRecord::DtIntersectionType irtFlag, short int filterMask);

   virtual bool needsCollision(btBroadphaseProxy* proxy0) const override;

   bool dataAvailable() const { return myDataAvailable; }

protected:
   const DtIntersectionRecord::DtIntersectionType myIrtFlag;
   mutable bool myDataAvailable;
};

struct DT_DLL_vantageTerrainImplementation DtAllHitsRayResultCallback
   : public DtBulletRayResultCallback
{
   DtAllHitsRayResultCallback(
      DtIntersectionRecord::DtIntersectionType irtFlag, short int filterMask);
      
   virtual btScalar addSingleResult(btCollisionWorld::LocalRayResult& rayResult,bool normalInWorldSpace);

   std::vector<RayResultRecord> myRecords;
};

struct DT_DLL_vantageTerrainImplementation DtClosestRayResultCallback
   : public DtBulletRayResultCallback
{
   DtClosestRayResultCallback(
      DtIntersectionRecord::DtIntersectionType irtFlag, short int filterMask);

   virtual btScalar addSingleResult(
      btCollisionWorld::LocalRayResult& rayResult,bool normalInWorldSpace);

   boost::optional<RayResultRecord> myResult;
};

struct DT_DLL_vantageTerrainImplementation DtIntersectionExistsCallback
   : public DtBulletRayResultCallback
{
   explicit DtIntersectionExistsCallback(short int filterMask);

   virtual bool needsCollision(btBroadphaseProxy* proxy0) const;

   virtual btScalar addSingleResult(
      btCollisionWorld::LocalRayResult& rayResult, bool normalInWorldSpace);
};

bool DT_DLL_vantageTerrainImplementation DtIntersectRaySphere2(const DtPoint& rayStartPoint,
   const DtVector& rayDirectionNonNormalized,
   const DtSphere& sphere,
   double& t);

Coordinate_System* createVrfCoordinateSystem(const makVrv::DtCoordinateSystem& coodSysIn);

void getBasisAndOrigin(osg::Matrix& matrix, btMatrix3x3& basisA, btVector3& origin, osg::Vec3d& scale, bool& scaled);