DebugRenderer.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#ifndef JPH_DEBUG_RENDERER
    #error This file should only be included when JPH_DEBUG_RENDERER is defined
#endif // !JPH_DEBUG_RENDERER
 
#ifndef JPH_DEBUG_RENDERER_EXPORT
    // By default export the debug renderer
    #define JPH_DEBUG_RENDERER_EXPORT JPH_EXPORT
#endif // !JPH_DEBUG_RENDERER_EXPORT
 
#include <Jolt/Core/Color.h>
#include <Jolt/Core/Reference.h>
#include <Jolt/Core/HashCombine.h>
#include <Jolt/Core/UnorderedMap.h>
#include <Jolt/Core/NonCopyable.h>
#include <Jolt/Math/Float2.h>
#include <Jolt/Geometry/IndexedTriangle.h>
#include <Jolt/Geometry/AABox.h>
 
JPH_NAMESPACE_BEGIN
 
class OrientedBox;
 
class JPH_DEBUG_RENDERER_EXPORT DebugRenderer : public NonCopyable
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
                            DebugRenderer();
    virtual                 ~DebugRenderer();
 
    void                    NextFrame();
 
    virtual void            DrawLine(RVec3Arg inFrom, RVec3Arg inTo, ColorArg inColor) = 0;
 
    void                    DrawWireBox(const AABox &inBox, ColorArg inColor);
    void                    DrawWireBox(const OrientedBox &inBox, ColorArg inColor);
    void                    DrawWireBox(RMat44Arg inMatrix, const AABox &inBox, ColorArg inColor);
 
    void                    DrawMarker(RVec3Arg inPosition, ColorArg inColor, float inSize);
 
    void                    DrawArrow(RVec3Arg inFrom, RVec3Arg inTo, ColorArg inColor, float inSize);
 
    void                    DrawCoordinateSystem(RMat44Arg inTransform, float inSize = 1.0f);
 
    void                    DrawPlane(RVec3Arg inPoint, Vec3Arg inNormal, ColorArg inColor, float inSize);
 
    void                    DrawWireTriangle(RVec3Arg inV1, RVec3Arg inV2, RVec3Arg inV3, ColorArg inColor);
 
    template <class VERTEX_ARRAY>
    void                    DrawWirePolygon(RMat44Arg inTransform, const VERTEX_ARRAY &inVertices, ColorArg inColor, float inArrowSize = 0.0f) { for (typename VERTEX_ARRAY::size_type i = 0; i < inVertices.size(); ++i) DrawArrow(inTransform * inVertices[i], inTransform * inVertices[(i + 1) % inVertices.size()], inColor, inArrowSize); }
 
    void                    DrawWireSphere(RVec3Arg inCenter, float inRadius, ColorArg inColor, int inLevel = 3);
    void                    DrawWireUnitSphere(RMat44Arg inMatrix, ColorArg inColor, int inLevel = 3);
 
    enum class ECastShadow
    {
        On,                 
        Off                 
    };
 
    enum class EDrawMode
    {
        Solid,              
        Wireframe,          
    };
 
    virtual void            DrawTriangle(RVec3Arg inV1, RVec3Arg inV2, RVec3Arg inV3, ColorArg inColor, ECastShadow inCastShadow = ECastShadow::Off) = 0;
 
    void                    DrawBox(const AABox &inBox, ColorArg inColor, ECastShadow inCastShadow = ECastShadow::On, EDrawMode inDrawMode = EDrawMode::Solid);
    void                    DrawBox(RMat44Arg inMatrix, const AABox &inBox, ColorArg inColor, ECastShadow inCastShadow = ECastShadow::On, EDrawMode inDrawMode = EDrawMode::Solid);
 
    void                    DrawSphere(RVec3Arg inCenter, float inRadius, ColorArg inColor, ECastShadow inCastShadow = ECastShadow::On, EDrawMode inDrawMode = EDrawMode::Solid);
    void                    DrawUnitSphere(RMat44Arg inMatrix, ColorArg inColor, ECastShadow inCastShadow = ECastShadow::On, EDrawMode inDrawMode = EDrawMode::Solid);
 
    void                    DrawCapsule(RMat44Arg inMatrix, float inHalfHeightOfCylinder, float inRadius, ColorArg inColor, ECastShadow inCastShadow = ECastShadow::On, EDrawMode inDrawMode = EDrawMode::Solid);
 
    void                    DrawCylinder(RMat44Arg inMatrix, float inHalfHeight, float inRadius, ColorArg inColor, ECastShadow inCastShadow = ECastShadow::On, EDrawMode inDrawMode = EDrawMode::Solid);
 
    void                    DrawOpenCone(RVec3Arg inTop, Vec3Arg inAxis, Vec3Arg inPerpendicular, float inHalfAngle, float inLength, ColorArg inColor, ECastShadow inCastShadow = ECastShadow::On, EDrawMode inDrawMode = EDrawMode::Solid);
 
    void                    DrawSwingConeLimits(RMat44Arg inMatrix, float inSwingYHalfAngle, float inSwingZHalfAngle, float inEdgeLength, ColorArg inColor, ECastShadow inCastShadow = ECastShadow::On, EDrawMode inDrawMode = EDrawMode::Solid);
 
    void                    DrawSwingPyramidLimits(RMat44Arg inMatrix, float inMinSwingYAngle, float inMaxSwingYAngle, float inMinSwingZAngle, float inMaxSwingZAngle, float inEdgeLength, ColorArg inColor, ECastShadow inCastShadow = ECastShadow::On, EDrawMode inDrawMode = EDrawMode::Solid);
 
    void                    DrawPie(RVec3Arg inCenter, float inRadius, Vec3Arg inNormal, Vec3Arg inAxis, float inMinAngle, float inMaxAngle, ColorArg inColor, ECastShadow inCastShadow = ECastShadow::On, EDrawMode inDrawMode = EDrawMode::Solid);
 
    void                    DrawTaperedCylinder(RMat44Arg inMatrix, float inTop, float inBottom, float inTopRadius, float inBottomRadius, ColorArg inColor, ECastShadow inCastShadow = ECastShadow::On, EDrawMode inDrawMode = EDrawMode::Solid);
 
    static DebugRenderer *  sInstance;
 
    class Vertex
    {
    public:
        Float3              mPosition;
        Float3              mNormal;
        Float2              mUV;
        Color               mColor;
    };
 
    class JPH_DEBUG_RENDERER_EXPORT Triangle
    {
    public:
                            Triangle() = default;
                            Triangle(Vec3Arg inV1, Vec3Arg inV2, Vec3Arg inV3, ColorArg inColor);
                            Triangle(Vec3Arg inV1, Vec3Arg inV2, Vec3Arg inV3, ColorArg inColor, Vec3Arg inUVOrigin, Vec3Arg inUVDirection);
 
        Vertex              mV[3];
    };
 
    using Batch = Ref<RefTargetVirtual>;
 
    class LOD
    {
    public:
        Batch               mTriangleBatch;
        float               mDistance;
    };
 
    class Geometry : public RefTarget<Geometry>
    {
    public:
        JPH_OVERRIDE_NEW_DELETE
 
                            Geometry(const AABox &inBounds) : mBounds(inBounds) { }
                            Geometry(const Batch &inBatch, const AABox &inBounds) : mBounds(inBounds) { mLODs.push_back({ inBatch, cLargeFloat }); }
 
        const LOD &         GetLOD(Vec3Arg inCameraPosition, const AABox &inWorldSpaceBounds, float inLODScaleSq) const
        {
            float dist_sq = inWorldSpaceBounds.GetSqDistanceTo(inCameraPosition);
            for (const LOD &lod : mLODs)
                if (dist_sq <= inLODScaleSq * Square(lod.mDistance))
                    return lod;
 
            return mLODs.back();
        }
 
        Array<LOD>          mLODs;
 
        AABox               mBounds;
    };
 
    using GeometryRef = Ref<Geometry>;
 
    static AABox            sCalculateBounds(const Vertex *inVertices, int inVertexCount);
 
    virtual Batch           CreateTriangleBatch(const Triangle *inTriangles, int inTriangleCount) = 0;
    virtual Batch           CreateTriangleBatch(const Vertex *inVertices, int inVertexCount, const uint32 *inIndices, int inIndexCount) = 0;
    Batch                   CreateTriangleBatch(const Array<Triangle> &inTriangles) { return CreateTriangleBatch(inTriangles.empty()? nullptr : &inTriangles[0], int(inTriangles.size())); }
    Batch                   CreateTriangleBatch(const Array<Vertex> &inVertices, const Array<uint32> &inIndices) { return CreateTriangleBatch(inVertices.empty()? nullptr : &inVertices[0], int(inVertices.size()), inIndices.empty()? nullptr : &inIndices[0], int(inIndices.size())); }
    Batch                   CreateTriangleBatch(const VertexList &inVertices, const IndexedTriangleNoMaterialList &inTriangles);
 
    using SupportFunction = function<Vec3 (Vec3Arg inDirection)>;
    Batch                   CreateTriangleBatchForConvex(SupportFunction inGetSupport, int inLevel, AABox *outBounds = nullptr);
    GeometryRef             CreateTriangleGeometryForConvex(SupportFunction inGetSupport);
 
    enum class ECullMode
    {
        CullBackFace,       
        CullFrontFace,      
        Off                 
    };
 
    virtual void            DrawGeometry(RMat44Arg inModelMatrix, const AABox &inWorldSpaceBounds, float inLODScaleSq, ColorArg inModelColor, const GeometryRef &inGeometry, ECullMode inCullMode = ECullMode::CullBackFace, ECastShadow inCastShadow = ECastShadow::On, EDrawMode inDrawMode = EDrawMode::Solid) = 0;
    void                    DrawGeometry(RMat44Arg inModelMatrix, ColorArg inModelColor, const GeometryRef &inGeometry, ECullMode inCullMode = ECullMode::CullBackFace, ECastShadow inCastShadow = ECastShadow::On, EDrawMode inDrawMode = EDrawMode::Solid) { DrawGeometry(inModelMatrix, inGeometry->mBounds.Transformed(inModelMatrix), max(max(inModelMatrix.GetAxisX().LengthSq(), inModelMatrix.GetAxisY().LengthSq()), inModelMatrix.GetAxisZ().LengthSq()), inModelColor, inGeometry, inCullMode, inCastShadow, inDrawMode); }
 
    virtual void            DrawText3D(RVec3Arg inPosition, const string_view &inString, ColorArg inColor = Color::sWhite, float inHeight = 0.5f) = 0;
 
protected:
    void                    Initialize();
 
private:
    void                    DrawWireUnitSphereRecursive(RMat44Arg inMatrix, ColorArg inColor, Vec3Arg inDir1, Vec3Arg inDir2, Vec3Arg inDir3, int inLevel);
 
    void                    CreateQuad(Array<uint32> &ioIndices, Array<Vertex> &ioVertices, Vec3Arg inV1, Vec3Arg inV2, Vec3Arg inV3, Vec3Arg inV4);
 
    void                    Create8thSphereRecursive(Array<uint32> &ioIndices, Array<Vertex> &ioVertices, Vec3Arg inDir1, uint32 &ioIdx1, Vec3Arg inDir2, uint32 &ioIdx2, Vec3Arg inDir3, uint32 &ioIdx3, const Float2 &inUV, SupportFunction inGetSupport, int inLevel);
    void                    Create8thSphere(Array<uint32> &ioIndices, Array<Vertex> &ioVertices, Vec3Arg inDir1, Vec3Arg inDir2, Vec3Arg inDir3, const Float2 &inUV, SupportFunction inGetSupport, int inLevel);
 
    Batch                   CreateCylinder(float inTop, float inBottom, float inTopRadius, float inBottomRadius, int inLevel);
 
    Geometry *              CreateSwingLimitGeometry(int inNumSegments, const Vec3 *inVertices);
 
    // Predefined shapes
    GeometryRef             mBox;
    GeometryRef             mSphere;
    GeometryRef             mCapsuleTop;
    GeometryRef             mCapsuleMid;
    GeometryRef             mCapsuleBottom;
    GeometryRef             mOpenCone;
    GeometryRef             mCylinder;
 
    struct SwingConeLimits
    {
        bool                operator == (const SwingConeLimits &inRHS) const
        {
            return mSwingYHalfAngle == inRHS.mSwingYHalfAngle
                && mSwingZHalfAngle == inRHS.mSwingZHalfAngle;
        }
 
        float               mSwingYHalfAngle;
        float               mSwingZHalfAngle;
    };
 
    JPH_MAKE_HASH_STRUCT(SwingConeLimits, SwingConeLimitsHasher, t.mSwingYHalfAngle, t.mSwingZHalfAngle)
 
    using SwingConeBatches = UnorderedMap<SwingConeLimits, GeometryRef, SwingConeLimitsHasher>;
    SwingConeBatches        mSwingConeLimits;
    SwingConeBatches        mPrevSwingConeLimits;
 
    struct SwingPyramidLimits
    {
        bool                operator == (const SwingPyramidLimits &inRHS) const
        {
            return mMinSwingYAngle == inRHS.mMinSwingYAngle
                && mMaxSwingYAngle == inRHS.mMaxSwingYAngle
                && mMinSwingZAngle == inRHS.mMinSwingZAngle
                && mMaxSwingZAngle == inRHS.mMaxSwingZAngle;
        }
 
        float               mMinSwingYAngle;
        float               mMaxSwingYAngle;
        float               mMinSwingZAngle;
        float               mMaxSwingZAngle;
    };
 
    JPH_MAKE_HASH_STRUCT(SwingPyramidLimits, SwingPyramidLimitsHasher, t.mMinSwingYAngle, t.mMaxSwingYAngle, t.mMinSwingZAngle, t.mMaxSwingZAngle)
 
    using SwingPyramidBatches = UnorderedMap<SwingPyramidLimits, GeometryRef, SwingPyramidLimitsHasher>;
    SwingPyramidBatches     mSwingPyramidLimits;
    SwingPyramidBatches     mPrevSwingPyramidLimits;
 
    using PieBatces = UnorderedMap<float, GeometryRef>;
    PieBatces               mPieLimits;
    PieBatces               mPrevPieLimits;
 
    struct TaperedCylinder
    {
        bool                operator == (const TaperedCylinder &inRHS) const
        {
            return mTop == inRHS.mTop
                && mBottom == inRHS.mBottom
                && mTopRadius == inRHS.mTopRadius
                && mBottomRadius == inRHS.mBottomRadius;
        }
 
        float               mTop;
        float               mBottom;
        float               mTopRadius;
        float               mBottomRadius;
    };
 
    JPH_MAKE_HASH_STRUCT(TaperedCylinder, TaperedCylinderHasher, t.mTop, t.mBottom, t.mTopRadius, t.mBottomRadius)
 
    using TaperedCylinderBatces = UnorderedMap<TaperedCylinder, GeometryRef, TaperedCylinderHasher>;
    TaperedCylinderBatces   mTaperedCylinders;
    TaperedCylinderBatces   mPrevTaperedCylinders;
};
 
JPH_NAMESPACE_END