mirror of
https://gitea.wildfiregames.com/0ad/0ad
synced 2026-06-16 21:34:08 -07:00
157c6af18e
Avoid cases of filenames Update years in terms and other legal(ish) documents Don't update years in license headers, since change is not meaningful Will add linter rule in seperate commit Happy recompiling everyone! Original Patch By: Nescio Comment By: Gallaecio Differential Revision: D2620 This was SVN commit r27786.
203 lines
8.3 KiB
C++
203 lines
8.3 KiB
C++
/* Copyright (C) 2020 Wildfire Games.
|
||
* This file is part of 0 A.D.
|
||
*
|
||
* 0 A.D. 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.
|
||
*
|
||
* 0 A.D. 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 0 A.D. If not, see <http://www.gnu.org/licenses/>.
|
||
*/
|
||
|
||
#ifndef INCLUDED_HELPER_RENDER
|
||
#define INCLUDED_HELPER_RENDER
|
||
|
||
#include <vector>
|
||
|
||
class CSimContext;
|
||
class CVector2D;
|
||
class CVector3D;
|
||
class CFixedVector3D;
|
||
class CMatrix3D;
|
||
class CBoundingBoxAligned;
|
||
class CBoundingBoxOriented;
|
||
|
||
struct SOverlayLine;
|
||
struct SOverlayTexturedLine;
|
||
|
||
struct SDashedLine
|
||
{
|
||
/// Packed array of consecutive dashes' points. Use m_StartIndices to navigate it.
|
||
std::vector<CVector2D> m_Points;
|
||
|
||
/**
|
||
* Start indices in m_Points of each dash. Dash n starts at point m_StartIndices[n] and ends at the point with index
|
||
* m_StartIndices[n+1] - 1, or at the end of the m_Points vector. Use the GetEndIndex(n) convenience method to abstract away the
|
||
* difference and get the (exclusive) end index of dash n.
|
||
*/
|
||
std::vector<size_t> m_StartIndices;
|
||
|
||
/// Returns the (exclusive) end point index (i.e. index within m_Points) of dash n.
|
||
size_t GetEndIndex(size_t i)
|
||
{
|
||
// for the last dash, there is no next starting index, so we need to use the end index of the m_Points array instead
|
||
return (i < m_StartIndices.size() - 1 ? m_StartIndices[i+1] : m_Points.size());
|
||
}
|
||
};
|
||
|
||
namespace SimRender
|
||
{
|
||
|
||
/**
|
||
* Constructs overlay line from given points, conforming to terrain.
|
||
*
|
||
* @param[in] xz List of x,z coordinate pairs representing the line.
|
||
* @param[in,out] overlay Updated overlay line now conforming to terrain.
|
||
* @param[in] floating If true, the line conforms to water as well.
|
||
* @param[in] heightOffset Height above terrain to offset the line.
|
||
*/
|
||
void ConstructLineOnGround(
|
||
const CSimContext& context, const std::vector<float>& xz,
|
||
SOverlayLine& overlay,
|
||
bool floating, float heightOffset = 0.25f);
|
||
|
||
/**
|
||
* Constructs overlay line as a circle with given center and radius, conforming to terrain.
|
||
*
|
||
* @param[in] x,z Coordinates of center of circle.
|
||
* @param[in] radius Radius of circle to construct.
|
||
* @param[in,out] overlay Updated overlay line representing this circle.
|
||
* @param[in] floating If true, the circle conforms to water as well.
|
||
* @param[in] heightOffset Height above terrain to offset the circle.
|
||
* @param heightOffset The vertical offset to apply to points, to raise the line off the terrain a bit.
|
||
*/
|
||
void ConstructCircleOnGround(
|
||
const CSimContext& context, float x, float z, float radius,
|
||
SOverlayLine& overlay,
|
||
bool floating, float heightOffset = 0.25f);
|
||
|
||
/**
|
||
* Constructs overlay line as an outlined circle sector (an arc with straight lines between the
|
||
* endpoints and the circle's center), conforming to terrain.
|
||
*/
|
||
void ConstructClosedArcOnGround(
|
||
const CSimContext& context, float x, float z, float radius,
|
||
float start, float end,
|
||
SOverlayLine& overlay,
|
||
bool floating, float heightOffset = 0.25f);
|
||
|
||
/**
|
||
* Constructs overlay line as rectangle with given center and dimensions, conforming to terrain.
|
||
*
|
||
* @param[in] x,z Coordinates of center of rectangle.
|
||
* @param[in] w,h Width/height dimensions of the rectangle.
|
||
* @param[in] a Clockwise angle to orient the rectangle.
|
||
* @param[in,out] overlay Updated overlay line representing this rectangle.
|
||
* @param[in] floating If true, the rectangle conforms to water as well.
|
||
* @param[in] heightOffset Height above terrain to offset the rectangle.
|
||
*/
|
||
void ConstructSquareOnGround(
|
||
const CSimContext& context, float x, float z, float w, float h, float a,
|
||
SOverlayLine& overlay,
|
||
bool floating, float heightOffset = 0.25f);
|
||
|
||
/**
|
||
* Constructs a solid outline of an arbitrarily-aligned bounding @p box.
|
||
*
|
||
* @param[in] box
|
||
* @param[in,out] overlayLine Updated overlay line representing the oriented box.
|
||
*/
|
||
void ConstructBoxOutline(const CBoundingBoxOriented& box, SOverlayLine& overlayLine);
|
||
|
||
/**
|
||
* Constructs a solid outline of an axis-aligned bounding @p box.
|
||
*
|
||
* @param[in] bound
|
||
* @param[in,out] overlayLine Updated overlay line representing the AABB.
|
||
*/
|
||
void ConstructBoxOutline(const CBoundingBoxAligned& box, SOverlayLine& overlayLine);
|
||
|
||
/**
|
||
* Constructs a simple gimbal outline with the given radius and center.
|
||
*
|
||
* @param[in] center
|
||
* @param[in] radius
|
||
* @param[in,out] out Updated overlay line representing the gimbal.
|
||
* @param[in] numSteps The amount of steps to trace a circle's complete outline. Must be a (strictly) positive multiple of four.
|
||
* For small radii, you can get away with small values; setting this to 4 will create a diamond shape.
|
||
*/
|
||
void ConstructGimbal(const CVector3D& center, float radius, SOverlayLine& out, size_t numSteps = 16);
|
||
|
||
/**
|
||
* Constructs 3D axis marker overlay lines for the given coordinate system.
|
||
* The XYZ axes are colored RGB, respectively.
|
||
*
|
||
* @param[in] coordSystem Specifies the coordinate system.
|
||
* @param[out] outX,outY,outZ Constructed overlay lines for each axes.
|
||
*/
|
||
void ConstructAxesMarker(const CMatrix3D& coordSystem, SOverlayLine& outX, SOverlayLine& outY, SOverlayLine& outZ);
|
||
|
||
/**
|
||
* Updates the given points so each point is averaged with its neighbours, resulting in
|
||
* a somewhat smoother curve, assuming the points are roughly equally spaced.
|
||
*
|
||
* @param[in,out] points List of points to smooth.
|
||
* @param[in] closed if true, then the points are treated as a closed path (the last is connected
|
||
* to the first).
|
||
*/
|
||
void SmoothPointsAverage(std::vector<CVector2D>& points, bool closed);
|
||
|
||
/**
|
||
* Updates the given points to include intermediate points interpolating between the original
|
||
* control points, using a rounded nonuniform spline.
|
||
*
|
||
* @param[in,out] points List of points to interpolate.
|
||
* @param[in] closed if true, then the points are treated as a closed path (the last is connected
|
||
* to the first).
|
||
* @param[in] offset The points are shifted by this distance in a direction 90 degrees clockwise from
|
||
* the direction of the curve.
|
||
* @param[in] segmentSamples Amount of intermediate points to sample between every two control points.
|
||
*/
|
||
void InterpolatePointsRNS(std::vector<CVector2D>& points, bool closed, float offset, int segmentSamples = 4);
|
||
|
||
/**
|
||
* Creates a dashed line from the given line, dash length, and blank space between.
|
||
*
|
||
* @param[in] linePoints List of points specifying the input line.
|
||
* @param[out] dashedLineOut The dashed line returned as a list of smaller lines
|
||
* @param[in] dashLength Length of a single dash. Must be strictly positive.
|
||
* @param[in] blankLength Length of a single blank between dashes. Must be strictly positive.
|
||
*/
|
||
void ConstructDashedLine(const std::vector<CVector2D>& linePoints, SDashedLine& dashedLineOut,
|
||
const float dashLength, const float blankLength);
|
||
|
||
/**
|
||
* Subdivides a list of @p points into segments of maximum length @p maxSegmentLength that are of equal size between every two
|
||
* control points. The resulting subdivided list of points is written back to @p points.
|
||
*
|
||
* @param points The list of intermediate points to subdivide.
|
||
* @param maxSegmentLength The maximum length of a single segment after subdivision. Must be strictly positive.
|
||
* @param closed Should the provided list of points be treated as a closed shape? If true, the resulting list of points will include
|
||
* extra subdivided points between the last and the first point.
|
||
*/
|
||
void SubdividePoints(std::vector<CVector2D>& points, float maxSegmentLength, bool closed);
|
||
|
||
/**
|
||
* Sets the coordinates of a rectangular textured overlay, for example used by selection rings of structures.
|
||
*/
|
||
void ConstructTexturedLineBox(SOverlayTexturedLine& overlay, const CVector2D& origin, const CFixedVector3D& rotation, const float sizeX, const float sizeZ);
|
||
|
||
/**
|
||
* Sets the coordinates of a circular textured overlay, for example by selection rings of units or attack range visualization.
|
||
*/
|
||
void ConstructTexturedLineCircle(SOverlayTexturedLine& overlay, const CVector2D& origin, const float overlay_radius);
|
||
|
||
} // namespace
|
||
|
||
#endif // INCLUDED_HELPER_RENDER
|