378 lines
9.5 KiB
C++
378 lines
9.5 KiB
C++
#include "cTracer.h"
|
|
#include "cWorld.h"
|
|
|
|
#include "Vector3f.h"
|
|
#include "Vector3i.h"
|
|
#include "Vector3d.h"
|
|
|
|
#include "BlockID.h"
|
|
#include "cMCLogger.h"
|
|
#include "cEntity.h"
|
|
|
|
#ifndef _WIN32
|
|
#include <stdlib.h> // abs()
|
|
#endif
|
|
|
|
cTracer::cTracer(cWorld* a_World)
|
|
: m_World( a_World )
|
|
{
|
|
m_NormalTable[0] = new Vector3f(-1, 0, 0);
|
|
m_NormalTable[1] = new Vector3f( 0, 0,-1);
|
|
m_NormalTable[2] = new Vector3f( 1, 0, 0);
|
|
m_NormalTable[3] = new Vector3f( 0, 0, 1);
|
|
m_NormalTable[4] = new Vector3f( 0, 1, 0);
|
|
m_NormalTable[5] = new Vector3f( 0,-1, 0);
|
|
|
|
DotPos = new Vector3f();
|
|
BoxOffset = new Vector3f();
|
|
BlockHitPosition = new Vector3f();
|
|
HitNormal = new Vector3f();
|
|
RealHit = new Vector3f();
|
|
|
|
|
|
dir = new Vector3f();
|
|
tDelta = new Vector3f();
|
|
pos = new Vector3i();
|
|
end1 = new Vector3i();
|
|
step = new Vector3i();
|
|
tMax = new Vector3f();
|
|
}
|
|
|
|
cTracer::~cTracer()
|
|
{
|
|
for( int i = 0; i < 6; ++i )
|
|
{
|
|
delete m_NormalTable[i];
|
|
m_NormalTable[i] = 0;
|
|
}
|
|
|
|
delete DotPos; DotPos = 0;
|
|
delete BoxOffset; BoxOffset = 0;
|
|
delete BlockHitPosition; BlockHitPosition = 0;
|
|
delete HitNormal; HitNormal = 0;
|
|
delete RealHit; RealHit = 0;
|
|
|
|
delete dir; dir = 0;
|
|
delete tDelta; tDelta = 0;
|
|
delete pos; pos = 0;
|
|
delete end1; end1 = 0;
|
|
delete step; step = 0;
|
|
delete tMax; tMax = 0;
|
|
}
|
|
|
|
float cTracer::SigNum( float a_Num )
|
|
{
|
|
if (a_Num < 0.f) return -1.f;
|
|
if (a_Num > 0.f) return 1.f;
|
|
return 0.f;
|
|
}
|
|
|
|
void cTracer::SetValues( const Vector3f & a_Start, const Vector3f & a_Direction )
|
|
{
|
|
// calculate the direction of the ray (linear algebra)
|
|
*dir = a_Direction;
|
|
|
|
// decide which direction to start walking in
|
|
step->x = (int) SigNum(dir->x);
|
|
step->y = (int) SigNum(dir->y);
|
|
step->z = (int) SigNum(dir->z);
|
|
|
|
// normalize the direction vector
|
|
if( dir->SqrLength() > 0.f ) dir->Normalize();
|
|
|
|
// how far we must move in the ray direction before
|
|
// we encounter a new voxel in x-direction
|
|
// same but y-direction
|
|
if( dir->x != 0.f ) tDelta->x = 1/fabs(dir->x);
|
|
else tDelta->x = 0;
|
|
if( dir->y != 0.f ) tDelta->y = 1/fabs(dir->y);
|
|
else tDelta->y = 0;
|
|
if( dir->z != 0.f ) tDelta->z = 1/fabs(dir->z);
|
|
else tDelta->z = 0;
|
|
|
|
// start voxel coordinates
|
|
// use your
|
|
// transformer
|
|
// function here
|
|
pos->x = (int)floorf(a_Start.x);
|
|
pos->y = (int)floorf(a_Start.y);
|
|
pos->z = (int)floorf(a_Start.z);
|
|
|
|
// calculate distance to first intersection in the voxel we start from
|
|
if(dir->x < 0)
|
|
{
|
|
tMax->x = ((float)pos->x - a_Start.x) / dir->x;
|
|
}
|
|
else
|
|
{
|
|
tMax->x = (((float)pos->x + 1) - a_Start.x) / dir->x;
|
|
}
|
|
|
|
if(dir->y < 0)
|
|
{
|
|
tMax->y = ((float)pos->y - a_Start.y) / dir->y;
|
|
}
|
|
else
|
|
{
|
|
tMax->y = (((float)pos->y + 1) - a_Start.y) / dir->y;
|
|
}
|
|
|
|
if(dir->z < 0)
|
|
{
|
|
tMax->z = ((float)pos->z - a_Start.z) / dir->z;
|
|
}
|
|
else
|
|
{
|
|
tMax->z = (((float)pos->z + 1) - a_Start.z) / dir->z;
|
|
}
|
|
}
|
|
|
|
int cTracer::Trace( const Vector3f & a_Start, const Vector3f & a_Direction, int a_Distance)
|
|
{
|
|
SetValues( a_Start, a_Direction );
|
|
|
|
const Vector3f End = a_Start + ((*dir) * (float)a_Distance);
|
|
|
|
// end voxel coordinates
|
|
end1->x = (int)floorf(End.x);
|
|
end1->y = (int)floorf(End.y);
|
|
end1->z = (int)floorf(End.z);
|
|
|
|
// check if first is occupied
|
|
if( pos->Equals( end1 ) )
|
|
{
|
|
LOG("WARNING: cTracer: Start and end in same block");
|
|
return 0;
|
|
}
|
|
|
|
bool reachedX = false, reachedY = false, reachedZ = false;
|
|
|
|
int Iterations = 0;
|
|
while ( Iterations < a_Distance )
|
|
{
|
|
Iterations++;
|
|
if(tMax->x < tMax->y && tMax->x < tMax->z)
|
|
{
|
|
tMax->x += tDelta->x;
|
|
pos->x += step->x;
|
|
}
|
|
else if(tMax->y < tMax->z)
|
|
{
|
|
tMax->y += tDelta->y;
|
|
pos->y += step->y;
|
|
}
|
|
else
|
|
{
|
|
tMax->z += tDelta->z;
|
|
pos->z += step->z;
|
|
}
|
|
|
|
if(step->x > 0.0f)
|
|
{
|
|
if(pos->x >= end1->x)
|
|
{
|
|
reachedX = true;
|
|
}
|
|
}
|
|
else if(pos->x <= end1->x)
|
|
{
|
|
reachedX = true;
|
|
}
|
|
|
|
if(step->y > 0.0f)
|
|
{
|
|
if(pos->y >= end1->y)
|
|
{
|
|
reachedY = true;
|
|
}
|
|
}
|
|
else if(pos->y <= end1->y)
|
|
{
|
|
reachedY = true;
|
|
}
|
|
|
|
if(step->z > 0.0f)
|
|
{
|
|
if(pos->z >= end1->z)
|
|
{
|
|
reachedZ = true;
|
|
}
|
|
}
|
|
else if(pos->z <= end1->z)
|
|
{
|
|
reachedZ = true;
|
|
}
|
|
|
|
if (reachedX && reachedY && reachedZ)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
char BlockID = m_World->GetBlock( pos->x, pos->y, pos->z );
|
|
if ( BlockID != E_BLOCK_AIR )
|
|
{
|
|
*BlockHitPosition = pos;
|
|
int Normal = GetHitNormal(a_Start, End, *pos );
|
|
if(Normal > 0)
|
|
{
|
|
*HitNormal = *m_NormalTable[Normal-1];
|
|
}
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// return 1 = hit, other is not hit
|
|
int LinesCross(float x0,float y0,float x1,float y1,float x2,float y2,float x3,float y3)
|
|
{
|
|
//float linx, liny;
|
|
|
|
float d=(x1-x0)*(y3-y2)-(y1-y0)*(x3-x2);
|
|
if (abs(d)<0.001) {return 0;}
|
|
float AB=((y0-y2)*(x3-x2)-(x0-x2)*(y3-y2))/d;
|
|
if (AB>=0.0 && AB<=1.0)
|
|
{
|
|
float CD=((y0-y2)*(x1-x0)-(x0-x2)*(y1-y0))/d;
|
|
if (CD>=0.0 && CD<=1.0)
|
|
{
|
|
//linx=x0+AB*(x1-x0);
|
|
//liny=y0+AB*(y1-y0);
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// intersect3D_SegmentPlane(): intersect a segment and a plane
|
|
// Input: a_Ray = a segment, and a_Plane = a plane = {Point V0; Vector n;}
|
|
// Output: *I0 = the intersect point (when it exists)
|
|
// Return: 0 = disjoint (no intersection)
|
|
// 1 = intersection in the unique point *I0
|
|
// 2 = the segment lies in the plane
|
|
int cTracer::intersect3D_SegmentPlane( const Vector3f & a_Origin, const Vector3f & a_End, const Vector3f & a_PlanePos, const Vector3f & a_PlaneNormal )
|
|
{
|
|
Vector3f u = a_End - a_Origin;//a_Ray.P1 - S.P0;
|
|
Vector3f w = a_Origin - a_PlanePos;//S.P0 - Pn.V0;
|
|
|
|
float D = a_PlaneNormal.Dot( u );//dot(Pn.n, u);
|
|
float N = -(a_PlaneNormal.Dot( w ) );//-dot(a_Plane.n, w);
|
|
|
|
const float EPSILON = 0.0001f;
|
|
if (fabs(D) < EPSILON) { // segment is parallel to plane
|
|
if (N == 0) // segment lies in plane
|
|
return 2;
|
|
return 0; // no intersection
|
|
}
|
|
// they are not parallel
|
|
// compute intersect param
|
|
float sI = N / D;
|
|
if (sI < 0 || sI > 1)
|
|
return 0; // no intersection
|
|
|
|
//Vector3f I ( a_Ray->GetOrigin() + sI * u );//S.P0 + sI * u; // compute segment intersect point
|
|
*RealHit = a_Origin + u * sI;
|
|
return 1;
|
|
}
|
|
|
|
int cTracer::GetHitNormal(const Vector3f & start, const Vector3f & end, const Vector3i & a_BlockPos)
|
|
{
|
|
Vector3i SmallBlockPos = a_BlockPos;
|
|
char BlockID = m_World->GetBlock( a_BlockPos.x, a_BlockPos.y, a_BlockPos.z );
|
|
|
|
if( BlockID == E_BLOCK_AIR )
|
|
return 0;
|
|
|
|
Vector3f BlockPos;
|
|
BlockPos = Vector3f(SmallBlockPos);
|
|
|
|
Vector3f Look = (end - start);
|
|
Look.Normalize();
|
|
|
|
float dot = Look.Dot( Vector3f(-1, 0, 0) ); // first face normal is x -1
|
|
if(dot < 0)
|
|
{
|
|
int Lines = LinesCross( start.x, start.y, end.x, end.y, BlockPos.x, BlockPos.y, BlockPos.x, BlockPos.y + 1 );
|
|
if(Lines == 1)
|
|
{
|
|
Lines = LinesCross( start.x, start.z, end.x, end.z, BlockPos.x, BlockPos.z, BlockPos.x, BlockPos.z + 1 );
|
|
if(Lines == 1)
|
|
{
|
|
intersect3D_SegmentPlane( start, end, BlockPos, Vector3f(-1, 0, 0) );
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
dot = Look.Dot( Vector3f(0, 0, -1) ); // second face normal is z -1
|
|
if(dot < 0)
|
|
{
|
|
int Lines = LinesCross( start.z, start.y, end.z, end.y, BlockPos.z, BlockPos.y, BlockPos.z, BlockPos.y + 1 );
|
|
if(Lines == 1)
|
|
{
|
|
Lines = LinesCross( start.z, start.x, end.z, end.x, BlockPos.z, BlockPos.x, BlockPos.z, BlockPos.x + 1 );
|
|
if(Lines == 1)
|
|
{
|
|
intersect3D_SegmentPlane( start, end, BlockPos, Vector3f(0, 0, -1) );
|
|
return 2;
|
|
}
|
|
}
|
|
}
|
|
dot = Look.Dot( Vector3f(1, 0, 0) ); // third face normal is x 1
|
|
if(dot < 0)
|
|
{
|
|
int Lines = LinesCross( start.x, start.y, end.x, end.y, BlockPos.x + 1, BlockPos.y, BlockPos.x + 1, BlockPos.y + 1 );
|
|
if(Lines == 1)
|
|
{
|
|
Lines = LinesCross( start.x, start.z, end.x, end.z, BlockPos.x + 1, BlockPos.z, BlockPos.x + 1, BlockPos.z + 1 );
|
|
if(Lines == 1)
|
|
{
|
|
intersect3D_SegmentPlane( start, end, BlockPos + Vector3f(1, 0, 0), Vector3f(1, 0, 0) );
|
|
return 3;
|
|
}
|
|
}
|
|
}
|
|
dot = Look.Dot( Vector3f(0, 0, 1) ); // fourth face normal is z 1
|
|
if(dot < 0)
|
|
{
|
|
int Lines = LinesCross( start.z, start.y, end.z, end.y, BlockPos.z + 1, BlockPos.y, BlockPos.z + 1, BlockPos.y + 1 );
|
|
if(Lines == 1)
|
|
{
|
|
Lines = LinesCross( start.z, start.x, end.z, end.x, BlockPos.z + 1, BlockPos.x, BlockPos.z + 1, BlockPos.x + 1 );
|
|
if(Lines == 1)
|
|
{
|
|
intersect3D_SegmentPlane( start, end, BlockPos + Vector3f(0, 0, 1), Vector3f(0, 0, 1) );
|
|
return 4;
|
|
}
|
|
}
|
|
}
|
|
dot = Look.Dot( Vector3f(0, 1, 0) ); // fifth face normal is y 1
|
|
if(dot < 0)
|
|
{
|
|
int Lines = LinesCross( start.y, start.x, end.y, end.x, BlockPos.y + 1, BlockPos.x, BlockPos.y + 1, BlockPos.x + 1 );
|
|
if(Lines == 1)
|
|
{
|
|
Lines = LinesCross( start.y, start.z, end.y, end.z, BlockPos.y + 1, BlockPos.z, BlockPos.y + 1, BlockPos.z + 1 );
|
|
if(Lines == 1)
|
|
{
|
|
intersect3D_SegmentPlane( start, end, BlockPos + Vector3f(0, 1, 0), Vector3f(0, 1, 0) );
|
|
return 5;
|
|
}
|
|
}
|
|
}
|
|
dot = Look.Dot( Vector3f(0, -1, 0) ); // sixth face normal is y -1
|
|
if(dot < 0)
|
|
{
|
|
int Lines = LinesCross( start.y, start.x, end.y, end.x, BlockPos.y, BlockPos.x, BlockPos.y, BlockPos.x + 1 );
|
|
if(Lines == 1)
|
|
{
|
|
Lines = LinesCross( start.y, start.z, end.y, end.z, BlockPos.y, BlockPos.z, BlockPos.y, BlockPos.z + 1 );
|
|
if(Lines == 1)
|
|
{
|
|
intersect3D_SegmentPlane( start, end, BlockPos, Vector3f(0, -1, 0) );
|
|
return 6;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|