tiberium/CnC_Renegade
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/ww3d2/seglinerenderer.cpp

1225 lines
No EOL
47 KiB
C++
Raw Permalink Blame History

/*
** Command & Conquer Renegade(tm)
** Copyright 2025 Electronic Arts 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 3 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, see <http://www.gnu.org/licenses/>.
*/
/***********************************************************************************************
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
***********************************************************************************************
* *
* Project Name : ww3d *
* *
* $Archive:: /Commando/Code/ww3d2/seglinerenderer.cpp $*
* *
* Original Author:: Greg Hjelstrom *
* *
* $Author:: Jani_p $*
* *
* $Modtime:: 11/24/01 6:20p $*
* *
* $Revision:: 4 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#if 1
#include "seglinerenderer.h"
#include "ww3d.h"
#include "rinfo.h"
#include "dx8wrapper.h"
#include "sortingrenderer.h"
#include "vp.h"
#include "vector3i.h"
#include "random.h"
#include "v3_rnd.h"
#include "meshgeometry.h"
/* We have chunking logic which handles N segments at a time. To simplify the subdivision logic,
** we will ensure that N is a power of two and that N >= 2^MAX_SEGLINE_SUBDIV_LEVELS, so that the
** subdivision logic can be inside the chunking loop.
*/
#if MAX_SEGLINE_SUBDIV_LEVELS > 7
#define SEGLINE_CHUNK_SIZE (1 << MAX_SEGLINE_SUBDIV_LEVELS)
#else
#define SEGLINE_CHUNK_SIZE (128)
#endif
#define MAX_SEGLINE_POINT_BUFFER_SIZE (1 + SEGLINE_CHUNK_SIZE)
// This macro depends on the assumption that each line segment is two polys.
#define MAX_SEGLINE_POLY_BUFFER_SIZE (SEGLINE_CHUNK_SIZE * 2)
SegLineRendererClass::SegLineRendererClass(void) :
Texture(NULL),
Shader(ShaderClass::_PresetAdditiveSpriteShader),
Width(0.0f),
Color(Vector3(1,1,1)),
Opacity(1.0f),
SubdivisionLevel(0),
NoiseAmplitude(0.0f),
MergeAbortFactor(1.5f),
TextureTileFactor(1.0f),
LastUsedSyncTime(WW3D::Get_Sync_Time()),
CurrentUVOffset(0.0f,0.0f),
UVOffsetDeltaPerMS(0.0f, 0.0f),
Bits(DEFAULT_BITS)
{
}
SegLineRendererClass::SegLineRendererClass(const SegLineRendererClass & that) :
Texture(NULL),
Shader(ShaderClass::_PresetAdditiveSpriteShader),
Width(0.0f),
Color(Vector3(1,1,1)),
Opacity(1.0f),
SubdivisionLevel(0),
NoiseAmplitude(0.0f),
MergeAbortFactor(1.5f),
TextureTileFactor(1.0f),
LastUsedSyncTime(that.LastUsedSyncTime),
CurrentUVOffset(0.0f,0.0f),
UVOffsetDeltaPerMS(0.0f, 0.0f),
Bits(DEFAULT_BITS)
{
*this = that;
}
SegLineRendererClass & SegLineRendererClass::operator = (const SegLineRendererClass & that)
{
if (this != &that) {
REF_PTR_SET(Texture,that.Texture);
Shader = that.Shader;
Width = that.Width;
Color = that.Color;
Opacity = that.Opacity;
SubdivisionLevel = that.SubdivisionLevel;
NoiseAmplitude = that.NoiseAmplitude;
MergeAbortFactor = that.MergeAbortFactor;
TextureTileFactor = that.TextureTileFactor;
LastUsedSyncTime = that.LastUsedSyncTime;
CurrentUVOffset = that.CurrentUVOffset;
UVOffsetDeltaPerMS = that.UVOffsetDeltaPerMS;
Bits = that.Bits;
}
return *this;
}
SegLineRendererClass::~SegLineRendererClass(void)
{
REF_PTR_RELEASE(Texture);
}
void SegLineRendererClass::Init(const W3dEmitterLinePropertiesStruct & props)
{
// translate the flags
Set_Merge_Intersections(props.Flags & W3D_ELINE_MERGE_INTERSECTIONS);
Set_Freeze_Random(props.Flags & W3D_ELINE_FREEZE_RANDOM);
Set_Disable_Sorting(props.Flags & W3D_ELINE_DISABLE_SORTING);
Set_End_Caps(props.Flags & W3D_ELINE_END_CAPS);
int texture_mode = ((props.Flags & W3D_ELINE_TEXTURE_MAP_MODE_MASK) >> W3D_ELINE_TEXTURE_MAP_MODE_OFFSET);
switch (texture_mode)
{
case W3D_ELINE_UNIFORM_WIDTH_TEXTURE_MAP:
Set_Texture_Mapping_Mode(UNIFORM_WIDTH_TEXTURE_MAP);
break;
case W3D_ELINE_UNIFORM_LENGTH_TEXTURE_MAP:
Set_Texture_Mapping_Mode(UNIFORM_LENGTH_TEXTURE_MAP);
break;
case W3D_ELINE_TILED_TEXTURE_MAP:
Set_Texture_Mapping_Mode(TILED_TEXTURE_MAP);
break;
};
// install all other settings
Set_Current_Subdivision_Level(props.SubdivisionLevel);
Set_Noise_Amplitude(props.NoiseAmplitude);
Set_Merge_Abort_Factor(props.MergeAbortFactor);
Set_Texture_Tile_Factor(props.TextureTileFactor);
Set_UV_Offset_Rate(Vector2(props.UPerSec,props.VPerSec));
}
void SegLineRendererClass::Set_Texture(TextureClass *texture)
{
REF_PTR_SET(Texture,texture);
}
TextureClass * SegLineRendererClass::Get_Texture(void) const
{
if (Texture != NULL) {
Texture->Add_Ref();
}
return Texture;
}
void SegLineRendererClass::Set_Current_UV_Offset(const Vector2 & offset)
{
CurrentUVOffset = offset;
}
void SegLineRendererClass::Set_Texture_Tile_Factor(float factor)
{
if (factor > 8.0f) {
factor = 8.0f;
WWDEBUG_SAY(("Texture Tile Factor too large in SegLineRendererClass!\r\n"));
} else {
factor = MAX(factor, 0.0f);
}
TextureTileFactor = factor;
}
void SegLineRendererClass::Reset_Line(void)
{
LastUsedSyncTime = WW3D::Get_Sync_Time();
CurrentUVOffset.Set(0.0f,0.0f);
}
void SegLineRendererClass::Render
(
RenderInfoClass & rinfo,
const Matrix3D & transform,
unsigned int num_points,
Vector3 * points,
const SphereClass & obj_sphere
)
{
Matrix4 view;
DX8Wrapper::Get_Transform(D3DTS_VIEW,view);
Matrix4 identity(true);
DX8Wrapper::Set_Transform(D3DTS_WORLD,identity);
DX8Wrapper::Set_Transform(D3DTS_VIEW,identity);
/*
** Handle texture UV offset animation (done once for entire line).
*/
unsigned int delta = WW3D::Get_Sync_Time() - LastUsedSyncTime;
float del = (float)delta;
Vector2 uv_offset = CurrentUVOffset + UVOffsetDeltaPerMS * del;
// ensure offsets are in [0, 1] range:
uv_offset.X = uv_offset.X - floor(uv_offset.X);
uv_offset.Y = uv_offset.Y - floor(uv_offset.Y);
// Update state
CurrentUVOffset = uv_offset;
LastUsedSyncTime = WW3D::Get_Sync_Time();
// Used later
TextureMapMode map_mode = Get_Texture_Mapping_Mode();
/*
** Process line geometry:
*/
// This has been tweaked to produce empirically good results.
const float parallel_factor = 0.9f;
// We reduce the chunk size to take account of subdivision levels (so that the # of points
// after subdivision will be no higher than the allowed maximum). We know this will not reduce
// the chunk size below 2, since the chunk size must be at least two to the power of the
// maximum allowable number of subdivisions. The plus 1 is because #points = #segments + 1.
unsigned int chunk_size = (SEGLINE_CHUNK_SIZE >> SubdivisionLevel) + 1;
if (chunk_size > num_points) chunk_size = num_points;
// Chunk through the points (we increment by chunk_size - 1 because the last point of this
// chunk must be reused as the first point of the next chunk. This is also the reason we stop
// when chidx = NumPoints - 1: the last point has already been processed in the previous
// iteration so we don't need another one).
for (unsigned int chidx = 0; chidx < num_points - 1; chidx += (chunk_size - 1)) {
unsigned int point_cnt = num_points - chidx;
point_cnt = MIN(point_cnt, chunk_size);
// We use these different loop indices (which loop INSIDE a chunk) to improve readability:
unsigned int pidx; // Point index
unsigned int sidx; // Segment index
unsigned int iidx; // Intersection index
/*
** Transform points in chunk from objectspace to eyespace:
*/
Vector3 xformed_pts[MAX_SEGLINE_POINT_BUFFER_SIZE];
Matrix3D view2( view[0].X,view[0].Y,view[0].Z,view[0].W,
view[1].X,view[1].Y,view[1].Z,view[1].W,
view[2].X,view[2].Y,view[2].Z,view[2].W);
Matrix3D modelview=view2*transform;
VectorProcessorClass::Transform(&xformed_pts[0],
&points[chidx], modelview, point_cnt);
/*
** Prepare v parameter per point - used for texture mapping (esp. tiled mapping mode)
*/
float base_tex_v[MAX_SEGLINE_POINT_BUFFER_SIZE];
float u_values[2];
switch (map_mode) {
case UNIFORM_WIDTH_TEXTURE_MAP:
for (pidx = 0; pidx < point_cnt; pidx++) {
// All 0
base_tex_v[pidx] = 0.0f;
}
u_values[0] = 0.0f;
u_values[1] = 1.0f;
break;
case UNIFORM_LENGTH_TEXTURE_MAP:
for (pidx = 0; pidx < point_cnt; pidx++) {
// Increasing V
base_tex_v[pidx] = (float)(pidx + chidx) * TextureTileFactor;
}
u_values[0] = 0.0f;
u_values[1] = 0.0f;
break;
case TILED_TEXTURE_MAP:
for (pidx = 0; pidx < point_cnt; pidx++) {
// Increasing V
base_tex_v[pidx] = (float)(pidx + chidx) * TextureTileFactor;
}
u_values[0] = 0.0f;
u_values[1] = 1.0f;
break;
}
/*
** Fractal noise recursive subdivision:
** We find the midpoint for each section, apply a random offset, and recurse. We also find
** the average V coordinate of the endpoints which is the midpoint V (for tiled texture
** mapping).
*/
Vector3 xformed_subdiv_pts[MAX_SEGLINE_POINT_BUFFER_SIZE];
float subdiv_tex_v[MAX_SEGLINE_POINT_BUFFER_SIZE];
unsigned int sub_point_cnt;
subdivision_util(point_cnt, xformed_pts, base_tex_v, &sub_point_cnt, xformed_subdiv_pts, subdiv_tex_v);
// Start using subdivided points from now on
Vector3 *points = xformed_subdiv_pts;
float *tex_v = subdiv_tex_v;
point_cnt = sub_point_cnt;
/*
** Calculate line segment edge planes:
*/
// For each line segment find the two silhouette planes from eyepoint to the line segment
// cylinder. To simplify we do not find the tangent planes but intersect the cylinder with a
// plane passing through its axis and perpendicular to the eye vector, find the edges of the
// resulting rectangle, and create planes through these edges and the eyepoint.
// Note that these planes are represented as a single normal rather than a normal and a
// distance; this is because they pass through the origin (eyepoint) so their distance is
// always zero.
// Since the line has thickness, each segment has two edges. We name these 'top' and
// 'bottom' - note however that the top/bottom distinction does not relate to screen
// up/down and remains consistent throughout the segmented line.
enum SegmentEdge {
FIRST_EDGE = 0, // For loop conditions
TOP_EDGE = 0, // Top Edge
BOTTOM_EDGE = 1, // Bottom Edge
MAX_EDGE = 1, // For loop conditions
NUM_EDGES = 2 // For array allocations
};
bool switch_edges = false;
// We have dummy segments for "before the first point" and "after the last point" - in these
// segments the top and bottom edge are the same - they are a perpendicular plane defined by
// the endpoint vertices. This is so we can merge intersections properly for the first and
// last points.
struct LineSegment {
Vector3 StartPlane;
Vector3 EdgePlane[NUM_EDGES];
};
// # segments = numpoints + 1 (numpoints - 1, plus two dummy segments)
LineSegment segment[MAX_SEGLINE_POINT_BUFFER_SIZE + 1];
// Intersections. This has data for two edges (top or bottom) intersecting.
struct LineSegmentIntersection {
unsigned int PointCount; // How many points does this intersection represent
unsigned int NextSegmentID; // ID of segment after this intersection
Vector3 Direction; // Calculated intersection direction line
Vector3 Point; // Averaged 3D point on the line which this represents
float TexV; // Averaged texture V coordinate of points
bool Fold; // Does the line fold over at this intersection?
bool Parallel; // Edges at this intersection are parallel (or almost-)
};
// Used to calculate the edge planes
float radius = Width * 0.5f;
// The number of intersections is the number of points minus 2. However, we store
// intersection records for the first and last point, even though they are not really
// intersections. The reason we do this is for the intersection merging - the vertices for
// the first and last points can get merged just like any other intersection. Also, we have
// a dummy intersection record before the first point - this is because we want "previous
// segments" for the first point and each intersection only has an index for the next
// segment.
LineSegmentIntersection intersection[MAX_SEGLINE_POINT_BUFFER_SIZE + 1][NUM_EDGES];
for (sidx = 1; sidx < point_cnt; sidx++) { // #segments = #points - 1 (+ 2 dummy segments)
Vector3 &curr_point = points[sidx - 1];
Vector3 &next_point = points[sidx];
// We temporarily store the segment direction in the segment's StartPlane (since it is
// used to calculate the StartPlane later).
Vector3 &segdir = segment[sidx].StartPlane;
segdir = next_point - curr_point;
segdir.Normalize();
// Find nearest point on infinite line to eye (origin)
Vector3 nearest = curr_point + segdir * -Vector3::Dot_Product(segdir, curr_point);
// Find top and bottom points on cylinder
Vector3 offset;
Vector3::Cross_Product(segdir, nearest, &offset);
offset.Normalize();
Vector3 top = curr_point + offset * radius;
Vector3 bottom = curr_point + offset * -radius;
// Find planes through top/bottom points and eyepoint. In addition to the two points, we
// know that the planes are parallel to the line segment.
Vector3 top_normal;
Vector3::Cross_Product(top, segdir, &top_normal);
top_normal.Normalize();
segment[sidx].EdgePlane[TOP_EDGE] = top_normal;
Vector3 bottom_normal;
Vector3::Cross_Product(segdir, bottom, &bottom_normal);
bottom_normal.Normalize();
segment[sidx].EdgePlane[BOTTOM_EDGE] = bottom_normal;
// If the visual angle between the previous and current line segments (we use the angle
// between the planes defined by each line segment and the eyepoint) is less than 90
// degrees, switch the top and bottom edges for the current and subsequent segments and
// mark the intersection as having a fold
if (sidx > 1) {
Vector3 prev_plane;
Vector3::Cross_Product(points[sidx - 2], curr_point, &prev_plane);
prev_plane.Normalize();
Vector3 curr_plane;
Vector3::Cross_Product(curr_point, next_point, &curr_plane);
curr_plane.Normalize();
if (Vector3::Dot_Product(prev_plane, curr_plane) < 0.0f) {
switch_edges = !switch_edges;
intersection[sidx][TOP_EDGE].Fold = true;
intersection[sidx][BOTTOM_EDGE].Fold = true;
} else {
intersection[sidx][TOP_EDGE].Fold = false;
intersection[sidx][BOTTOM_EDGE].Fold = false;
}
}
if (switch_edges) {
// We switch signs so the normals will always point inwards
segment[sidx].EdgePlane[TOP_EDGE] = -bottom_normal;
segment[sidx].EdgePlane[BOTTOM_EDGE] = -top_normal;
}
}
// The two dummy segments for the clipping edges of the first and last real segments will be
// defined later, with the first and last intersections.
/*
** Calculate segment edge intersections:
*/
unsigned int numsegs = point_cnt - 1; // Doesn't include the two dummy segments
unsigned int num_intersections[NUM_EDGES];
// These include the 1st, last point "intersections", not the pre-first dummy intersection
num_intersections[TOP_EDGE] = point_cnt;
num_intersections[BOTTOM_EDGE] = point_cnt;
// Initialize pre-first point dummy intersection record (only NextSegmentID will be used).
intersection[0][TOP_EDGE].PointCount = 0; // Should never be used
intersection[0][TOP_EDGE].NextSegmentID = 0; // Points to first dummy segment
intersection[0][TOP_EDGE].Direction.Set(1,0,0); // Should never be used
intersection[0][TOP_EDGE].Point.Set(0,0,0); // Should never be used
intersection[0][TOP_EDGE].TexV = 0.0f; // Should never be used
intersection[0][TOP_EDGE].Fold = true; // Should never be used
intersection[0][TOP_EDGE].Parallel = false; // Should never be used
intersection[0][BOTTOM_EDGE].PointCount = 0; // Should never be used
intersection[0][BOTTOM_EDGE].NextSegmentID = 0; // Points to first dummy segment
intersection[0][BOTTOM_EDGE].Point.Set(0,0,0); // Should never be used
intersection[0][BOTTOM_EDGE].TexV = 0.0f; // Should never be used
intersection[0][BOTTOM_EDGE].Direction.Set(1,0,0); // Should never be used
intersection[0][BOTTOM_EDGE].Fold = true; // Should never be used
intersection[0][BOTTOM_EDGE].Parallel = false; // Should never be used
// Initialize first point "intersection" record.
intersection[1][TOP_EDGE].PointCount = 1;
intersection[1][TOP_EDGE].NextSegmentID = 1;
intersection[1][TOP_EDGE].Point = points[0];
intersection[1][TOP_EDGE].TexV = tex_v[0];
intersection[1][TOP_EDGE].Fold = true;
intersection[1][TOP_EDGE].Parallel = false;
intersection[1][BOTTOM_EDGE].PointCount = 1;
intersection[1][BOTTOM_EDGE].NextSegmentID = 1;
intersection[1][BOTTOM_EDGE].Point = points[0];
intersection[1][BOTTOM_EDGE].TexV = tex_v[0];
intersection[1][BOTTOM_EDGE].Fold = true;
intersection[1][BOTTOM_EDGE].Parallel = false;
// Find closest point to 1st top/bottom segment edge plane, and convert to direction vector
// and dummy segment edge plane.
Vector3 top;
Vector3 bottom;
Vector3 &first_point = points[0];
Vector3 *first_plane = &(segment[1].EdgePlane[0]);
top = first_point - first_plane[TOP_EDGE] * Vector3::Dot_Product(first_plane[TOP_EDGE], first_point);
top.Normalize();
intersection[1][TOP_EDGE].Direction = top;
bottom = first_point - first_plane[BOTTOM_EDGE] * Vector3::Dot_Product(first_plane[BOTTOM_EDGE], first_point);
bottom.Normalize();
intersection[1][BOTTOM_EDGE].Direction = bottom;
Vector3 segdir = points[1] - points[0];
segdir.Normalize(); // Is this needed? Probably not - remove later when all works
Vector3 start_pl;
Vector3::Cross_Product(top, bottom, &start_pl);
start_pl.Normalize();
float dp = Vector3::Dot_Product(segdir, start_pl);
if (dp > 0.0f) {
segment[0].StartPlane = segment[0].EdgePlane[TOP_EDGE] = segment[0].EdgePlane[BOTTOM_EDGE] = start_pl;
} else {
segment[0].StartPlane = segment[0].EdgePlane[TOP_EDGE] = segment[0].EdgePlane[BOTTOM_EDGE] = -start_pl;
}
// Initialize StartPlane for the first "real" segment
segment[1].StartPlane = segment[0].StartPlane;
// Initialize last point "intersection" record.
unsigned int last_isec = num_intersections[TOP_EDGE]; // Same # top, bottom intersections
intersection[last_isec][TOP_EDGE].PointCount = 1;
intersection[last_isec][TOP_EDGE].NextSegmentID = numsegs + 1; // Last dummy segment
intersection[last_isec][TOP_EDGE].Point = points[point_cnt - 1];
intersection[last_isec][TOP_EDGE].TexV = tex_v[point_cnt - 1];
intersection[last_isec][TOP_EDGE].Fold = true;
intersection[last_isec][TOP_EDGE].Parallel = false;
intersection[last_isec][BOTTOM_EDGE].PointCount = 1;
intersection[last_isec][BOTTOM_EDGE].NextSegmentID = numsegs + 1;// Last dummy segment
intersection[last_isec][BOTTOM_EDGE].Point = points[point_cnt - 1];
intersection[last_isec][BOTTOM_EDGE].TexV = tex_v[point_cnt - 1];
intersection[last_isec][BOTTOM_EDGE].Fold = true;
intersection[last_isec][BOTTOM_EDGE].Parallel = false;
// Find closest point to last top/bottom segment edge plane, and convert to direction vector
// and dummy segment edge vector
Vector3 &last_point = points[point_cnt - 1];
Vector3 *last_plane = &(segment[numsegs].EdgePlane[0]);
top = last_point - last_plane[TOP_EDGE] * Vector3::Dot_Product(last_plane[TOP_EDGE], last_point);
top.Normalize();
intersection[last_isec][TOP_EDGE].Direction = top;
bottom = last_point - last_plane[BOTTOM_EDGE] * Vector3::Dot_Product(last_plane[BOTTOM_EDGE], last_point);
bottom.Normalize();
intersection[last_isec][BOTTOM_EDGE].Direction = bottom;
segdir = points[point_cnt - 1] - points[point_cnt - 2];
segdir.Normalize(); // Is this needed? Probably not - remove later when all works
Vector3::Cross_Product(top, bottom, &start_pl);
start_pl.Normalize();
dp = Vector3::Dot_Product(segdir, start_pl);
if (dp > 0.0f) {
segment[numsegs + 1].StartPlane = segment[numsegs + 1].EdgePlane[TOP_EDGE] =
segment[numsegs + 1].EdgePlane[BOTTOM_EDGE] = start_pl;
} else {
segment[numsegs + 1].StartPlane = segment[numsegs + 1].EdgePlane[TOP_EDGE] =
segment[numsegs + 1].EdgePlane[BOTTOM_EDGE] = -start_pl;
}
// Calculate midpoint segment intersections. There are 2 segment intersections for each
// point: top and bottom (due to the fact that the segments have width, so they have a top
// edge and a bottom edge). Note that the top/bottom distinction does not relate to screen
// up/down. Since each segment edge is represented by a plane passing through the origin
// (eyepoint), the intersection of two such is a line passing through the origin, which is
// represented as a normalized direction vector.
// We use both segment intersections to define the startplane for the segment which begins
// at that intersection.
float vdp;
for (iidx = 2; iidx < num_intersections[TOP_EDGE]; iidx++) {
// Relevant midpoint:
Vector3 &midpoint = points[iidx - 1];
float mid_tex_v = tex_v[iidx - 1];
// Initialize misc. fields
intersection[iidx][TOP_EDGE].PointCount = 1;
intersection[iidx][TOP_EDGE].NextSegmentID = iidx;
intersection[iidx][TOP_EDGE].Point = midpoint;
intersection[iidx][TOP_EDGE].TexV = mid_tex_v;
intersection[iidx][BOTTOM_EDGE].PointCount = 1;
intersection[iidx][BOTTOM_EDGE].NextSegmentID = iidx;
intersection[iidx][BOTTOM_EDGE].Point = midpoint;
intersection[iidx][BOTTOM_EDGE].TexV = mid_tex_v;
// Intersection calculation: if the top/bottom planes of both adjoining segments are not
// very close to being parallel, intersect them to get top/bottom intersection lines. If
// the planes are almost parallel, pick one, find the point on the plane closest to the
// midpoint, and convert that point to a line direction vector.
// Top:
vdp = Vector3::Dot_Product(segment[iidx - 1].EdgePlane[TOP_EDGE], segment[iidx].EdgePlane[TOP_EDGE]);
if (fabs(vdp) < parallel_factor) {
// Not parallel - intersect planes to get line (get vector, normalize it, ensure it is
// pointing towards the midpoint)
Vector3::Cross_Product(segment[iidx - 1].EdgePlane[TOP_EDGE], segment[iidx].EdgePlane[TOP_EDGE],
&(intersection[iidx][TOP_EDGE].Direction));
intersection[iidx][TOP_EDGE].Direction.Normalize();
if (Vector3::Dot_Product(intersection[iidx][TOP_EDGE].Direction, midpoint) < 0.0f) {
intersection[iidx][TOP_EDGE].Direction = -intersection[iidx][TOP_EDGE].Direction;
}
intersection[iidx][TOP_EDGE].Parallel = false;
} else {
// Parallel (or almost): find point on av. plane closest to midpoint, convert to line
// Ensure average calculation is numerically stable:
Vector3 pl;
if (vdp > 0.0f) {
pl = segment[iidx - 1].EdgePlane[TOP_EDGE] + segment[iidx].EdgePlane[TOP_EDGE];
} else {
pl = segment[iidx - 1].EdgePlane[TOP_EDGE] - segment[iidx].EdgePlane[TOP_EDGE];
}
pl.Normalize();
intersection[iidx][TOP_EDGE].Direction = midpoint - pl * Vector3::Dot_Product(pl, midpoint);
intersection[iidx][TOP_EDGE].Direction.Normalize();
intersection[iidx][TOP_EDGE].Parallel = true;
}
// Bottom:
vdp = Vector3::Dot_Product(segment[iidx - 1].EdgePlane[BOTTOM_EDGE], segment[iidx].EdgePlane[BOTTOM_EDGE]);
if (fabs(vdp) < parallel_factor) {
// Not parallel - intersect planes to get line (get vector, normalize it, ensure it is
// pointing towards the midpoint)
Vector3::Cross_Product(segment[iidx - 1].EdgePlane[BOTTOM_EDGE], segment[iidx].EdgePlane[BOTTOM_EDGE],
&(intersection[iidx][BOTTOM_EDGE].Direction));
intersection[iidx][BOTTOM_EDGE].Direction.Normalize();
if (Vector3::Dot_Product(intersection[iidx][BOTTOM_EDGE].Direction, midpoint) < 0.0f) {
intersection[iidx][BOTTOM_EDGE].Direction = -intersection[iidx][BOTTOM_EDGE].Direction;
}
intersection[iidx][BOTTOM_EDGE].Parallel = false;
} else {
// Parallel (or almost): find point on av. plane closest to midpoint, convert to line
// Ensure average calculation is numerically stable:
Vector3 pl;
if (vdp > 0.0f) {
pl = segment[iidx - 1].EdgePlane[BOTTOM_EDGE] + segment[iidx].EdgePlane[BOTTOM_EDGE];
} else {
pl = segment[iidx - 1].EdgePlane[BOTTOM_EDGE] - segment[iidx].EdgePlane[BOTTOM_EDGE];
}
pl.Normalize();
intersection[iidx][BOTTOM_EDGE].Direction = midpoint - pl * Vector3::Dot_Product(pl, midpoint);
intersection[iidx][BOTTOM_EDGE].Direction.Normalize();
intersection[iidx][BOTTOM_EDGE].Parallel = true;
}
// Find StartPlane:
Vector3::Cross_Product(intersection[iidx][TOP_EDGE].Direction, intersection[iidx][BOTTOM_EDGE].Direction, &start_pl);
start_pl.Normalize();
dp = Vector3::Dot_Product(segment[iidx].StartPlane, start_pl);
if (dp > 0.0f) {
segment[iidx].StartPlane = start_pl;
} else {
segment[iidx].StartPlane = -start_pl;
}
} // for iidx
/*
** Intersection merging: when an intersection is inside an adjacent segment and certain
** other conditions hold true, we need to merge intersections to avoid visual glitches
** caused by the polys folding over on themselves.
*/
if (Is_Merge_Intersections()) {
// Since we are merging the intersections in-place, we have two index variables, a "read
// index" and a "write index".
unsigned int iidx_r;
unsigned int iidx_w;
// The merges will be repeated in multiple passes until none are performed. The reason
// for this is that one merge may cause the need for another merge elsewhere.
bool merged = true;
while (merged) {
merged = false;
SegmentEdge edge;
for (edge = FIRST_EDGE; edge <= MAX_EDGE; edge = (SegmentEdge)((int)edge + 1)) {
// Merge top and bottom edge intersections: loop through the intersections from the
// first intersection to the penultimate intersection, for each intersection check
// if it needs to be merged with the next one (which is why the loop doesn't go all
// the way to the last intersection). We start at 1 because 0 is the dummy
// "pre-first-point" intersection.
unsigned int num_isects = num_intersections[edge]; // Capture here because will change inside loop
for (iidx_r = 1, iidx_w = 1; iidx_r < num_isects; iidx_r++, iidx_w++) {
// Check for either of two possible reasons to merge this intersection with the
// next: either the segment on the far side of the next intersection overlaps
// this intersection, or the previous segment overlaps the next intersection.
// Note that some other conditions need to be true as well.
// Note: iidx_r is used for anything at or after the current position, iidx_w is
// used for anything before the current position (previous positions have
// potentially already been merged).
// Note: iidx_r is used for anything at or after the current position, iidx_w is
// used for anything before the current position (previous positions have
// potentially already been merged).
LineSegmentIntersection *curr_int = &(intersection[iidx_r][edge]);
LineSegmentIntersection *next_int = &(intersection[iidx_r + 1][edge]);
LineSegmentIntersection *write_int = &(intersection[iidx_w][edge]);
LineSegmentIntersection *prev_int = &(intersection[iidx_w - 1][edge]);
LineSegment *next_seg = &(segment[next_int->NextSegmentID]);
LineSegment *curr_seg = &(segment[curr_int->NextSegmentID]);
LineSegment *prev_seg = &(segment[prev_int->NextSegmentID]);
// If this intersection is inside both the start plane and the segment edge
// plane of the segment after the next intersection, merge this edge
// intersection and the next. We repeat merging until no longer needed.
// NOTE - we do not merge across a fold.
while ( (!next_int->Fold &&
(Vector3::Dot_Product(curr_int->Direction, next_seg->StartPlane) > 0.0f) &&
(Vector3::Dot_Product(curr_int->Direction, next_seg->EdgePlane[edge]) > 0.0f )) ||
(!curr_int->Fold &&
(Vector3::Dot_Product(next_int->Direction, -curr_seg->StartPlane) > 0.0f) &&
(Vector3::Dot_Product(next_int->Direction, prev_seg->EdgePlane[edge]) > 0.0f )) ) {
// First calculate location of merged intersection - this is so we can abort
// the merge if it yields funky results.
// Find mean point (weighted so all points have same weighting)
unsigned int new_count = curr_int->PointCount + next_int->PointCount;
float oo_new_count = 1.0f / (float)new_count;
float curr_factor = oo_new_count * (float)curr_int->PointCount;
float next_factor = oo_new_count * (float)curr_int->PointCount;
Vector3 new_point = curr_int->Point * curr_factor + next_int->Point * next_factor;
float new_tex_v = curr_int->TexV * curr_factor + next_int->TexV * next_factor;
// Calculate new intersection direction by intersecting prev_seg with next_seg
bool new_parallel;
Vector3 new_direction;
vdp = Vector3::Dot_Product(prev_seg->EdgePlane[edge], next_seg->EdgePlane[edge]);
if (fabs(vdp) < parallel_factor) {
// Not parallel - intersect planes to get line (get vector, normalize it,
// ensure it is pointing towards the current point)
Vector3::Cross_Product(prev_seg->EdgePlane[edge], next_seg->EdgePlane[edge], &new_direction);
new_direction.Normalize();
if (Vector3::Dot_Product(new_direction, new_point) < 0.0f) {
new_direction = -new_direction;
}
new_parallel = false;
} else {
// Parallel (or almost). If the current intersection is not parallel, take
// the average plane and intersect it with the skipped plane. If the
// current intersection is parallel, find the average plane, and find the
// direction vector on it closest to the current intersections direction
// vector.
// Ensure average calculation is numerically stable:
Vector3 pl;
if (vdp > 0.0f) {
pl = prev_seg->EdgePlane[edge] + next_seg->EdgePlane[edge];
} else {
pl = prev_seg->EdgePlane[edge] - next_seg->EdgePlane[edge];
}
pl.Normalize();
if (curr_int->Parallel) {
new_direction = new_direction - pl * Vector3::Dot_Product(pl, new_direction);
new_direction.Normalize();
} else {
Vector3::Cross_Product(curr_seg->EdgePlane[edge], pl, &new_direction);
new_direction.Normalize();
}
new_parallel = true;
}
// Now check to see if the merge caused any funky results - if so abort it.
// Currently we check to see if the distance of the direction from the two
// points is larger than the radius times the merge_abort factor.
if (MergeAbortFactor > 0.0f) {
float abort_dist = radius * MergeAbortFactor;
float abort_dist2 = abort_dist * abort_dist;
Vector3 diff_curr = curr_int->Point -
new_direction * Vector3::Dot_Product(curr_int->Point, new_direction);
if (diff_curr.Length2() > abort_dist2) break;
Vector3 next_curr = next_int->Point -
new_direction * Vector3::Dot_Product(next_int->Point, new_direction);
if (next_curr.Length2() > abort_dist2) break;
}
// Merge edge intersections (curr_int and next_int) into curr_int
merged = true;
curr_int->Direction = new_direction;
curr_int->Parallel = new_parallel;
curr_int->Point = new_point;
curr_int->TexV = new_tex_v;
curr_int->PointCount = new_count;
curr_int->NextSegmentID = next_int->NextSegmentID;
curr_int->Fold = curr_int->Fold || next_int->Fold;
// Decrement number of edge intersections
num_intersections[edge]--;
// Advance iidx_r to shift subsequent entries backwards in result.
iidx_r++;
// If we are at the end then break:
if (iidx_r == num_isects) {
break;
}
// Advance next_int and next_seg.
next_int = &(intersection[iidx_r + 1][edge]);
next_seg = &(segment[next_int->NextSegmentID]);
} // while <merging needed>
// Copy from "read index" to "write index"
write_int->PointCount = curr_int->PointCount;
write_int->NextSegmentID = curr_int->NextSegmentID;
write_int->Point = curr_int->Point;
write_int->TexV = curr_int->TexV;
write_int->Direction = curr_int->Direction;
write_int->Fold = curr_int->Fold;
} // for iidx
// If iidx_r is exactly equal to num_isects (rather than being larger by one) at this
// point, this means that the last intersection was not merged with the previous one. In
// this case, we need to do one last copy:
if (iidx_r == num_isects) {
LineSegmentIntersection *write_int = &(intersection[iidx_w][edge]);
LineSegmentIntersection *curr_int = &(intersection[iidx_r][edge]);
write_int->PointCount = curr_int->PointCount;
write_int->NextSegmentID = curr_int->NextSegmentID;
write_int->Point = curr_int->Point;
write_int->TexV = curr_int->TexV;
write_int->Direction = curr_int->Direction;
write_int->Fold = curr_int->Fold;
}
#ifdef ENABLE_WWDEBUGGING
// Testing code - ensure total PointCount fits the number of points
unsigned int total_cnt = 0;
for (unsigned int nidx = 0; nidx <= num_intersections[edge]; nidx++) {
total_cnt += intersection[nidx][edge].PointCount;
}
assert(total_cnt == point_cnt);
#endif
} // for edge
} // while (merged)
} // if (Is_Merge_Intersections())
/*
** Find vertex positions, generate vertices and triangles:
** Since we can have top/bottom intersections merged, we need to skip points if both the top
** and bottom intersections are merged, generate triangle fans if one of the sides is merged
** and the other isnt, and generate triangle strips otherwise.
*/
// Configure vertex array and setup renderer.
unsigned int vnum = num_intersections[TOP_EDGE] + num_intersections[BOTTOM_EDGE];
VertexFormatXYZDUV1 *vArray=new VertexFormatXYZDUV1[vnum];
TriIndex v_index_array[MAX_SEGLINE_POLY_BUFFER_SIZE];
// Vertex and triangle indices
unsigned int vidx = 0;
unsigned int tidx = 0;
// GENERALIZE FOR WHEN NO TEXTURE (DO NOT SET UV IN THESE CASES? NEED TO GENERALIZE FOR DIFFERENT TEXTURING MODES ANYWAY).
// "Prime the pump" with two vertices (pick nearest point on each direction line):
Vector3 &top_dir = intersection[1][TOP_EDGE].Direction;
top = top_dir * Vector3::Dot_Product(points[0], top_dir);
Vector3 &bottom_dir = intersection[1][BOTTOM_EDGE].Direction;
bottom = bottom_dir * Vector3::Dot_Product(points[0], bottom_dir);
vArray[vidx].x = top.X;
vArray[vidx].y = top.Y;
vArray[vidx].z = top.Z;
vArray[vidx].u1 = u_values[0] + uv_offset.X;
vArray[vidx].v1 = intersection[1][TOP_EDGE].TexV + uv_offset.Y;
vidx++;
vArray[vidx].x = bottom.X;
vArray[vidx].y = bottom.Y;
vArray[vidx].z = bottom.Z;
vArray[vidx].u1 = u_values[1] + uv_offset.X;
vArray[vidx].v1 = intersection[1][BOTTOM_EDGE].TexV + uv_offset.Y;
vidx++;
unsigned int last_top_vidx = 0;
unsigned int last_bottom_vidx = 1;
// Loop over intersections, create new vertices and triangles.
unsigned int top_int_idx = 1; // Skip "pre-first-point" dummy intersection
unsigned int bottom_int_idx = 1; // Skip "pre-first-point" dummy intersection
pidx = 0;
unsigned int residual_top_points = intersection[1][TOP_EDGE].PointCount;
unsigned int residual_bottom_points = intersection[1][BOTTOM_EDGE].PointCount;
// Reduce both pointcounts by the same amount so the smaller one is 1 (skip points)
unsigned int delta = MIN(residual_top_points, residual_bottom_points) - 1;
residual_top_points -= delta;
residual_bottom_points -= delta;
pidx += delta;
for (; ; ) {
if (residual_top_points == 1 && residual_bottom_points == 1) {
// Advance both intersections, creating a tristrip segment
v_index_array[tidx].I = last_top_vidx;
v_index_array[tidx].J = last_bottom_vidx;
v_index_array[tidx].K = vidx;
tidx++;
v_index_array[tidx].I = last_bottom_vidx;
v_index_array[tidx].J = vidx + 1;
v_index_array[tidx].K = vidx;
tidx++;
last_top_vidx = vidx;
last_bottom_vidx = vidx + 1;
// Advance both intersections.
top_int_idx++;
bottom_int_idx++;
residual_top_points = intersection[top_int_idx][TOP_EDGE].PointCount;
residual_bottom_points = intersection[bottom_int_idx][BOTTOM_EDGE].PointCount;
// Advance point index (must do here because the new point index is used below):
pidx++;
// Generate two vertices for next point by picking nearest point on each direction line
Vector3 &top_dir = intersection[top_int_idx][TOP_EDGE].Direction;
top = top_dir * Vector3::Dot_Product(points[pidx], top_dir);
Vector3 &bottom_dir = intersection[bottom_int_idx][BOTTOM_EDGE].Direction;
bottom = bottom_dir * Vector3::Dot_Product(points[pidx], bottom_dir);
vArray[vidx].x = top.X;
vArray[vidx].y = top.Y;
vArray[vidx].z = top.Z;
vArray[vidx].u1 = u_values[0] + uv_offset.X;
vArray[vidx].v1 = intersection[top_int_idx][TOP_EDGE].TexV + uv_offset.Y;
vidx++;
vArray[vidx].x = bottom.X;
vArray[vidx].y = bottom.Y;
vArray[vidx].z = bottom.Z;
vArray[vidx].u1 = u_values[1] + uv_offset.X;
vArray[vidx].v1 = intersection[bottom_int_idx][BOTTOM_EDGE].TexV + uv_offset.Y;
vidx++;
} else {
// Exactly one of the pointcounts is greater than one - advance it and draw one triangle
if (residual_top_points > 1) {
// Draw one triangle (fan segment)
v_index_array[tidx].I = last_top_vidx;
v_index_array[tidx].J = last_bottom_vidx;
v_index_array[tidx].K = vidx;
tidx++;
last_bottom_vidx = vidx;
// Advance bottom intersection only
residual_top_points--;
bottom_int_idx++;
residual_bottom_points = intersection[bottom_int_idx][BOTTOM_EDGE].PointCount;
// Advance point index (must do here because the new point index is used below):
pidx++;
// Generate bottom vertex by picking nearest point on bottom direction line
Vector3 &bottom_dir = intersection[bottom_int_idx][BOTTOM_EDGE].Direction;
bottom = bottom_dir * Vector3::Dot_Product(points[pidx], bottom_dir);
vArray[vidx].x = bottom.X;
vArray[vidx].y = bottom.Y;
vArray[vidx].z = bottom.Z;
vArray[vidx].u1 = u_values[1] + uv_offset.X;
vArray[vidx].v1 = intersection[bottom_int_idx][BOTTOM_EDGE].TexV + uv_offset.Y;
vidx++;
} else {
// residual_bottom_points > 1
// Draw one triangle (fan segment)
v_index_array[tidx].I = last_top_vidx;
v_index_array[tidx].J = last_bottom_vidx;
v_index_array[tidx].K = vidx;
tidx++;
last_top_vidx = vidx;
// Advance top intersection only
residual_bottom_points--;
top_int_idx++;
residual_top_points = intersection[top_int_idx][TOP_EDGE].PointCount;
// Advance point index (must do here because the new point index is used below):
pidx++;
// Generate top vertex by picking nearest point on top direction line
Vector3 &top_dir = intersection[top_int_idx][TOP_EDGE].Direction;
top = top_dir * Vector3::Dot_Product(points[pidx], top_dir);
vArray[vidx].x = top.X;
vArray[vidx].y = top.Y;
vArray[vidx].z = top.Z;
vArray[vidx].u1 = u_values[0] + uv_offset.X;
vArray[vidx].v1 = intersection[top_int_idx][TOP_EDGE].TexV + uv_offset.Y;
vidx++;
}
}
// Reduce both pointcounts by the same amount so the smaller one is 1 (skip points)
delta = MIN(residual_top_points, residual_bottom_points) - 1;
residual_top_points -= delta;
residual_bottom_points -= delta;
pidx += delta;
// Exit conditions
if ( (top_int_idx >= num_intersections[TOP_EDGE] && residual_top_points == 1) ||
(bottom_int_idx >= num_intersections[BOTTOM_EDGE] && residual_bottom_points == 1)) {
// Debugging check - if either intersection index is before end, both of them should be
// and the points should be before the end.
assert(top_int_idx == num_intersections[TOP_EDGE]);
assert(bottom_int_idx == num_intersections[BOTTOM_EDGE]);
assert(pidx == point_cnt - 1);
break;
}
}
/*
** Set color, opacity, vertex flags:
*/
// If color is not white or opacity not 100%, enable gradient in shader and in renderer - otherwise disable.
unsigned int rgba;
rgba=DX8Wrapper::Convert_Color(Color,Opacity);
bool rgba_all=(rgba==0xFFFFFFFF);
// Enable sorting if sorting has not been disabled and line is translucent and alpha testing is not enabled.
bool sorting = (!Is_Sorting_Disabled()) && (Shader.Get_Dst_Blend_Func() != ShaderClass::DSTBLEND_ZERO && Shader.Get_Alpha_Test() == ShaderClass::ALPHATEST_DISABLE);
ShaderClass shader = Shader;
shader.Set_Cull_Mode(ShaderClass::CULL_MODE_DISABLE);
VertexMaterialClass *mat;
if (!rgba_all) {
shader.Set_Primary_Gradient(ShaderClass::GRADIENT_MODULATE);
for (vidx = 0; vidx < vnum; vidx++) vArray[vidx].diffuse=rgba;
mat=VertexMaterialClass::Get_Preset(VertexMaterialClass::PRELIT_DIFFUSE);
} else {
shader.Set_Primary_Gradient(ShaderClass::GRADIENT_DISABLE);
mat=VertexMaterialClass::Get_Preset(VertexMaterialClass::PRELIT_NODIFFUSE);
}
// If Texture is non-NULL enable texturing in shader - otherwise disable.
if (Texture) {
shader.Set_Texturing(ShaderClass::TEXTURING_ENABLE);
} else {
shader.Set_Texturing(ShaderClass::TEXTURING_DISABLE);
}
/*
** Render
*/
DynamicVBAccessClass Verts((sorting?BUFFER_TYPE_DYNAMIC_SORTING:BUFFER_TYPE_DYNAMIC_DX8),dynamic_fvf_type,vnum);
// Copy in the data to the VB
{
DynamicVBAccessClass::WriteLockClass Lock(&Verts);
unsigned int i;
unsigned char *vb=(unsigned char*)Lock.Get_Formatted_Vertex_Array();
const FVFInfoClass& fvfinfo=Verts.FVF_Info();
for (i=0; i<vnum; i++)
{
// Copy Locations
((Vector3*)(vb+fvfinfo.Get_Location_Offset()))->X=vArray[i].x;
((Vector3*)(vb+fvfinfo.Get_Location_Offset()))->Y=vArray[i].y;
((Vector3*)(vb+fvfinfo.Get_Location_Offset()))->Z=vArray[i].z;
*(unsigned int*)(vb+fvfinfo.Get_Diffuse_Offset())=vArray[i].diffuse;
((Vector2*)(vb+fvfinfo.Get_Tex_Offset(0)))->U=vArray[i].u1;
((Vector2*)(vb+fvfinfo.Get_Tex_Offset(0)))->V=vArray[i].v1;
vb+=fvfinfo.Get_FVF_Size();
}
} // copy
DynamicIBAccessClass ib_access((sorting?BUFFER_TYPE_DYNAMIC_SORTING:BUFFER_TYPE_DYNAMIC_DX8),tidx*3);
{
unsigned int i;
DynamicIBAccessClass::WriteLockClass lock(&ib_access);
unsigned short* inds=lock.Get_Index_Array();
for (i=0; i<tidx; i++)
{
*inds++=v_index_array[i].I;
*inds++=v_index_array[i].J;
*inds++=v_index_array[i].K;
}
}
DX8Wrapper::Set_Index_Buffer(ib_access,0);
DX8Wrapper::Set_Vertex_Buffer(Verts);
DX8Wrapper::Set_Material(mat);
DX8Wrapper::Set_Texture(0,Texture);
DX8Wrapper::Set_Shader(shader);
if (sorting) {
SortingRendererClass::Insert_Triangles(obj_sphere,0,tidx,0,vnum);
} else {
DX8Wrapper::Draw_Triangles(0,tidx,0,vnum);
}
REF_PTR_RELEASE(mat);
delete [] vArray;
} // Chunking loop
DX8Wrapper::Set_Transform(D3DTS_VIEW,view);
}
void SegLineRendererClass::subdivision_util(unsigned int point_cnt, const Vector3 *xformed_pts,
const float *base_tex_v, unsigned int *p_sub_point_cnt, Vector3 *xformed_subdiv_pts,
float *subdiv_tex_v)
{
// CAUTION: freezing the random offsets will make it more readily apparent that the offsets
// are in camera space rather than worldspace.
int freeze_random = Is_Freeze_Random();
Random3Class randomize;
const float oo_int_max = 1.0f / (float)INT_MAX;
Vector3SolidBoxRandomizer randomizer(Vector3(1,1,1));
Vector3 randvec(0,0,0);
unsigned int sub_pidx = 0;
struct SegLineSubdivision {
Vector3 StartPos;
Vector3 EndPos;
float StartTexV; // V texture coordinate of start point
float EndTexV; // V texture coordinate of end point
float Rand;
unsigned int Level; // Subdivision level
};
SegLineSubdivision stack[2 * MAX_SEGLINE_SUBDIV_LEVELS]; // Maximum number needed
int tos = 0;
for (unsigned int pidx = 0; pidx < point_cnt - 1; pidx++) {
// Subdivide the (pidx, pidx + 1) segment. Produce pidx and all subdivided points up to
// (not including) pidx + 1.
tos = 0;
stack[0].StartPos = xformed_pts[pidx];
stack[0].EndPos = xformed_pts[pidx + 1];
stack[0].StartTexV = base_tex_v[pidx];
stack[0].EndTexV = base_tex_v[pidx + 1];
stack[0].Rand = NoiseAmplitude;
stack[0].Level = 0;
for (; tos >= 0;) {
if (stack[tos].Level == SubdivisionLevel) {
// Generate point location and texture V coordinate
xformed_subdiv_pts[sub_pidx] = stack[tos].StartPos;
subdiv_tex_v[sub_pidx++] = stack[tos].StartTexV;
// Pop
tos--;
} else {
// Recurse down: pop existing entry and push two subdivided ones.
if (freeze_random) {
randvec.Set(randomize * oo_int_max, randomize * oo_int_max, randomize * oo_int_max);
} else {
randomizer.Get_Vector(randvec);
}
stack[tos + 1].StartPos = stack[tos].StartPos;
stack[tos + 1].EndPos = (stack[tos].StartPos + stack[tos].EndPos) * 0.5f + randvec * stack[tos].Rand;
stack[tos + 1].StartTexV = stack[tos].StartTexV;
stack[tos + 1].EndTexV = (stack[tos].StartTexV + stack[tos].EndTexV) * 0.5f;
stack[tos + 1].Rand = stack[tos].Rand * 0.5f;
stack[tos + 1].Level = stack[tos].Level + 1;
stack[tos].StartPos = stack[tos + 1].EndPos;
// stack[tos].EndPos already has the right value
stack[tos].StartTexV = stack[tos + 1].EndTexV;
// stack[tos].EndTexV already has the right value
stack[tos].Rand = stack[tos + 1].Rand;
stack[tos].Level = stack[tos + 1].Level;
tos++;
}
}
}
// Last point
xformed_subdiv_pts[sub_pidx] = xformed_pts[point_cnt - 1];
subdiv_tex_v[sub_pidx++] = base_tex_v[point_cnt - 1];
// Output:
*p_sub_point_cnt = sub_pidx;
}
#endif //0
Reference in a new issue View git blame Copy permalink