GUIView3DUtils.h

#pragma once
 
#include "GUIDefinitions.h"
 
namespace FLImaging
{
    namespace GUI
    {
        typedef struct FL_EXPORT sVertexTangent
        {
            sVertexTangent() {}
            sVertexTangent(
                const Base::TPoint3<float>& p,
                const Base::TPoint3<float>& n,
                const Base::TPoint3<float>& t) :
                position(p),
                normal(n),
                tangentU(t) {}
            sVertexTangent(
                float px, float py, float pz,
                float nx, float ny, float nz,
                float tx, float ty, float tz) :
                position(px, py, pz),
                normal(nx, ny, nz),
                tangentU(tx, ty, tz) {}
            Base::TPoint3<float> position;
            Base::TPoint3<float> normal;
            Base::TPoint3<float> tangentU;
        }
        SVertexTangent;
 
        typedef struct FL_EXPORT sFaceDataTangent
        {
            std::vector<SVertexTangent>& m_vctVertex;
            std::vector<uint32_t>& m_vctIndices32;
 
            sFaceDataTangent();
            sFaceDataTangent(const sFaceDataTangent& rh);
            ~sFaceDataTangent();
 
            const CResult Assign(const sFaceDataTangent& rh);
            sFaceDataTangent& operator=(const sFaceDataTangent& rh);
            std::vector<uint16_t>& GetIndices16();
 
        private:
            std::vector<uint16_t>& m_vctIndices16;
        }
        SFaceDataTangent;
 
        typedef struct FL_EXPORT sBoundingBox
        {
            Base::TPoint3<float> Center;            // Center of the box.
            Base::TPoint3<float> Extents;           // Distance from the center to each side.
 
            sBoundingBox();
            sBoundingBox(const sBoundingBox& rh);
            sBoundingBox& operator=(const sBoundingBox& rh);
            sBoundingBox(const Base::TPoint3<float>& center, const Base::TPoint3<float>& extents);
 
            bool Intersects(const Base::TPoint3<float>& tp3F32Origin, const Base::TPoint3<float>& tp3F32Direction, float& f32Dist);
            const CResult GetMinMaxCoord(Base::TPoint3<float>& tp3F32Min, Base::TPoint3<float>& tp3F32Max);
            const CResult GetMinMaxCoord(float& f32MinX, float& f32MinY, float& f32MinZ, float& f32MaxX, float& f32MaxY, float& f32MaxZ);
            const CResult Extend(const Base::TPoint3<float>& tp3F32NewPoint);
            const CResult Extend(const Base::TPoint3<double>& tp3F64NewPoint);
            const CResult Extend(const Base::TPoint3<float>& tp3F32NewPoint1, const Base::TPoint3<float>& tp3F32NewPoint2);
            const CResult Extend(const Base::TPoint3<double>& tp3F64NewPoint1, const Base::TPoint3<double>& tp3F64NewPoint2);
            void Reset();
        }
        SBoundingBox;
 
        class FL_EXPORT CGUIView3DUtils
        {
        public:
            CGUIView3DUtils();
            virtual ~CGUIView3DUtils();
 
            static CGUIView3DUtils* GetObject();
 
            static bool Initialize();       // Initialize tables
            static bool IsInitialized();    // Is tables initialized?
 
            static bool RayTriangleIntersect(const Base::TPoint3<float>& tpRayOrig, const Base::TPoint3<float>& tpRayDir, const Base::TPoint3<float>& tp0, const Base::TPoint3<float>& tp1, const Base::TPoint3<float>& tp2, float& f32Dist);
            static bool RayOrientedBoundigBoxIntersect(const Base::TPoint3<float>& tpRayOrig, const Base::TPoint3<float>& tpRayDir, const Base::TPoint3<float>& tpOrientedBoundigBoxMin, const Base::TPoint3<float>& tpOrientedBoundigBoxMax, float& f32Dist);
 
 
 
            static const CResult CreateBox(float width, float height, float depth, uint32_t numSubdivisions, SFaceDataTangent& sFaceData);
            static const CResult CreateSphere(float radius, uint32_t sliceCount, uint32_t stackCount, SFaceDataTangent& sFaceData);
            static const CResult CreateGeosphere(float radius, uint32_t numSubdivisions, SFaceDataTangent& sFaceData);
            static const CResult CreateCylinder(float bottomRadius, float topRadius, float height, float x, float y, float z, uint32_t sliceCount, uint32_t stackCount, SFaceDataTangent& sFaceData);
            static const CResult CreateGrid(float width, float depth, uint32_t m, uint32_t n, SFaceDataTangent& sFaceData);
            static const CResult CreateQuad(float x, float y, float w, float h, float depth, SFaceDataTangent& sFaceData);
            static const CResult CreateCircle(float f32Radius, float x, float y, float z, uint32_t sliceCount, SFaceDataTangent& sFaceData);
 
            static void __fastcall FastFloatRGB(const COLORREF& clr, float& f32R, float& f32G, float& f32B);
 
            static COLORREF GetPredefinedColor(int32_t i32Index);
 
        private:
            const CResult Subdivide(SFaceDataTangent& meshData);
            const CResult MidPoint(const SVertexTangent& v0, const SVertexTangent& v1, SVertexTangent& vOut);
            const CResult BuildCylinderTopCap(float bottomRadius, float topRadius, float height, uint32_t sliceCount, uint32_t stackCount, SFaceDataTangent& meshData);
            const CResult BuildCylinderBottomCap(float bottomRadius, float topRadius, float height, uint32_t sliceCount, uint32_t stackCount, SFaceDataTangent& meshData);
 
        protected:
            volatile bool m_bInitialized;
        };
    }
}