id-software/Wolf3D-iOS
1
0
Fork 0
mirror of https://github.com/id-Software/Wolf3D-iOS.git synced 2026-03-20 08:59:51 +01:00
Code Issues Packages Projects Releases Wiki Activity

Source release of Wolfenstein 3D Classic Platinum for iOS, 1.0

Browse Source
This commit is contained in:
Travis Bradshaw
2012-01-31 16:46:52 -06:00
commit e20e553baf
1001 changed files with 54065 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

125
wolf3d/newCode/env/vector.h vendored Normal file
View File

@@ -0,0 +1,125 @@
/*
Copyright (C) 2005 Michael Liebscher <johnnycanuck@users.sourceforge.net>
Copyright (C) 1997-2001 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*
* vector.h: 2D and 3D vector math routines.
*
* Author: Michael Liebscher <johnnycanuck@users.sourceforge.net>
*
* Acknowledgement:
* Portion of this code was derived from Quake II, and was originally
* written by Id Software, Inc.
*
*/
#ifndef __VECTOR_H__
#define __VECTOR_H__
typedef float vec_t;
typedef vec_t vec2_t[ 2 ];
typedef vec_t vec3_t[ 3 ];
typedef vec_t vec4_t[ 4 ];
typedef vec_t vec5_t[ 5 ];
extern vec3_t vec3_origin;
/////////////////////////////////////////////////////////////////////
//
// 3D Vector routines
//
/////////////////////////////////////////////////////////////////////
#define vectorClear( a ) ( (a)[ 0 ] = (a)[ 1 ] = (a)[ 2 ] = 0 )
#define vectorNegate( a, b ) ( (b)[ 0 ] = (-a)[ 0 ], (b)[ 1 ] = (-a)[ 1 ], (b)[ 2 ] = (-a)[ 2 ] )
#define vectorSet( v, x, y, z ) ( (v)[ 0 ] = ( x ), (v)[ 1 ] = ( y ), (v)[ 2 ] = ( z ) )
#define vectorInverse( a ) ( (a)[ 0 ] = (-a)[ 0 ], (a)[ 1 ] = (-a)[ 1 ], (a)[ 2 ] = (-a)[ 2 ] )
#if 1
#define DotProduct( x, y ) ( (x)[ 0 ] * (y)[ 0 ] + (x)[ 1 ] * (y)[ 1 ] + (x)[ 2 ] * (y)[ 2 ] )
#define vectorSubtract( a, b, c ) ( (c)[ 0 ] = (a)[ 0 ] - (b)[ 0 ], (c)[ 1 ] = (a)[ 1 ] - (b)[ 1 ], (c)[ 2 ] = (a)[ 2 ] - (b)[ 2 ] )
#define vectorAdd( a, b, c ) ( (c)[ 0 ] = (a)[ 0 ] + (b)[ 0 ], (c)[ 1 ] = (a)[ 1 ] + (b)[ 1 ], (c)[ 2 ] = (a)[ 2 ] + (b)[ 2 ] )
#define vectorCopy( a, b ) ( (b)[ 0 ] = (a)[ 0 ], (b)[ 1 ] = (a)[ 1 ], (b)[ 2 ] = (a)[ 2 ] )
#define vectorScale( v, s, o ) ( (o)[ 0 ] = (v)[ 0 ] * (s),(o)[ 1 ] = (v)[ 1 ] * (s), (o)[ 2 ] = (v)[ 2 ] * (s) )
#define vectorMA( v, s, b, o ) ( (o)[ 0 ] = (v)[ 0 ] + (b)[ 0 ]*(s),(o)[ 1 ] = (v)[ 1 ] + (b)[ 1 ] * (s),(o)[ 2 ] = (v)[ 2 ] + (b)[ 2 ] * (s) )
#else
/* just in case you don't want to use the macros */
#define DotProduct( x, y ) _vectorDotProduct( x, y )
#define vectorSubtract( a, b, c ) _vectorSubtract( a, b, c )
#define vectorAdd( a, b, c ) _vectorAdd( a, b, c )
#define vectorCopy( a, b ) _vectorCopy( a, b )
#define vectorScale( v, s, o ) _vectorScale( v, s, o )
#define vectorMA( v, s, b, o ) _vectorMA( v, s, b, o )
#endif
extern void vectorCrossProduct( const vec3_t v1, const vec3_t v2, vec3_t cross );
extern int vectorCompare( const vec3_t v1, const vec3_t v2 );
extern vec_t vectorLength( const vec3_t v );
extern vec_t (*pfVectorNormalize)( vec3_t vec );
extern void angleVectors( const vec3_t angles, vec3_t forward, vec3_t right, vec3_t up );
extern void RotatePointAroundVector( vec3_t dst, const vec3_t dir, const vec3_t point, float degrees );
extern void PerpendicularVector( vec3_t dst, const vec3_t src );
extern void ProjectPointOnPlane( vec3_t dst, const vec3_t p, const vec3_t normal );
extern void AddPointToBounds( vec3_t v, vec3_t mins, vec3_t maxs );
extern float RadiusFromBounds( const vec3_t mins, const vec3_t maxs );
/////////////////////////////////////////////////////////////////////
//
// 2D Vector routines
//
/////////////////////////////////////////////////////////////////////
#define vector2DClear( a ) ( (a)[ 0 ] = (a)[ 1 ] = 0 )
#define vector2DNegate( a, b ) ( (b)[ 0 ] = (-a)[ 0 ], (b)[ 1 ] = (-a)[ 1 ] )
#define vector2DSet( v, x, y ) ( (v)[ 0 ] = ( x ), (v)[ 1 ] = ( y ) )
#define vector2DInverse( a ) ( (a)[ 0 ] = (-a)[ 0 ], (a)[ 1 ] = (-a)[ 1 ] )
#define vector2DPerpDot( a, b ) ( (a)[ 0 ] * (b)[ 1 ] - (a)[ 1 ] * (b)[ 0 ] )
#define vector2DDotProduct( x, y ) ( (x)[ 0 ] * (y)[ 0 ] + (x)[ 1 ] * (y)[ 1 ] )
#define vector2DSubtract( a, b, c ) ( (c)[ 0 ] = (a)[ 0 ] - (b)[ 0 ], (c)[ 1 ] = (a)[ 1 ] - (b)[ 1 ] )
#define vector2DAdd( a, b, c ) ( (c)[ 0 ] = (a)[ 0 ] + (b)[ 0 ], (c)[ 1 ] = (a)[ 1 ] + (b)[ 1 ] )
#define vector2DCopy( a, b ) ( (b)[ 0 ] = (a)[ 0 ], (b)[ 1 ] = (a)[ 1 ] )
#define vector2DScale( v, s, o ) ( (o)[ 0 ] = (v)[ 0 ] * (s), (o)[ 1 ] = (v)[ 1 ] * (s) )
#define vector2DMA( v, s, b, o ) ( (o)[ 0 ] = (v)[ 0 ] + (b)[ 0 ]*(s), (o)[ 1 ] = (v)[ 1 ] + (b)[ 1 ] * (s) )
extern W32 vector2DCompare( const vec2_t v1, const vec2_t v2 );
extern vec_t vector2DLength( const vec2_t v );
#endif /* __VECTOR_H__ */