---

AMath.cpp

Go to the documentation of this file.

/*
CS Senior Project 2003
Team : Leftfield
Project : ModernWarfare
Members :
- Russ Christensen              <rchriste@cs.utah.edu>
- Todd Smith                    <tcsmith@cs.utah.edu>
- Usit Duongsaa                 <duongsaa@cs.utah.edu>
Copyright 2003 Russ Christensen, Usit Duongsaa, and Todd Smith. All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 
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 RUSS CHRISTENSEN, USIT DUONGSAA, AND TODD SMITH ``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 RUSS, USIT, TODD OR OTHER CONTRIBUTORS 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.
*/


#include "AEngine.h"
#include "AState.h"
#include "AConstants.h"
#include "ADevice.h"
#include "ASharedFunc.h"


//------------------------------------------------------------------------------------
Vec3D math_translateScreenToWorldPlane( const Vec2D pt, FLOAT z )
{
        // Get screen space vector
        Vec3D v;
    v.x =  ( 2.0f*pt[0] - 1 ) / AS.camera_projMatrix._11;
    v.y = -( 2.0f*pt[1] - 1 ) / AS.camera_projMatrix._22;
    v.z =  1.0f;

        // Get the inverse view matrix
    D3DXMATRIX inv;
        D3DXMatrixInverse( &inv, NULL, &AS.camera_viewMatrix );
        
    // Transform to world space vector
        Vec3D pt1, pt2, dir;
    dir.x  = v.x*inv._11 + v.y*inv._21 + v.z*inv._31;
    dir.y  = v.x*inv._12 + v.y*inv._22 + v.z*inv._32;
    dir.z  = v.x*inv._13 + v.y*inv._23 + v.z*inv._33;
    pt1.x = inv._41;
    pt1.y = inv._42;
    pt1.z = inv._43;
        pt2 = pt1 + 10000.0f * dir;

        // construct a plane with specified height
        D3DXPLANE plane;
        Vec3D planePt(0,0,z), planeNormal(0,0,1);
        D3DXPlaneFromPointNormal( &plane, &planePt, &planeNormal );

        // find where the vector intersect with the plane
        Vec3D intersectPt;
        D3DXPlaneIntersectLine( &intersectPt, &plane, &pt1, &pt2 );

        return intersectPt;
}
//------------------------------------------------------------------------------------
Vec2D math_translateWorldToScreen( const Vec3D pt )
{       
        Vec3D scrPt;
        D3DXVec3TransformCoord( &scrPt, &pt, &AS.camera_world2projMatrix );
        if(scrPt.z > 1)                         // fix "off-screen line clipping bug"
        {
                scrPt.x = -scrPt.x;
                scrPt.y = -scrPt.y;
        }
        return Vec2D( 0.5f+0.5f*scrPt[0], 0.5f-0.5f*scrPt[1] );
}
//------------------------------------------------------------------------------------
Vec3D math_translateObjectToWorld( const Vec3D objPos, const Vec3D objDir, const Vec3D objPt )
{
        Matx matTrans, matTheta, matFinal;
        Vec3D result;

        D3DXMatrixTranslation( &matTrans, objPos[0], objPos[1], objPos[2] );
        D3DXMatrixRotationZ( &matTheta, D3DXToRadian(objDir[0]) );      
        matFinal = matTheta * matTrans;
        D3DXVec3TransformCoord( &result, &objPt, &matFinal );
        return result;
}
//------------------------------------------------------------------------------------
FLOAT math_dist2D( const Vec2D &a, const Vec2D &b )
{
        Vec2D delta = a-b;
        return D3DXVec2Length(&delta);
}
//------------------------------------------------------------------------------------
FLOAT math_dist3D( const Vec3D &a, const Vec3D &b )
{
        Vec3D delta = a-b;
        return D3DXVec3Length(&delta);
}
//------------------------------------------------------------------------------------
FLOAT math_distPlanar3D( const Vec3D &a, const Vec3D &b )
{
        Vec3D delta = a-b;
        return sqrtf( delta.x*delta.x + delta.y*delta.y );
}
//------------------------------------------------------------------------------------
FLOAT math_clipAngle( FLOAT degree )
{
        if( degree < 0.0f )             return degree + 360.0f;
        if( degree >= 360.0f )  return degree - 360.0f;
        return degree;
}
//------------------------------------------------------------------------------------
FLOAT math_getDir( const Vec3D &from, const Vec3D &to )
{
        Vec3D targetVec = to - from;
        return math_clipAngle( 90-D3DXToDegree( atan2f( targetVec.x, targetVec.y ) ) );
}
//------------------------------------------------------------------------------------
FLOAT math_deltaDir( const FLOAT currentDir, const FLOAT newDir )
{
        FLOAT delta;
        if(newDir>currentDir)
        {
                delta = newDir - currentDir;
                if(delta>180.0f) delta = delta - 360.0f;
        }
        else
        {
                delta = newDir - currentDir;
                if(delta<-180.0f) delta = 360.0f - delta;
        }
        return delta;
}
//------------------------------------------------------------------------------------

---