quick/netradiant-custom
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

initial

Browse Source 
git-svn-id: svn://svn.icculus.org/netradiant/trunk@1 61c419a2-8eb2-4b30-bcec-8cead039b335
This commit is contained in:
rpolzer
2008-09-13 18:28:57 +00:00
commit 107765f0e4
1687 changed files with 438695 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

462
libs/mathlib/bbox.c Normal file
View File

@@ -0,0 +1,462 @@
/*
Copyright (C) 2001-2006, William Joseph.
All Rights Reserved.
This file is part of GtkRadiant.
GtkRadiant 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.
GtkRadiant 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 GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <float.h>
#include "mathlib.h"
const aabb_t g_aabb_null = {
{ 0, 0, 0, },
{ -FLT_MAX, -FLT_MAX, -FLT_MAX, },
};
void aabb_construct_for_vec3(aabb_t *aabb, const vec3_t min, const vec3_t max)
{
VectorMid(min, max, aabb->origin);
VectorSubtract(max, aabb->origin, aabb->extents);
}
void aabb_clear(aabb_t *aabb)
{
VectorCopy(g_aabb_null.origin, aabb->origin);
VectorCopy(g_aabb_null.extents, aabb->extents);
}
void aabb_extend_by_point(aabb_t *aabb, const vec3_t point)
{
#if 1
int i;
vec_t min, max, displacement;
for(i=0; i<3; i++)
{
displacement = point[i] - aabb->origin[i];
if(fabs(displacement) > aabb->extents[i])
{
if(aabb->extents[i] < 0) // degenerate
{
min = max = point[i];
}
else if(displacement > 0)
{
min = aabb->origin[i] - aabb->extents[i];
max = aabb->origin[i] + displacement;
}
else
{
max = aabb->origin[i] + aabb->extents[i];
min = aabb->origin[i] + displacement;
}
aabb->origin[i] = (min + max) * 0.5f;
aabb->extents[i] = max - aabb->origin[i];
}
}
#else
unsigned int i;
for(i=0; i<3; ++i)
{
if(aabb->extents[i] < 0) // degenerate
{
aabb->origin[i] = point[i];
aabb->extents[i] = 0;
}
else
{
vec_t displacement = point[i] - aabb->origin[i];
vec_t increment = (vec_t)fabs(displacement) - aabb->extents[i];
if(increment > 0)
{
increment *= (vec_t)((displacement > 0) ? 0.5 : -0.5);
aabb->extents[i] += increment;
aabb->origin[i] += increment;
}
}
}
#endif
}
void aabb_extend_by_aabb(aabb_t *aabb, const aabb_t *aabb_src)
{
int i;
vec_t min, max, displacement, difference;
for(i=0; i<3; i++)
{
displacement = aabb_src->origin[i] - aabb->origin[i];
difference = aabb_src->extents[i] - aabb->extents[i];
if(aabb->extents[i] < 0
|| difference >= fabs(displacement))
{
// 2nd contains 1st
aabb->extents[i] = aabb_src->extents[i];
aabb->origin[i] = aabb_src->origin[i];
}
else if(aabb_src->extents[i] < 0
|| -difference >= fabs(displacement))
{
// 1st contains 2nd
continue;
}
else
{
// not contained
if(displacement > 0)
{
min = aabb->origin[i] - aabb->extents[i];
max = aabb_src->origin[i] + aabb_src->extents[i];
}
else
{
min = aabb_src->origin[i] - aabb_src->extents[i];
max = aabb->origin[i] + aabb->extents[i];
}
aabb->origin[i] = (min + max) * 0.5f;
aabb->extents[i] = max - aabb->origin[i];
}
}
}
void aabb_extend_by_vec3(aabb_t *aabb, vec3_t extension)
{
VectorAdd(aabb->extents, extension, aabb->extents);
}
int aabb_test_point(const aabb_t *aabb, const vec3_t point)
{
int i;
for(i=0; i<3; i++)
if(fabs(point[i] - aabb->origin[i]) >= aabb->extents[i])
return 0;
return 1;
}
int aabb_test_aabb(const aabb_t *aabb, const aabb_t *aabb_src)
{
int i;
for (i=0; i<3; i++)
if ( fabs(aabb_src->origin[i] - aabb->origin[i]) > (fabs(aabb->extents[i]) + fabs(aabb_src->extents[i])) )
return 0;
return 1;
}
int aabb_test_plane(const aabb_t *aabb, const float *plane)
{
float fDist, fIntersect;
// calc distance of origin from plane
fDist = DotProduct(plane, aabb->origin) + plane[3];
// calc extents distance relative to plane normal
fIntersect = (vec_t)(fabs(plane[0] * aabb->extents[0]) + fabs(plane[1] * aabb->extents[1]) + fabs(plane[2] * aabb->extents[2]));
// accept if origin is less than or equal to this distance
if (fabs(fDist) < fIntersect) return 1; // partially inside
else if (fDist < 0) return 2; // totally inside
return 0; // totally outside
}
/*
Fast Ray-Box Intersection
by Andrew Woo
from "Graphics Gems", Academic Press, 1990
*/
#define NUMDIM 3
#define RIGHT 0
#define LEFT 1
#define MIDDLE 2
int aabb_intersect_ray(const aabb_t *aabb, const ray_t *ray, vec3_t intersection)
{
int inside = 1;
char quadrant[NUMDIM];
register int i;
int whichPlane;
double maxT[NUMDIM];
double candidatePlane[NUMDIM];
const float *origin = ray->origin;
const float *direction = ray->direction;
/* Find candidate planes; this loop can be avoided if
rays cast all from the eye(assume perpsective view) */
for (i=0; i<NUMDIM; i++)
{
if(origin[i] < (aabb->origin[i] - aabb->extents[i]))
{
quadrant[i] = LEFT;
candidatePlane[i] = (aabb->origin[i] - aabb->extents[i]);
inside = 0;
}
else if (origin[i] > (aabb->origin[i] + aabb->extents[i]))
{
quadrant[i] = RIGHT;
candidatePlane[i] = (aabb->origin[i] + aabb->extents[i]);
inside = 0;
}
else
{
quadrant[i] = MIDDLE;
}
}
/* Ray origin inside bounding box */
if(inside == 1)
{
VectorCopy(ray->origin, intersection);
return 1;
}
/* Calculate T distances to candidate planes */
for (i = 0; i < NUMDIM; i++)
{
if (quadrant[i] != MIDDLE && direction[i] !=0.)
maxT[i] = (candidatePlane[i] - origin[i]) / direction[i];
else
maxT[i] = -1.;
}
/* Get largest of the maxT's for final choice of intersection */
whichPlane = 0;
for (i = 1; i < NUMDIM; i++)
if (maxT[whichPlane] < maxT[i])
whichPlane = i;
/* Check final candidate actually inside box */
if (maxT[whichPlane] < 0.)
return 0;
for (i = 0; i < NUMDIM; i++)
{
if (whichPlane != i)
{
intersection[i] = (vec_t)(origin[i] + maxT[whichPlane] * direction[i]);
if (fabs(intersection[i] - aabb->origin[i]) > aabb->extents[i])
return 0;
}
else
{
intersection[i] = (vec_t)candidatePlane[i];
}
}
return 1; /* ray hits box */
}
int aabb_test_ray(const aabb_t* aabb, const ray_t* ray)
{
vec3_t displacement, ray_absolute;
vec_t f;
displacement[0] = ray->origin[0] - aabb->origin[0];
if(fabs(displacement[0]) > aabb->extents[0] && displacement[0] * ray->direction[0] >= 0.0f)
return 0;
displacement[1] = ray->origin[1] - aabb->origin[1];
if(fabs(displacement[1]) > aabb->extents[1] && displacement[1] * ray->direction[1] >= 0.0f)
return 0;
displacement[2] = ray->origin[2] - aabb->origin[2];
if(fabs(displacement[2]) > aabb->extents[2] && displacement[2] * ray->direction[2] >= 0.0f)
return 0;
ray_absolute[0] = (float)fabs(ray->direction[0]);
ray_absolute[1] = (float)fabs(ray->direction[1]);
ray_absolute[2] = (float)fabs(ray->direction[2]);
f = ray->direction[1] * displacement[2] - ray->direction[2] * displacement[1];
if((float)fabs(f) > aabb->extents[1] * ray_absolute[2] + aabb->extents[2] * ray_absolute[1])
return 0;
f = ray->direction[2] * displacement[0] - ray->direction[0] * displacement[2];
if((float)fabs(f) > aabb->extents[0] * ray_absolute[2] + aabb->extents[2] * ray_absolute[0])
return 0;
f = ray->direction[0] * displacement[1] - ray->direction[1] * displacement[0];
if((float)fabs(f) > aabb->extents[0] * ray_absolute[1] + aabb->extents[1] * ray_absolute[0])
return 0;
return 1;
}
void aabb_orthogonal_transform(aabb_t* dst, const aabb_t* src, const m4x4_t transform)
{
VectorCopy(src->origin, dst->origin);
m4x4_transform_point(transform, dst->origin);
dst->extents[0] = (vec_t)(fabs(transform[0] * src->extents[0])
+ fabs(transform[4] * src->extents[1])
+ fabs(transform[8] * src->extents[2]));
dst->extents[1] = (vec_t)(fabs(transform[1] * src->extents[0])
+ fabs(transform[5] * src->extents[1])
+ fabs(transform[9] * src->extents[2]));
dst->extents[2] = (vec_t)(fabs(transform[2] * src->extents[0])
+ fabs(transform[6] * src->extents[1])
+ fabs(transform[10] * src->extents[2]));
}
void aabb_for_bbox(aabb_t *aabb, const bbox_t *bbox)
{
int i;
vec3_t temp[3];
VectorCopy(bbox->aabb.origin, aabb->origin);
// calculate the AABB extents in local coord space from the OBB extents and axes
VectorScale(bbox->axes[0], bbox->aabb.extents[0], temp[0]);
VectorScale(bbox->axes[1], bbox->aabb.extents[1], temp[1]);
VectorScale(bbox->axes[2], bbox->aabb.extents[2], temp[2]);
for(i=0;i<3;i++) aabb->extents[i] = (vec_t)(fabs(temp[0][i]) + fabs(temp[1][i]) + fabs(temp[2][i]));
}
void aabb_for_area(aabb_t *aabb, vec3_t area_tl, vec3_t area_br, int axis)
{
aabb_clear(aabb);
aabb->extents[axis] = FLT_MAX;
aabb_extend_by_point(aabb, area_tl);
aabb_extend_by_point(aabb, area_br);
}
int aabb_oriented_intersect_plane(const aabb_t *aabb, const m4x4_t transform, const vec_t* plane)
{
vec_t fDist, fIntersect;
// calc distance of origin from plane
fDist = DotProduct(plane, aabb->origin) + plane[3];
// calc extents distance relative to plane normal
fIntersect = (vec_t)(fabs(aabb->extents[0] * DotProduct(plane, transform))
+ fabs(aabb->extents[1] * DotProduct(plane, transform+4))
+ fabs(aabb->extents[2] * DotProduct(plane, transform+8)));
// accept if origin is less than this distance
if (fabs(fDist) < fIntersect) return 1; // partially inside
else if (fDist < 0) return 2; // totally inside
return 0; // totally outside
}
void aabb_corners(const aabb_t* aabb, vec3_t corners[8])
{
vec3_t min, max;
VectorSubtract(aabb->origin, aabb->extents, min);
VectorAdd(aabb->origin, aabb->extents, max);
VectorSet(corners[0], min[0], max[1], max[2]);
VectorSet(corners[1], max[0], max[1], max[2]);
VectorSet(corners[2], max[0], min[1], max[2]);
VectorSet(corners[3], min[0], min[1], max[2]);
VectorSet(corners[4], min[0], max[1], min[2]);
VectorSet(corners[5], max[0], max[1], min[2]);
VectorSet(corners[6], max[0], min[1], min[2]);
VectorSet(corners[7], min[0], min[1], min[2]);
}
void bbox_update_radius(bbox_t *bbox)
{
bbox->radius = VectorLength(bbox->aabb.extents);
}
void aabb_for_transformed_aabb(aabb_t* dst, const aabb_t* src, const m4x4_t transform)
{
if(src->extents[0] < 0
|| src->extents[1] < 0
|| src->extents[2] < 0)
{
aabb_clear(dst);
return;
}
VectorCopy(src->origin, dst->origin);
m4x4_transform_point(transform, dst->origin);
dst->extents[0] = (vec_t)(fabs(transform[0] * src->extents[0])
+ fabs(transform[4] * src->extents[1])
+ fabs(transform[8] * src->extents[2]));
dst->extents[1] = (vec_t)(fabs(transform[1] * src->extents[0])
+ fabs(transform[5] * src->extents[1])
+ fabs(transform[9] * src->extents[2]));
dst->extents[2] = (vec_t)(fabs(transform[2] * src->extents[0])
+ fabs(transform[6] * src->extents[1])
+ fabs(transform[10] * src->extents[2]));
}
void bbox_for_oriented_aabb(bbox_t *bbox, const aabb_t *aabb, const m4x4_t matrix, const vec3_t euler, const vec3_t scale)
{
double rad[3];
double pi_180 = Q_PI / 180;
double A, B, C, D, E, F, AD, BD;
VectorCopy(aabb->origin, bbox->aabb.origin);
m4x4_transform_point(matrix, bbox->aabb.origin);
bbox->aabb.extents[0] = aabb->extents[0] * scale[0];
bbox->aabb.extents[1] = aabb->extents[1] * scale[1];
bbox->aabb.extents[2] = aabb->extents[2] * scale[2];
rad[0] = euler[0] * pi_180;
rad[1] = euler[1] * pi_180;
rad[2] = euler[2] * pi_180;
A = cos(rad[0]);
B = sin(rad[0]);
C = cos(rad[1]);
D = sin(rad[1]);
E = cos(rad[2]);
F = sin(rad[2]);
AD = A * -D;
BD = B * -D;
bbox->axes[0][0] = (vec_t)(C*E);
bbox->axes[0][1] = (vec_t)(-BD*E + A*F);
bbox->axes[0][2] = (vec_t)(AD*E + B*F);
bbox->axes[1][0] = (vec_t)(-C*F);
bbox->axes[1][1] = (vec_t)(BD*F + A*E);
bbox->axes[1][2] = (vec_t)(-AD*F + B*E);
bbox->axes[2][0] = (vec_t)D;
bbox->axes[2][1] = (vec_t)(-B*C);
bbox->axes[2][2] = (vec_t)(A*C);
bbox_update_radius(bbox);
}
int bbox_intersect_plane(const bbox_t *bbox, const vec_t* plane)
{
vec_t fDist, fIntersect;
// calc distance of origin from plane
fDist = DotProduct(plane, bbox->aabb.origin) + plane[3];
// trivial accept/reject using bounding sphere
if (fabs(fDist) > bbox->radius)
{
if (fDist < 0)
return 2; // totally inside
else
return 0; // totally outside
}
// calc extents distance relative to plane normal
fIntersect = (vec_t)(fabs(bbox->aabb.extents[0] * DotProduct(plane, bbox->axes[0]))
+ fabs(bbox->aabb.extents[1] * DotProduct(plane, bbox->axes[1]))
+ fabs(bbox->aabb.extents[2] * DotProduct(plane, bbox->axes[2])));
// accept if origin is less than this distance
if (fabs(fDist) < fIntersect) return 1; // partially inside
else if (fDist < 0) return 2; // totally inside
return 0; // totally outside
}

41
libs/mathlib/line.c Normal file
View File

@@ -0,0 +1,41 @@
/*
Copyright (C) 2001-2006, William Joseph.
All Rights Reserved.
This file is part of GtkRadiant.
GtkRadiant 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.
GtkRadiant 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 GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "mathlib.h"
void line_construct_for_vec3(line_t *line, const vec3_t start, const vec3_t end)
{
VectorMid(start, end, line->origin);
VectorSubtract(end, line->origin, line->extents);
}
int line_test_plane(const line_t* line, const vec4_t plane)
{
float fDist;
// calc distance of origin from plane
fDist = DotProduct(plane, line->origin) + plane[3];
// accept if origin is less than or equal to this distance
if (fabs(fDist) < fabs(DotProduct(plane, line->extents))) return 1; // partially inside
else if (fDist < 0) return 2; // totally inside
return 0; // totally outside
}

1877
libs/mathlib/m4x4.c Normal file
View File

File diff suppressed because it is too large Load Diff

578
libs/mathlib/mathlib.c Normal file
View File

@@ -0,0 +1,578 @@
/*
Copyright (C) 1999-2006 Id Software, Inc. and contributors.
For a list of contributors, see the accompanying CONTRIBUTORS file.
This file is part of GtkRadiant.
GtkRadiant 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.
GtkRadiant 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 GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
// mathlib.c -- math primitives
#include "mathlib.h"
// we use memcpy and memset
#include <memory.h>
const vec3_t vec3_origin = {0.0f,0.0f,0.0f};
const vec3_t g_vec3_axis_x = { 1, 0, 0, };
const vec3_t g_vec3_axis_y = { 0, 1, 0, };
const vec3_t g_vec3_axis_z = { 0, 0, 1, };
/*
================
MakeNormalVectors
Given a normalized forward vector, create two
other perpendicular vectors
================
*/
void MakeNormalVectors (vec3_t forward, vec3_t right, vec3_t up)
{
float d;
// this rotate and negate guarantees a vector
// not colinear with the original
right[1] = -forward[0];
right[2] = forward[1];
right[0] = forward[2];
d = DotProduct (right, forward);
VectorMA (right, -d, forward, right);
VectorNormalize (right, right);
CrossProduct (right, forward, up);
}
vec_t VectorLength(const vec3_t v)
{
int i;
float length;
length = 0.0f;
for (i=0 ; i< 3 ; i++)
length += v[i]*v[i];
length = (float)sqrt (length);
return length;
}
qboolean VectorCompare (const vec3_t v1, const vec3_t v2)
{
int i;
for (i=0 ; i<3 ; i++)
if (fabs(v1[i]-v2[i]) > EQUAL_EPSILON)
return qfalse;
return qtrue;
}
void VectorMA( const vec3_t va, vec_t scale, const vec3_t vb, vec3_t vc )
{
vc[0] = va[0] + scale*vb[0];
vc[1] = va[1] + scale*vb[1];
vc[2] = va[2] + scale*vb[2];
}
void _CrossProduct (vec3_t v1, vec3_t v2, vec3_t cross)
{
cross[0] = v1[1]*v2[2] - v1[2]*v2[1];
cross[1] = v1[2]*v2[0] - v1[0]*v2[2];
cross[2] = v1[0]*v2[1] - v1[1]*v2[0];
}
vec_t _DotProduct (vec3_t v1, vec3_t v2)
{
return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];
}
void _VectorSubtract (vec3_t va, vec3_t vb, vec3_t out)
{
out[0] = va[0]-vb[0];
out[1] = va[1]-vb[1];
out[2] = va[2]-vb[2];
}
void _VectorAdd (vec3_t va, vec3_t vb, vec3_t out)
{
out[0] = va[0]+vb[0];
out[1] = va[1]+vb[1];
out[2] = va[2]+vb[2];
}
void _VectorCopy (vec3_t in, vec3_t out)
{
out[0] = in[0];
out[1] = in[1];
out[2] = in[2];
}
vec_t VectorNormalize( const vec3_t in, vec3_t out ) {
vec_t length, ilength;
length = (vec_t)sqrt (in[0]*in[0] + in[1]*in[1] + in[2]*in[2]);
if (length == 0)
{
VectorClear (out);
return 0;
}
ilength = 1.0f/length;
out[0] = in[0]*ilength;
out[1] = in[1]*ilength;
out[2] = in[2]*ilength;
return length;
}
vec_t ColorNormalize( const vec3_t in, vec3_t out ) {
float max, scale;
max = in[0];
if (in[1] > max)
max = in[1];
if (in[2] > max)
max = in[2];
if (max == 0) {
out[0] = out[1] = out[2] = 1.0;
return 0;
}
scale = 1.0f / max;
VectorScale (in, scale, out);
return max;
}
void VectorInverse (vec3_t v)
{
v[0] = -v[0];
v[1] = -v[1];
v[2] = -v[2];
}
/*
void VectorScale (vec3_t v, vec_t scale, vec3_t out)
{
out[0] = v[0] * scale;
out[1] = v[1] * scale;
out[2] = v[2] * scale;
}
*/
void VectorRotate (vec3_t vIn, vec3_t vRotation, vec3_t out)
{
vec3_t vWork, va;
int nIndex[3][2];
int i;
VectorCopy(vIn, va);
VectorCopy(va, vWork);
nIndex[0][0] = 1; nIndex[0][1] = 2;
nIndex[1][0] = 2; nIndex[1][1] = 0;
nIndex[2][0] = 0; nIndex[2][1] = 1;
for (i = 0; i < 3; i++)
{
if (vRotation[i] != 0)
{
float dAngle = vRotation[i] * Q_PI / 180.0f;
float c = (vec_t)cos(dAngle);
float s = (vec_t)sin(dAngle);
vWork[nIndex[i][0]] = va[nIndex[i][0]] * c - va[nIndex[i][1]] * s;
vWork[nIndex[i][1]] = va[nIndex[i][0]] * s + va[nIndex[i][1]] * c;
}
VectorCopy(vWork, va);
}
VectorCopy(vWork, out);
}
void VectorRotateOrigin (vec3_t vIn, vec3_t vRotation, vec3_t vOrigin, vec3_t out)
{
vec3_t vTemp, vTemp2;
VectorSubtract(vIn, vOrigin, vTemp);
VectorRotate(vTemp, vRotation, vTemp2);
VectorAdd(vTemp2, vOrigin, out);
}
void VectorPolar(vec3_t v, float radius, float theta, float phi)
{
v[0]=(float)(radius * cos(theta) * cos(phi));
v[1]=(float)(radius * sin(theta) * cos(phi));
v[2]=(float)(radius * sin(phi));
}
void VectorSnap(vec3_t v)
{
int i;
for (i = 0; i < 3; i++)
{
v[i] = (vec_t)FLOAT_TO_INTEGER(v[i]);
}
}
void VectorISnap(vec3_t point, int snap)
{
int i;
for (i = 0 ;i < 3 ; i++)
{
point[i] = (vec_t)FLOAT_SNAP(point[i], snap);
}
}
void VectorFSnap(vec3_t point, float snap)
{
int i;
for (i = 0 ;i < 3 ; i++)
{
point[i] = (vec_t)FLOAT_SNAP(point[i], snap);
}
}
void _Vector5Add (vec5_t va, vec5_t vb, vec5_t out)
{
out[0] = va[0]+vb[0];
out[1] = va[1]+vb[1];
out[2] = va[2]+vb[2];
out[3] = va[3]+vb[3];
out[4] = va[4]+vb[4];
}
void _Vector5Scale (vec5_t v, vec_t scale, vec5_t out)
{
out[0] = v[0] * scale;
out[1] = v[1] * scale;
out[2] = v[2] * scale;
out[3] = v[3] * scale;
out[4] = v[4] * scale;
}
void _Vector53Copy (vec5_t in, vec3_t out)
{
out[0] = in[0];
out[1] = in[1];
out[2] = in[2];
}
// NOTE: added these from Ritual's Q3Radiant
void ClearBounds (vec3_t mins, vec3_t maxs)
{
mins[0] = mins[1] = mins[2] = 99999;
maxs[0] = maxs[1] = maxs[2] = -99999;
}
void AddPointToBounds (vec3_t v, vec3_t mins, vec3_t maxs)
{
int i;
vec_t val;
for (i=0 ; i<3 ; i++)
{
val = v[i];
if (val < mins[i])
mins[i] = val;
if (val > maxs[i])
maxs[i] = val;
}
}
void AngleVectors (vec3_t angles, vec3_t forward, vec3_t right, vec3_t up)
{
float angle;
static float sr, sp, sy, cr, cp, cy;
// static to help MS compiler fp bugs
angle = angles[YAW] * (Q_PI*2.0f / 360.0f);
sy = (vec_t)sin(angle);
cy = (vec_t)cos(angle);
angle = angles[PITCH] * (Q_PI*2.0f / 360.0f);
sp = (vec_t)sin(angle);
cp = (vec_t)cos(angle);
angle = angles[ROLL] * (Q_PI*2.0f / 360.0f);
sr = (vec_t)sin(angle);
cr = (vec_t)cos(angle);
if (forward)
{
forward[0] = cp*cy;
forward[1] = cp*sy;
forward[2] = -sp;
}
if (right)
{
right[0] = -sr*sp*cy+cr*sy;
right[1] = -sr*sp*sy-cr*cy;
right[2] = -sr*cp;
}
if (up)
{
up[0] = cr*sp*cy+sr*sy;
up[1] = cr*sp*sy-sr*cy;
up[2] = cr*cp;
}
}
void VectorToAngles( vec3_t vec, vec3_t angles )
{
float forward;
float yaw, pitch;
if ( ( vec[ 0 ] == 0 ) && ( vec[ 1 ] == 0 ) )
{
yaw = 0;
if ( vec[ 2 ] > 0 )
{
pitch = 90;
}
else
{
pitch = 270;
}
}
else
{
yaw = (vec_t)atan2( vec[ 1 ], vec[ 0 ] ) * 180 / Q_PI;
if ( yaw < 0 )
{
yaw += 360;
}
forward = ( float )sqrt( vec[ 0 ] * vec[ 0 ] + vec[ 1 ] * vec[ 1 ] );
pitch = (vec_t)atan2( vec[ 2 ], forward ) * 180 / Q_PI;
if ( pitch < 0 )
{
pitch += 360;
}
}
angles[ 0 ] = pitch;
angles[ 1 ] = yaw;
angles[ 2 ] = 0;
}
/*
=====================
PlaneFromPoints
Returns false if the triangle is degenrate.
The normal will point out of the clock for clockwise ordered points
=====================
*/
qboolean PlaneFromPoints( vec4_t plane, const vec3_t a, const vec3_t b, const vec3_t c ) {
vec3_t d1, d2;
VectorSubtract( b, a, d1 );
VectorSubtract( c, a, d2 );
CrossProduct( d2, d1, plane );
if ( VectorNormalize( plane, plane ) == 0 ) {
return qfalse;
}
plane[3] = DotProduct( a, plane );
return qtrue;
}
/*
** NormalToLatLong
**
** We use two byte encoded normals in some space critical applications.
** Lat = 0 at (1,0,0) to 360 (-1,0,0), encoded in 8-bit sine table format
** Lng = 0 at (0,0,1) to 180 (0,0,-1), encoded in 8-bit sine table format
**
*/
void NormalToLatLong( const vec3_t normal, byte bytes[2] ) {
// check for singularities
if ( normal[0] == 0 && normal[1] == 0 ) {
if ( normal[2] > 0 ) {
bytes[0] = 0;
bytes[1] = 0; // lat = 0, long = 0
} else {
bytes[0] = 128;
bytes[1] = 0; // lat = 0, long = 128
}
} else {
int a, b;
a = (int)( RAD2DEG( atan2( normal[1], normal[0] ) ) * (255.0f / 360.0f ) );
a &= 0xff;
b = (int)( RAD2DEG( acos( normal[2] ) ) * ( 255.0f / 360.0f ) );
b &= 0xff;
bytes[0] = b; // longitude
bytes[1] = a; // lattitude
}
}
/*
=================
PlaneTypeForNormal
=================
*/
int PlaneTypeForNormal (vec3_t normal) {
if (normal[0] == 1.0 || normal[0] == -1.0)
return PLANE_X;
if (normal[1] == 1.0 || normal[1] == -1.0)
return PLANE_Y;
if (normal[2] == 1.0 || normal[2] == -1.0)
return PLANE_Z;
return PLANE_NON_AXIAL;
}
/*
================
MatrixMultiply
================
*/
void MatrixMultiply(float in1[3][3], float in2[3][3], float out[3][3]) {
out[0][0] = in1[0][0] * in2[0][0] + in1[0][1] * in2[1][0] +
in1[0][2] * in2[2][0];
out[0][1] = in1[0][0] * in2[0][1] + in1[0][1] * in2[1][1] +
in1[0][2] * in2[2][1];
out[0][2] = in1[0][0] * in2[0][2] + in1[0][1] * in2[1][2] +
in1[0][2] * in2[2][2];
out[1][0] = in1[1][0] * in2[0][0] + in1[1][1] * in2[1][0] +
in1[1][2] * in2[2][0];
out[1][1] = in1[1][0] * in2[0][1] + in1[1][1] * in2[1][1] +
in1[1][2] * in2[2][1];
out[1][2] = in1[1][0] * in2[0][2] + in1[1][1] * in2[1][2] +
in1[1][2] * in2[2][2];
out[2][0] = in1[2][0] * in2[0][0] + in1[2][1] * in2[1][0] +
in1[2][2] * in2[2][0];
out[2][1] = in1[2][0] * in2[0][1] + in1[2][1] * in2[1][1] +
in1[2][2] * in2[2][1];
out[2][2] = in1[2][0] * in2[0][2] + in1[2][1] * in2[1][2] +
in1[2][2] * in2[2][2];
}
void ProjectPointOnPlane( vec3_t dst, const vec3_t p, const vec3_t normal )
{
float d;
vec3_t n;
float inv_denom;
inv_denom = 1.0F / DotProduct( normal, normal );
d = DotProduct( normal, p ) * inv_denom;
n[0] = normal[0] * inv_denom;
n[1] = normal[1] * inv_denom;
n[2] = normal[2] * inv_denom;
dst[0] = p[0] - d * n[0];
dst[1] = p[1] - d * n[1];
dst[2] = p[2] - d * n[2];
}
/*
** assumes "src" is normalized
*/
void PerpendicularVector( vec3_t dst, const vec3_t src )
{
int pos;
int i;
vec_t minelem = 1.0F;
vec3_t tempvec;
/*
** find the smallest magnitude axially aligned vector
*/
for ( pos = 0, i = 0; i < 3; i++ )
{
if ( fabs( src[i] ) < minelem )
{
pos = i;
minelem = (vec_t)fabs( src[i] );
}
}
tempvec[0] = tempvec[1] = tempvec[2] = 0.0F;
tempvec[pos] = 1.0F;
/*
** project the point onto the plane defined by src
*/
ProjectPointOnPlane( dst, tempvec, src );
/*
** normalize the result
*/
VectorNormalize( dst, dst );
}
/*
===============
RotatePointAroundVector
This is not implemented very well...
===============
*/
void RotatePointAroundVector( vec3_t dst, const vec3_t dir, const vec3_t point,
float degrees ) {
float m[3][3];
float im[3][3];
float zrot[3][3];
float tmpmat[3][3];
float rot[3][3];
int i;
vec3_t vr, vup, vf;
float rad;
vf[0] = dir[0];
vf[1] = dir[1];
vf[2] = dir[2];
PerpendicularVector( vr, dir );
CrossProduct( vr, vf, vup );
m[0][0] = vr[0];
m[1][0] = vr[1];
m[2][0] = vr[2];
m[0][1] = vup[0];
m[1][1] = vup[1];
m[2][1] = vup[2];
m[0][2] = vf[0];
m[1][2] = vf[1];
m[2][2] = vf[2];
memcpy( im, m, sizeof( im ) );
im[0][1] = m[1][0];
im[0][2] = m[2][0];
im[1][0] = m[0][1];
im[1][2] = m[2][1];
im[2][0] = m[0][2];
im[2][1] = m[1][2];
memset( zrot, 0, sizeof( zrot ) );
zrot[0][0] = zrot[1][1] = zrot[2][2] = 1.0F;
rad = (float)DEG2RAD( degrees );
zrot[0][0] = (vec_t)cos( rad );
zrot[0][1] = (vec_t)sin( rad );
zrot[1][0] = (vec_t)-sin( rad );
zrot[1][1] = (vec_t)cos( rad );
MatrixMultiply( m, zrot, tmpmat );
MatrixMultiply( tmpmat, im, rot );
for ( i = 0; i < 3; i++ ) {
dst[i] = rot[i][0] * point[0] + rot[i][1] * point[1] + rot[i][2] * point[2];
}
}

320
libs/mathlib/mathlib.vcproj Normal file
View File

@@ -0,0 +1,320 @@
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="8,00"
Name="mathlib"
ProjectGUID="{BF0FF048-887F-4D43-A455-F8C04FB98F10}"
>
<Platforms>
<Platform
Name="Win32"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory=".\Debug"
IntermediateDirectory=".\Debug"
ConfigurationType="4"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=".."
PreprocessorDefinitions="_CRT_SECURE_NO_DEPRECATE;WIN32;_DEBUG;_LIB"
ExceptionHandling="0"
BasicRuntimeChecks="3"
RuntimeLibrary="3"
BufferSecurityCheck="true"
PrecompiledHeaderFile=".\Debug/mathlib.pch"
AssemblerListingLocation=".\Debug/"
ObjectFile=".\Debug/"
ProgramDataBaseFileName=".\Debug/"
BrowseInformation="0"
WarningLevel="3"
SuppressStartupBanner="true"
DebugInformationFormat="3"
CompileAs="0"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1036"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
OutputFile=".\Debug\mathlib.lib"
SuppressStartupBanner="true"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory=".\Release"
IntermediateDirectory=".\Release"
ConfigurationType="4"
InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="false"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories=".."
PreprocessorDefinitions="_CRT_SECURE_NO_DEPRECATE;WIN32;NDEBUG;_LIB"
StringPooling="true"
ExceptionHandling="0"
BasicRuntimeChecks="0"
RuntimeLibrary="2"
BufferSecurityCheck="false"
EnableFunctionLevelLinking="true"
PrecompiledHeaderFile=".\Release/mathlib.pch"
AssemblerListingLocation=".\Release/"
ObjectFile=".\Release/"
ProgramDataBaseFileName=".\Release/"
WarningLevel="3"
SuppressStartupBanner="true"
CompileAs="0"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1036"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLibrarianTool"
OutputFile=".\Release\mathlib.lib"
SuppressStartupBanner="true"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
>
<File
RelativePath="bbox.c"
>
<FileConfiguration
Name="Debug|Win32"
>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
BasicRuntimeChecks="3"
BrowseInformation="1"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32"
>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
/>
</FileConfiguration>
</File>
<File
RelativePath="line.c"
>
<FileConfiguration
Name="Debug|Win32"
>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
BasicRuntimeChecks="3"
BrowseInformation="1"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32"
>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
/>
</FileConfiguration>
</File>
<File
RelativePath="m4x4.c"
>
<FileConfiguration
Name="Debug|Win32"
>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
BasicRuntimeChecks="3"
BrowseInformation="1"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32"
>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
/>
</FileConfiguration>
</File>
<File
RelativePath="mathlib.c"
>
<FileConfiguration
Name="Debug|Win32"
>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
BasicRuntimeChecks="3"
BrowseInformation="1"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32"
>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
/>
</FileConfiguration>
</File>
<File
RelativePath="ray.c"
>
<FileConfiguration
Name="Debug|Win32"
>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
BasicRuntimeChecks="3"
BrowseInformation="1"
/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32"
>
<Tool
Name="VCCLCompilerTool"
Optimization="2"
AdditionalIncludeDirectories=""
PreprocessorDefinitions=""
/>
</FileConfiguration>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl"
>
<File
RelativePath="..\mathlib.h"
>
</File>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

140
libs/mathlib/ray.c Normal file
View File

@@ -0,0 +1,140 @@
/*
Copyright (C) 2001-2006, William Joseph.
All Rights Reserved.
This file is part of GtkRadiant.
GtkRadiant 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.
GtkRadiant 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 GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "mathlib.h"
#include <float.h>
vec3_t identity = { 0,0,0 };
void ray_construct_for_vec3(ray_t *ray, const vec3_t origin, const vec3_t direction)
{
VectorCopy(origin, ray->origin);
VectorCopy(direction, ray->direction);
}
void ray_transform(ray_t *ray, const m4x4_t matrix)
{
m4x4_transform_point(matrix, ray->origin);
m4x4_transform_normal(matrix, ray->direction);
}
vec_t ray_intersect_point(const ray_t *ray, const vec3_t point, vec_t epsilon, vec_t divergence)
{
vec3_t displacement;
vec_t depth;
// calc displacement of test point from ray origin
VectorSubtract(point, ray->origin, displacement);
// calc length of displacement vector along ray direction
depth = DotProduct(displacement, ray->direction);
if(depth < 0.0f) return (vec_t)FLT_MAX;
// calc position of closest point on ray to test point
VectorMA (ray->origin, depth, ray->direction, displacement);
// calc displacement of test point from closest point
VectorSubtract(point, displacement, displacement);
// calc length of displacement, subtract depth-dependant epsilon
if (VectorLength(displacement) - (epsilon + (depth * divergence)) > 0.0f) return (vec_t)FLT_MAX;
return depth;
}
// Tomas Moller and Ben Trumbore. Fast, minimum storage ray-triangle intersection. Journal of graphics tools, 2(1):21-28, 1997
#define EPSILON 0.000001
vec_t ray_intersect_triangle(const ray_t *ray, qboolean bCullBack, const vec3_t vert0, const vec3_t vert1, const vec3_t vert2)
{
float edge1[3], edge2[3], tvec[3], pvec[3], qvec[3];
float det,inv_det;
float u, v;
vec_t depth = (vec_t)FLT_MAX;
/* find vectors for two edges sharing vert0 */
VectorSubtract(vert1, vert0, edge1);
VectorSubtract(vert2, vert0, edge2);
/* begin calculating determinant - also used to calculate U parameter */
CrossProduct(ray->direction, edge2, pvec);
/* if determinant is near zero, ray lies in plane of triangle */
det = DotProduct(edge1, pvec);
if (bCullBack == qtrue)
{
if (det < EPSILON)
return depth;
// calculate distance from vert0 to ray origin
VectorSubtract(ray->origin, vert0, tvec);
// calculate U parameter and test bounds
u = DotProduct(tvec, pvec);
if (u < 0.0 || u > det)
return depth;
// prepare to test V parameter
CrossProduct(tvec, edge1, qvec);
// calculate V parameter and test bounds
v = DotProduct(ray->direction, qvec);
if (v < 0.0 || u + v > det)
return depth;
// calculate t, scale parameters, ray intersects triangle
depth = DotProduct(edge2, qvec);
inv_det = 1.0f / det;
depth *= inv_det;
//u *= inv_det;
//v *= inv_det;
}
else
{
/* the non-culling branch */
if (det > -EPSILON && det < EPSILON)
return depth;
inv_det = 1.0f / det;
/* calculate distance from vert0 to ray origin */
VectorSubtract(ray->origin, vert0, tvec);
/* calculate U parameter and test bounds */
u = DotProduct(tvec, pvec) * inv_det;
if (u < 0.0 || u > 1.0)
return depth;
/* prepare to test V parameter */
CrossProduct(tvec, edge1, qvec);
/* calculate V parameter and test bounds */
v = DotProduct(ray->direction, qvec) * inv_det;
if (v < 0.0 || u + v > 1.0)
return depth;
/* calculate t, ray intersects triangle */
depth = DotProduct(edge2, qvec) * inv_det;
}
return depth;
}
vec_t ray_intersect_plane(const ray_t* ray, const vec3_t normal, vec_t dist)
{
return -(DotProduct(normal, ray->origin) - dist) / DotProduct(ray->direction, normal);
}