CAD DTM Rendering

62_CAD/CTriangleMesh.cpp

@@ -0,0 +1 @@
+#include "CTriangleMesh.h"

62_CAD/CTriangleMesh.h

@@ -0,0 +1,137 @@
+#pragma once
+
+#include <nabla.h>
+#include <nbl/builtin/hlsl/cpp_compat.hlsl>
+#include "shaders/globals.hlsl"
+
+using namespace nbl;
+
+struct DTMHeightShadingSettingsInfo
+{
+	// Height Shading Mode
+	E_HEIGHT_SHADING_MODE heightShadingMode;
+
+	// Used as fixed interval length for "DISCRETE_FIXED_LENGTH_INTERVALS" shading mode
+	float intervalLength;
+
+	// Converts an interval index to its corresponding height value
+	// For example, if this value is 10.0, then an interval index of 2 corresponds to a height of 20.0.
+	// This computed height is later used to determine the interpolated color for shading.
+	// It makes sense for this variable to be always equal to `intervalLength` but sometimes it's a different scaling so that last index corresponds to largestHeight
+	float intervalIndexToHeightMultiplier;
+
+	// Used for "DISCRETE_FIXED_LENGTH_INTERVALS" shading mode
+	// If `isCenteredShading` is true, the intervals are centered around `minHeight`, meaning the
+	// first interval spans [minHeight - intervalLength / 2.0, minHeight + intervalLength / 2.0].
+	// Otherwise, intervals are aligned from `minHeight` upward, so the first interval spans
+	// [minHeight, minHeight + intervalLength].
+	bool isCenteredShading;
+
+	void addHeightColorMapEntry(float height, float32_t4 color)
+	{
+		heightColorSet.emplace(height, color);
+	}
+
+	bool fillShaderDTMSettingsHeightColorMap(DTMSettings& dtmSettings) const
+	{
+		const uint32_t mapSize = heightColorSet.size();
+		if (mapSize > DTMHeightShadingSettings::HeightColorMapMaxEntries)
+			return false;
+		dtmSettings.heightShadingSettings.heightColorEntryCount = mapSize;
+
+		int index = 0;
+		for (auto it = heightColorSet.begin(); it != heightColorSet.end(); ++it)
+		{
+			dtmSettings.heightShadingSettings.heightColorMapHeights[index] = it->height;
+			dtmSettings.heightShadingSettings.heightColorMapColors[index] = it->color;
+			++index;
+		}
+
+		return true;
+	}
+
+private:
+	struct HeightColor
+	{
+		float height;
+		float32_t4 color;
+
+		bool operator<(const HeightColor& other) const
+		{
+			return height < other.height;
+		}
+	};
+
+	std::set<HeightColor> heightColorSet;
+};
+
+struct DTMContourSettingsInfo
+{
+	LineStyleInfo lineStyleInfo;
+
+	float startHeight;
+	float endHeight;
+	float heightInterval;
+};
+
+struct DTMSettingsInfo
+{
+	static constexpr uint32_t MaxContourSettings = DTMSettings::MaxContourSettings;
+
+	uint32_t mode = 0u;
+
+	// outline
+	LineStyleInfo outlineStyleInfo;
+	// contours
+	uint32_t contourSettingsCount = 0u;
+	DTMContourSettingsInfo contourSettings[MaxContourSettings];
+	// height shading
+	DTMHeightShadingSettingsInfo heightShadingInfo;
+};
+
+class CTriangleMesh final
+{
+public:
+	using index_t = uint32_t;
+	using vertex_t = TriangleMeshVertex;
+
+	inline void setVertices(core::vector<vertex_t>&& vertices)
+	{
+		m_vertices = std::move(vertices);
+	}
+	inline void setIndices(core::vector<uint32_t>&& indices)
+	{
+		m_indices = std::move(indices);
+	}
+
+	inline const core::vector<vertex_t>& getVertices() const
+	{
+		return m_vertices;
+	}
+	inline const core::vector<uint32_t>& getIndices() const
+	{
+		return m_indices;
+	}
+
+	inline size_t getVertexBuffByteSize() const
+	{
+		return sizeof(vertex_t) * m_vertices.size();
+	}
+	inline size_t getIndexBuffByteSize() const
+	{
+		return sizeof(index_t) * m_indices.size();
+	}
+	inline size_t getIndexCount() const
+	{
+		return m_indices.size();
+	}
+
+	inline void clear()
+	{
+		m_vertices.clear();
+		m_indices.clear();
+	}
+
+	core::vector<vertex_t> m_vertices;
+	core::vector<index_t> m_indices;
+};