int CreateNewFloatPlane (vec3_t normal, vec_t dist)
{
plane_t *p, temp;
float len = VectorLength(normal);
if ((!badnormal_check && len < 0.5) || (badnormal_check &&
(len + badnormal < 1.0f || len - badnormal < -1.0f)))
{
if(show_points)
Error ("FloatPlane: bad normal\n Plane Points: ( %g %g %g) ( %g %g %g) (%g %g %g)\n"
" Brush: %s\n",
last_points[0][0],last_points[0][1],last_points[0][2],
last_points[1][0],last_points[1][1],last_points[1][2],
last_points[2][0],last_points[2][1],last_points[2][2],
brush_info);
else
Error ("FloatPlane: bad normal");
}
// create a new plane
if (nummapplanes+2 > MAX_MAP_PLANES)
Error ("MAX_MAP_PLANES");
p = &mapplanes[nummapplanes];
VectorCopy (normal, p->normal);
p->dist = dist;
p->type = (p+1)->type = PlaneTypeForNormal (p->normal);
VectorSubtract (vec3_origin, normal, (p+1)->normal);
(p+1)->dist = -dist;
nummapplanes += 2;
// allways put axial planes facing positive first
if (p->type < 3)
{
if (p->normal[0] < 0 || p->normal[1] < 0 || p->normal[2] < 0)
{
// flip order
temp = *p;
*p = *(p+1);
*(p+1) = temp;
AddPlaneToHash (p);
AddPlaneToHash (p+1);
return nummapplanes - 1;
}
}
AddPlaneToHash (p);
AddPlaneToHash (p+1);
return nummapplanes - 2;
}
/*
================
CreateNewFloatPlane
================
*/
int CreateNewFloatPlane( vec3_t normal, vec_t dist )
{
plane_t *p, temp;
if( VectorLength( normal ) < 0.5f )
{
MsgDev( D_NOTE, "CreateNewFloatPlane: bad normal\n");
return -1;
}
// create a new plane
if( nummapplanes + 2 > MAX_MAP_PLANES ) Sys_Error( "MAX_MAP_PLANES limit exceeded\n" );
p = &mapplanes[nummapplanes];
VectorCopy( normal, p->normal );
p->dist = dist;
p->type = (p+1)->type = MapPlaneTypeForNormal( p->normal );
VectorSubtract( vec3_origin, normal, (p+1)->normal );
(p+1)->dist = -dist;
nummapplanes += 2;
// allways put axial planes facing positive first
if( p->type < 3 )
{
if( p->normal[0] < 0 || p->normal[1] < 0 || p->normal[2] < 0 )
{
// flip order
temp = *p;
*p = *(p+1);
*(p+1) = temp;
AddPlaneToHash( p+0 );
AddPlaneToHash( p+1 );
return nummapplanes - 1;
}
}
AddPlaneToHash( p+0 );
AddPlaneToHash( p+1 );
return nummapplanes - 2;
}
/*
================
CreateNewFloatPlane
================
*/
int CreateNewFloatPlane (vec3_t normal, vec_t dist)
{
plane_t *p, temp;
if (VectorLength(normal) < 0.5)
{
Sys_Printf( "FloatPlane: bad normal\n");
return -1;
}
// create a new plane
AUTOEXPAND_BY_REALLOC(mapplanes, nummapplanes+1, allocatedmapplanes, 1024);
p = &mapplanes[nummapplanes];
VectorCopy (normal, p->normal);
p->dist = dist;
p->type = (p+1)->type = PlaneTypeForNormal (p->normal);
VectorSubtract (vec3_origin, normal, (p+1)->normal);
(p+1)->dist = -dist;
nummapplanes += 2;
// allways put axial planes facing positive first
if (p->type < 3)
{
if (p->normal[0] < 0 || p->normal[1] < 0 || p->normal[2] < 0)
{
// flip order
temp = *p;
*p = *(p+1);
*(p+1) = temp;
AddPlaneToHash (p);
AddPlaneToHash (p+1);
return nummapplanes - 1;
}
}
AddPlaneToHash (p);
AddPlaneToHash (p+1);
return nummapplanes - 2;
}
static uint16_t CreateNewFloatPlane (vec3_t normal, vec_t dist)
{
plane_t* p;
if (VectorLength(normal) < 0.5)
Sys_Error("FloatPlane: bad normal (%.3f:%.3f:%.3f)", normal[0], normal[1], normal[2]);
/* create a new plane */
if (nummapplanes + 2 > MAX_MAP_PLANES)
Sys_Error("MAX_MAP_PLANES (%i)", nummapplanes + 2);
p = &mapplanes[nummapplanes];
VectorCopy(normal, p->normal);
p->dist = dist;
p->type = (p + 1)->type = PlaneTypeForNormal(p->normal);
VectorSubtract(vec3_origin, normal, (p + 1)->normal);
(p + 1)->dist = -dist;
nummapplanes += 2;
/* always put axial planes facing positive first */
if (AXIAL(p)) {
if (p->normal[0] < 0 || p->normal[1] < 0 || p->normal[2] < 0) {
/* flip order by swapping the planes */
const plane_t temp = *p;
*p = *(p + 1);
*(p + 1) = temp;
AddPlaneToHash(p);
AddPlaneToHash(p + 1);
return nummapplanes - 1;
}
}
AddPlaneToHash(p);
AddPlaneToHash(p + 1);
return nummapplanes - 2;
}
/*
* @brief
*/
static int32_t CreateNewFloatPlane(vec3_t normal, vec_t dist) {
map_plane_t *p, temp;
if (VectorLength(normal) < 0.5)
Com_Error(ERR_FATAL, "FloatPlane: bad normal\n");
// create a new plane
if (num_map_planes + 2 > MAX_BSP_PLANES)
Com_Error(ERR_FATAL, "MAX_BSP_PLANES\n");
p = &map_planes[num_map_planes];
VectorCopy(normal, p->normal);
p->dist = dist;
p->type = (p + 1)->type = PlaneTypeForNormal(p->normal);
VectorSubtract(vec3_origin, normal, (p + 1)->normal);
(p + 1)->dist = -dist;
num_map_planes += 2;
// always put axial planes facing positive first
if (AXIAL(p)) {
if (p->normal[0] < 0.0 || p->normal[1] < 0.0 || p->normal[2] < 0.0) {
// flip order
temp = *p;
*p = *(p + 1);
*(p + 1) = temp;
AddPlaneToHash(p);
AddPlaneToHash(p + 1);
return num_map_planes - 1;
}
}
AddPlaneToHash(p);
AddPlaneToHash(p + 1);
return num_map_planes - 2;
}