/* ** 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 . */ /*********************************************************************************************** *** 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 // 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; iX=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= 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