laCollisionDomain.cpp

/*

Jump'n'Run Engine
http://www.atanaslaskov.com/jnr/

BSD LICENSE
Copyright (c) 2007-2013, Atanas Laskov
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. 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.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 ATANAS LASKOV 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.

*/

//
// FILE: laCollisionDomain.cpp
//
// Copyright (C) 2007-2013 Atanas Laskov, <latanas@gmail.com>
//
#include "stdafx.h"
#include "Core.h"

laCollisionDomain::laCollisionDomain(void)
{
    _nLineCnt = 0;
    _pNextDomain = NULL;
}

/*laCollisionDomain::~laCollisionDomain(void)
{
}*/

laPoint3 laCollisionDomain::normal(laPoint3 a, laPoint3 b, laPoint3 c)
{
    laPoint3 v1 = a-b;
    laPoint3 v2 = a-c;
    laPoint3 normal;

    normal[0] = v1.y()*v2.z() - v1.z()*v2.y();
    normal[1] = v1.z()*v2.x() - v1.x()*v2.z();
    normal[2] = v1.x()*v2.y() - v1.y()*v2.x();

    double len = normal.lenght()*3.0;
    normal = laPoint3(normal/len)*M_UNIT;

    return normal;
}

// Remove empty domains in the chain
//
void laCollisionDomain::optimize()
{
    laCollisionDomain *pNext    = _pNextDomain;

    while( pNext && (pNext->countLines() == 0) )
        pNext = pNext->nextDomain();
    _pNextDomain = pNext;

    if(pNext) _pNextDomain->optimize();
}

void laCollisionDomain::addLine(laPoint3 a, laPoint3 b, laPoint3 normal, rpgTrap* pTrap)
{
    ASSERT( (_nLineCnt+1) < M_MAX_COLLISION_DOMAIN_SZ, "Collision domain exceeds maximal size" );

    laLine2 ln(a, b);

    _arLines[_nLineCnt]     = ln;
    _arNormals[_nLineCnt]   = normal;
    _arTrap[_nLineCnt]      = pTrap;
    _nLineCnt++;
}


void laCollisionDomain::addTriangle(const laPoint3 &a, const laPoint3 &b, const laPoint3 &c, rpgTrap* pTrap)
{
    const double CollisionPathZ = M_UNIT/2.0;
    const double SmallDistance  = M_UNIT/20.0;

    laPoint3 arTrianglePoints[3];
    int arSide[3];

    unsigned arLinePointIndexs[3];
    unsigned nLinePoints=0;
    unsigned i;

    arTrianglePoints[0] = _offset + a;
    arTrianglePoints[1] = _offset + b;
    arTrianglePoints[2] = _offset + c;

    //arTrianglePoints[0].snap(SmallDistance);
    //arTrianglePoints[1].snap(SmallDistance);
    //arTrianglePoints[2].snap(SmallDistance);

    //Analyse vertex positions in relation to the collision track
    //
    for(i=0; i<3; i++)
    {
        if( M_ABS(arTrianglePoints[i].z()-CollisionPathZ) <= SmallDistance  ) //vertex on the collision track
        {
            arSide[i] = 0;
            arLinePointIndexs[nLinePoints++] = i;
        }
        else if(arTrianglePoints[i].z() < CollisionPathZ) arSide[i] = -1;       //vertex in the "negative" side
        else arSide[i] = 1;                                                 //vertex in the "positive" side
    }

    //If all vertex lie on the same side of the collision track there is no intersection so we ignore this triangle
    if( M_ABS(arSide[0]+arSide[1]+arSide[2])==3 ) return;

    //If all vertex lie on the collision track itself this is some sort of invalid triangle
    if( nLinePoints == 3 ) return;

    //If an edge lies on the collision track just add it
    if(nLinePoints == 2){
        addLine(arTrianglePoints[arLinePointIndexs[0]],
            arTrianglePoints[arLinePointIndexs[1]],
            normal(a,b,c), pTrap);
        return;
    }

    //If there is a single point of the triangle  that lies on the collision track
    if(nLinePoints==1)
    {
        //The two remaining points are on the same side ignore this triangle
        if( (arSide[0]+arSide[1]+arSide[2]) !=0 ) return;

        //Otherwise, find the crossing of the edge between them with the collision track
        if(arLinePointIndexs[0]==0)
        {
            arLinePointIndexs[1] = 1;
            arLinePointIndexs[2] = 2;
        }
        else if(arLinePointIndexs[0]==1)
        {
            arLinePointIndexs[1] = 0;
            arLinePointIndexs[2] = 2;
        }
        else if(arLinePointIndexs[0]==2)
        {
            arLinePointIndexs[1] = 0;
            arLinePointIndexs[2] = 1;
        }

        //Extract the edge end-points
        laPoint3 track_pt  = arTrianglePoints[arLinePointIndexs[0]];
        laPoint3 pt1       = arTrianglePoints[arLinePointIndexs[1]];
        laPoint3 pt2       = arTrianglePoints[arLinePointIndexs[2]];

        //The laLine2 class is 2D and it can not hanndle a 3D intersection. That's
        //why we use two proections to achive the same result.

        //Build a XZ proection
        laLine2 edge_xz(laPoint3(pt1.x(), pt1.z()), laPoint3(pt2.x(), pt2.z()));

        double k = edge_xz.getK_atY(CollisionPathZ); //this is really "GetKAtZ" because in this proection  Y=>Z
        double x = edge_xz.getX(k);

        //Build a YZ proection
        laLine2 edge_yz(laPoint3(pt1.y(), pt1.z()), laPoint3(pt2.y(), pt2.z()));
        k = edge_yz.getK_atY(CollisionPathZ); //this is really "GetKAtZ" bacause in this proection Y=>Z
        double y = edge_yz.getX(k);

        //Add the line
        addLine(track_pt, laPoint3(x, y), normal(a,b,c), pTrap);
        return;
    }

    //If we are here, then there are no points whatoever that lie
    //near the collision track. In that case two of the points are
    //together on one side and there is a single point on the other. The
    //two edges that come out of that singe point intersect the collision
    //path so we must identify them.

    //If 0 and 1 are on the same side
    if( arSide[0]+arSide[1] != 0)
    {
        arLinePointIndexs[0] = 2;   //then 2 is alone
        arLinePointIndexs[1] = 0;   //0 is an end-point of a crossing edge
        arLinePointIndexs[2] = 1;   //1 is an end-point of a crossing edge
    }
    //If 0 and 2 are on the same side
    else if( arSide[0]+arSide[2] != 0)
    {
        arLinePointIndexs[0] = 1;   //then 1 is alone
        arLinePointIndexs[1] = 0;   //0 is an end-point of a crossing edge
        arLinePointIndexs[2] = 2;   //2 is an end-point of a crossing edge
    }
    //If 1 and 2 are on the same side
    else if( arSide[1]+arSide[2] != 0)
    {
        arLinePointIndexs[0] = 0;   //then 0 is alone
        arLinePointIndexs[1] = 1;   //1 is an end-point of a crossing edge
        arLinePointIndexs[2] = 2;   //2 is an end-point of a crossing edge
    }

    //Now that we know which is the lone vertex, we can proceed
    //to finding the crossings at its edges

    //Extract the edge end-points
    laPoint3 lone  = arTrianglePoints[arLinePointIndexs[0]];
    laPoint3 pt1   = arTrianglePoints[arLinePointIndexs[1]];
    laPoint3 pt2   = arTrianglePoints[arLinePointIndexs[2]];

    //The laLine2 class is 2D and it cannot hanndle a 3D intersection;
    //We use two 2D projections to achive the same result.

    //Build a XZ projection
    laLine2 edge1_xz(laPoint3(lone.x(), lone.z()), laPoint3(pt1.x(), pt1.z()));
    laLine2 edge2_xz(laPoint3(lone.x(), lone.z()), laPoint3(pt2.x(), pt2.z()));

    double k1 = edge1_xz.getK_atY(CollisionPathZ); //this is really "GetKAtZ" because in this proection  Y=>Z
    double k2 = edge2_xz.getK_atY(CollisionPathZ);

    double x1 = edge1_xz.getX(k1);
    double x2 = edge2_xz.getX(k2);

    //Build a YZ projection
    laLine2 edge1_yz(laPoint3(lone.y(), lone.z()), laPoint3(pt1.y(), pt1.z()));
    laLine2 edge2_yz(laPoint3(lone.y(), lone.z()), laPoint3(pt2.y(), pt2.z()));

    k1 = edge1_yz.getK_atY(CollisionPathZ); //this is really "GetKAtZ" bacause in this proection Y=>Z
    k2 = edge2_yz.getK_atY(CollisionPathZ);

    double y1 = edge1_yz.getX(k1);
    double y2 = edge2_yz.getX(k2);

    //Add the line
    addLine(laPoint3(x1, y1), laPoint3(x2, y2), normal(a,b,c), pTrap);

}

void laCollisionDomain::updateBounds()
{
    _rectBounds.reset();
    for(unsigned i=0; i<_nLineCnt; i++) _rectBounds.add( _arLines[i] );
}

// Draw lines and normals in the domain
//
void laCollisionDomain::draw(laRenderer* r, laPoint3 ptBasePos)
{
    //const double dCollisionPathZ = M_UNIT/2.0;

    /*r->modeLight(M_FALSE);
    r->modeTexture(M_FALSE);
    r->modeDepthBuffer(M_FALSE);*/


    for(unsigned i=0; i<_nLineCnt; i++)
    {
        laLine2 ln(_arLines[i].origin - (laPoint2)_offset, _arLines[i].origin -  (laPoint2)_offset + _arLines[i].vector);
        laLine2 ln_normal(ln.origin + ln.vector*0.5, ln.origin + ln.vector*0.5 + _arNormals[i]*0.5);

        r->styleLine(2);
        r->styleSet(laColor(255,0,0));
        ln.draw(r, (laPoint2)ptBasePos);

        r->styleLine(1);
        r->styleSet(laColor(255,0,0));
        ln_normal.draw(r, (laPoint2)ptBasePos);
    }

    /*r->modeLight(M_TRUE);
    r->modeTexture(M_TRUE);
    r->styleSet(laColor(255,255,255));
    r->modeDepthBuffer(M_TRUE);*/
}