Register    Login    Forum    Search    FAQ

Board index » Everything




Post new topic Reply to topic  [ 1 post ] 
Author Message
 Post Posted: December 14th, 2014, 8:15 pm 
 

Joined: November 30th, 2013, 7:40 pm
Posts: 562
Location: Merville, British Columbia Canada
Here is some work i've done for 3d i hope some will find useful :)
This uses DirectX (d3dx9.h)
Code:
#ifndef EPSILON
#define EPSILON  (float)1.0e-6
#endif
struct _PickRayPtData
{
   D3DXVECTOR3 vNormal;
   D3DXVECTOR3 vIntersectPt;
   FLOAT       fDistanceSq;
};
struct _PickRayDesc
{
   D3DXVECTOR3 vOrigin;
   D3DXVECTOR3 vDirection;
   _PickRayPtData Pts[2];
   // object ray intersected
   class TObject* Object = NULL;
   BOOL        bHit;
};
typedef _PickRayDesc PickRay_Desc, *LPPickRay_Desc;
//==========================================================
struct _AABB
{
   float       fWidth;
   float       fHeight;
   float       fDepth;
   D3DXVECTOR3 vMin;
   D3DXVECTOR3 vMax;
   D3DXVECTOR3 vCenter;
   
   bool PointInBox(D3DXVECTOR3 Pt)
   {
      
      return Pt.x > vMin.x && Pt.y > vMin.y && Pt.z > vMin.z &&
         Pt.x < vMax.x && Pt.y < vMax.y && Pt.z < vMax.z;
   }
   static _AABB Make( D3DXVECTOR3 center, float width,float height,float depth)
   {
      
      _AABB AB;
      AB.fWidth = width;
      AB.fHeight = height;
      AB.fDepth = depth;
      AB.vMin.x = center.x - width ;
      AB.vMin.y = center.y - height ;
      AB.vMin.z = center.z - depth ;
      AB.vMax.x = center.x + width ;
      AB.vMax.y = center.y + height ;
      AB.vMax.z = center.z + depth ;
      AB.vCenter = center;
      return AB;
   }
   bool Overlaps(const _AABB& tBox2)
   {

      //Check if Box1's max is greater than Box2's min and Box1's min is less than Box2's max
      return(vMax.x > tBox2.vMin.x &&
         vMin.x < tBox2.vMax.x &&
         vMax.y > tBox2.vMin.y &&
         vMin.y < tBox2.vMax.y &&
         vMax.z > tBox2.vMin.z &&
         vMin.z < tBox2.vMax.z);

      //If not, it will return false

   }

};
typedef _AABB D3_AABB, *LPD3_AABB;

//=========================================================
struct _Sphere
{
   D3DXVECTOR3 vCenter;
   float fRadius;
   
   static _Sphere Make(D3DXVECTOR3 center, float radius)
   {
      _Sphere s;
      s.vCenter = center;
      s.fRadius = radius;
      return s;
   }
   /////////////
   //check if a point is in sphere
   ////////////
   bool PointIn(D3DXVECTOR3 pt)
   {
      D3DXVECTOR3 vecDist(vCenter - pt);
      float fDistSq(D3DXVec3Dot(&vecDist, &vecDist));

      //Calculate if the squared distance between the sphere's center and the point
      //is less than the squared radius of the sphere
      if (fDistSq < (fRadius * fRadius))
      {
         return true;
      }

      //If not, return false
      return false;
   }
   //////////
   // check if ray intersects sphere (no data returned)
   // use for quick check
   /////////
   bool RayIntersectSphere(_PickRayDesc desc)
   {
      //First, let's see if the point is inside the sphere. If so, return true
      if (PointIn(desc.vOrigin))
         return true;

      //Create a vector from the ray's start to the sphere's center
      D3DXVECTOR3 vecV1(vCenter - desc.vOrigin);

      //Project this vector onto the ray's direction vector
      float fD = D3DXVec3Dot(&vecV1, &desc.vDirection);

      //If the ray is pointing away
      if (fD < 0.0f)
         return false;

      //Calculate the closest point to the sphere
      D3DXVECTOR3 vecClosestPoint(desc.vOrigin + (desc.vDirection * fD));

      //Check if that point is inside the sphere
      return (PointIn(vecClosestPoint));

   }
   /////////////
   //Get entry and exit points of sphere
   //via pick ray and filling PickRay_Desc data
   //caluclates normals of intersect points
   ////////////
   void GetRayIntersectSphereData(_PickRayDesc& desc)
   {
      D3DXVECTOR3 vantage = desc.vOrigin;
      D3DXVECTOR3 direction = desc.vDirection;
         // Calculate the coefficients of the quadratic equation
         //     au^2 + bu + c = 0.
         // Solving this equation gives us the value of u
         // for any intersection points.
          const D3DXVECTOR3 displacement = vantage - vCenter;
         const double a = D3DXVec3LengthSq(&direction);
         const double b = 2.0 * D3DXVec3Dot(&direction, &displacement);
         const double c = D3DXVec3LengthSq(&displacement) - fRadius*fRadius;
         
         // Calculate the radicand of the quadratic equation solution formula.
         // The radicand must be non-negative for there to be real solutions.
         const double radicand = b*b - 4.0*a*c;
         if (radicand >= 0.0)
         {
            // There are two intersection solutions, one involving
            // +sqrt(radicand), the other -sqrt(radicand).
            // through and through intersect
            desc.bHit = true;
            const double root = sqrt(radicand);
            const double denom = 2.0 * a;
            const double u[2] = {
               (-b + root) / denom,
               (-b - root) / denom
            };
            
            for (int i = 0; i < 2; ++i)
            {
               if (u[i] > EPSILON)
               {
                  
                  const D3DXVECTOR3 vantageToSurface = u[i] * direction;
                  desc.Pts[i].vIntersectPt = vantage + vantageToSurface;

                  // The normal vector to the surface of
                  // a sphere is outward from the center.
                  D3DXVec3Normalize(&desc.Pts[i].vNormal, &(desc.Pts[i].vIntersectPt - vCenter));
                  desc.Pts[i].fDistanceSq = D3DXVec3LengthSq(&vantageToSurface);
               }
            }
         }
         else
         {
            desc.bHit = false;
         }
                  
      }
   

};
typedef _Sphere D3_SPHERE, *LPD3_SPHERE;
//==========================================================
struct _Plane
{
   D3DXVECTOR3 pt0;
   D3DXVECTOR3 pt1;
   D3DXVECTOR3 pt2;
   D3DXVECTOR3 normal;
   static _Plane Make(D3DXVECTOR3 pt0, D3DXVECTOR3 pt1, D3DXVECTOR3 pt2)
   {
      _Plane p;
      p.pt0 = pt0;
      p.pt1 = pt1;
      p.pt2 = pt2;
      p.MakeNormal();
      return p;
   }
   D3DXVECTOR3 MakeNormal()
   {
      D3DXVECTOR3 Vector1 = { pt1 - pt0 };
      D3DXVECTOR3 Vector2 = { pt2 - pt0 };
      
      D3DXVec3Cross(&normal,&Vector1, &Vector2);
      D3DXVec3Normalize(&normal, &normal);
      return normal;
   }
   D3DXVECTOR3 Rebound(D3DXVECTOR3 impactVel)
   {
      return impactVel - 2 * D3DXVec3Dot(&impactVel, &normal) * normal;
   }
};

_________________
Curiosity killed the cat, satisfaction brought him back


Top 
 Profile  
Reply with quote  
Display posts from previous:  Sort by  
 
Post new topic Reply to topic  [ 1 post ] 

Board index » Everything


 
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot post attachments in this forum

Search for:
cron