Geometry.h

#pragma once
 
#include <Core/CoreDLL.h>
#include <Foundation/Containers/Deque.h>
#include <Foundation/Containers/HybridArray.h>
#include <Foundation/Math/Color.h>
#include <Foundation/Math/Color8UNorm.h>
#include <Foundation/Math/Mat4.h>
#include <Foundation/Math/Vec3.h>
 
class PL_CORE_DLL plGeometry
{
public:
  struct Vertex
  {
    PL_DECLARE_POD_TYPE();
 
    plVec3 m_vPosition;
    plVec3 m_vNormal;
    plVec3 m_vTangent;
    float m_fBiTangentSign;
    plVec2 m_vTexCoord;
    plColor m_Color;
    plVec4U16 m_BoneIndices;
    plColorLinearUB m_BoneWeights;
 
    bool operator<(const Vertex& rhs) const;
    bool operator==(const Vertex& rhs) const;
  };
 
  struct Polygon
  {
    // Reverses the order of vertices.
    void FlipWinding();
 
    plVec3 m_vNormal;
    plHybridArray<plUInt32, 4> m_Vertices;
  };
 
  struct Line
  {
    PL_DECLARE_POD_TYPE();
 
    plUInt32 m_uiStartVertex;
    plUInt32 m_uiEndVertex;
  };
 
  struct GeoOptions
  {
    PL_DECLARE_POD_TYPE();
 
    GeoOptions(){}; // NOLINT: This struct is used before the sourrounding class ends, so it needs a default constructor. = default doesn't work here.
 
    plColor m_Color = plColor(1, 1, 1, 1);         
    plMat4 m_Transform = plMat4::MakeIdentity();   
    plUInt16 m_uiBoneIndex = 0;                    
 
    bool IsFlipWindingNecessary() const;
  };
 
  plDeque<Vertex>& GetVertices() { return m_Vertices; }
 
  plDeque<Polygon>& GetPolygons() { return m_Polygons; }
 
  plDeque<Line>& GetLines() { return m_Lines; }
 
  const plDeque<Vertex>& GetVertices() const { return m_Vertices; }
 
  const plDeque<Polygon>& GetPolygons() const { return m_Polygons; }
 
  const plDeque<Line>& GetLines() const { return m_Lines; }
 
  void Clear();
 
  plUInt32 AddVertex(const plVec3& vPos, const plVec3& vNormal, const plVec2& vTexCoord, const plColor& color, const plVec4U16& vBoneIndices = plVec4U16::MakeZero(), const plColorLinearUB& boneWeights = plColorLinearUB(255, 0, 0, 0));
 
  plUInt32 AddVertex(const plVec3& vPos, const plVec3& vNormal, const plVec2& vTexCoord, const plColor& color, const plVec4U16& vBoneIndices, const plColorLinearUB& boneWeights, const plMat4& mTransform)
  {
    return AddVertex(mTransform.TransformPosition(vPos), mTransform.TransformDirection(vNormal).GetNormalized(), vTexCoord, color, vBoneIndices, boneWeights);
  }
 
  plUInt32 AddVertex(const plVec3& vPos, const plVec3& vNormal, const plVec2& vTexCoord, const plColor& color, const plUInt16 uiBoneIndex, const plMat4& mTransform)
  {
    return AddVertex(mTransform.TransformPosition(vPos), mTransform.TransformDirection(vNormal).GetNormalized(), vTexCoord, color, plVec4U16(uiBoneIndex, 0, 0, 0), plColorLinearUB(255, 0, 0, 0));
  }
 
  plUInt32 AddVertex(const plVec3& vPos, const plVec3& vNormal, const plVec2& vTexCoord, const GeoOptions& options)
  {
    return AddVertex(options.m_Transform.TransformPosition(vPos), options.m_Transform.TransformDirection(vNormal).GetNormalized(), vTexCoord, options.m_Color, plVec4U16(options.m_uiBoneIndex, 0, 0, 0), plColorLinearUB(255, 0, 0, 0));
  }
 
  void AddPolygon(const plArrayPtr<plUInt32>& vertices, bool bFlipWinding);
 
  void AddLine(plUInt32 uiStartVertex, plUInt32 uiEndVertex);
 
  void TriangulatePolygons(plUInt32 uiMaxVerticesInPolygon = 3);
 
  void ComputeFaceNormals();
 
  void ComputeSmoothVertexNormals();
 
  void ComputeTangents();
 
  void ValidateTangents(float fEpsilon = 0.01f);
 
  plUInt32 CalculateTriangleCount() const;
 
  void SetAllVertexBoneIndices(const plVec4U16& vBoneIndices, plUInt32 uiFirstVertex = 0);
 
  void SetAllVertexColor(const plColor& color, plUInt32 uiFirstVertex = 0);
 
  void SetAllVertexTexCoord(const plVec2& vTexCoord, plUInt32 uiFirstVertex = 0);
 
  void Transform(const plMat4& mTransform, bool bTransformPolyNormals);
 
  void Merge(const plGeometry& other);
 
  void AddRectXY(const plVec2& vSize, plUInt32 uiTesselationX = 1, plUInt32 uiTesselationY = 1, const GeoOptions& options = GeoOptions());
 
  void AddBox(const plVec3& vFullExtents, bool bExtraVerticesForTexturing, const GeoOptions& options = GeoOptions());
 
  void AddLineBox(const plVec3& vSize, const GeoOptions& options = GeoOptions());
 
  void AddLineBoxCorners(const plVec3& vSize, float fCornerFraction, const GeoOptions& options = GeoOptions());
 
  void AddPyramid(const plVec3& vSize, bool bCap, const GeoOptions& options = GeoOptions());
 
  void AddGeodesicSphere(float fRadius, plUInt8 uiSubDivisions, const GeoOptions& options = GeoOptions());
 
  void AddCylinder(float fRadiusTop, float fRadiusBottom, float fPositiveLength, float fNegativeLength, bool bCapTop, bool bCapBottom, plUInt16 uiSegments, const GeoOptions& options = GeoOptions(), plAngle fraction = plAngle::MakeFromDegree(360.0f));
 
  void AddCylinderOnePiece(float fRadiusTop, float fRadiusBottom, float fPositiveLength, float fNegativeLength, plUInt16 uiSegments, const GeoOptions& options = GeoOptions());
 
  void AddCone(float fRadius, float fHeight, bool bCap, plUInt16 uiSegments, const GeoOptions& options = GeoOptions());
 
  void AddSphere(float fRadius, plUInt16 uiSegments, plUInt16 uiStacks, const GeoOptions& options = GeoOptions());
 
  void AddHalfSphere(float fRadius, plUInt16 uiSegments, plUInt16 uiStacks, bool bCap, const GeoOptions& options = GeoOptions());
 
  void AddCapsule(float fRadius, float fHeight, plUInt16 uiSegments, plUInt16 uiStacks, const GeoOptions& options = GeoOptions());
 
  void AddTorus(float fInnerRadius, float fOuterRadius, plUInt16 uiSegments, plUInt16 uiSegmentDetail, bool bExtraVerticesForTexturing, const GeoOptions& options = GeoOptions());
 
  void AddTexturedRamp(const plVec3& vSize, const GeoOptions& options = GeoOptions());
 
  void AddStairs(const plVec3& vSize, plUInt32 uiNumSteps, plAngle curvature, bool bSmoothSloped, const GeoOptions& options = GeoOptions());
 
  void AddArch(const plVec3& vSize, plUInt32 uiNumSegments, float fThickness, plAngle angle, bool bMakeSteps, bool bSmoothBottom, bool bSmoothTop, bool bCapTopAndBottom, const GeoOptions& options = GeoOptions());
 
  // ThickLine
  // Part of a Torus
  // Arc
  // Circle
  // Curved cone (spotlight)
  // flat arc / circle (ie. UE4 gizmo)
  // ....
 
  // Compounds:
  // Arrow
  // Cross ?
  //
 
 
private:
  void TransformVertices(const plMat4& mTransform, plUInt32 uiFirstVertex);
 
  plDeque<Vertex> m_Vertices;
  plDeque<Polygon> m_Polygons;
  plDeque<Line> m_Lines;
};