1842 lines
74 KiB
C++
1842 lines
74 KiB
C++
#include "MetaCoreRender/MetaCorePandaSceneBridge.h"
|
|
|
|
#include "MetaCoreRender/MetaCoreRenderDevice.h"
|
|
#include "MetaCoreRender/MetaCoreRenderTypes.h"
|
|
#include "MetaCoreScene/MetaCoreComponents.h"
|
|
#include "MetaCoreScene/MetaCoreScene.h"
|
|
#include "MetaCoreFoundation/MetaCoreAssetTypes.h"
|
|
#include "MetaCoreFoundation/MetaCorePackage.h"
|
|
|
|
#include "ambientLight.h"
|
|
#include "camera.h"
|
|
#include "directionalLight.h"
|
|
#include "geom.h"
|
|
#include "geomNode.h"
|
|
#include "geomLines.h"
|
|
#include "geomTriangles.h"
|
|
#include "geomVertexData.h"
|
|
#include "geomVertexFormat.h"
|
|
#include "geomVertexWriter.h"
|
|
#include "internalName.h"
|
|
#include "lineSegs.h"
|
|
#include "loader.h"
|
|
#include "nodePath.h"
|
|
#include "perspectiveLens.h"
|
|
#include "pandaNode.h"
|
|
#include "shader.h"
|
|
#include "texture.h"
|
|
#include "texturePool.h"
|
|
#include "transparencyAttrib.h"
|
|
#include "windowFramework.h"
|
|
#include "pointerTo.h"
|
|
#include "dcast.h"
|
|
|
|
#include <algorithm>
|
|
#include <chrono>
|
|
#include <filesystem>
|
|
#include <mutex>
|
|
#include <optional>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
#include <vector>
|
|
#include <span>
|
|
#include <cstddef>
|
|
#include <fstream>
|
|
|
|
#define GLM_ENABLE_EXPERIMENTAL
|
|
#include <glm/glm.hpp>
|
|
#include <glm/ext/matrix_transform.hpp>
|
|
#include <glm/gtx/euler_angles.hpp>
|
|
#include <glm/gtx/matrix_decompose.hpp>
|
|
#include <glm/mat4x4.hpp>
|
|
#include <cstdlib>
|
|
#include <cstdio>
|
|
#include <ctime>
|
|
#include <memory>
|
|
|
|
#include "MetaCoreFoundation/MetaCoreAssetTypes.h"
|
|
#include "MetaCoreFoundation/MetaCorePackage.h"
|
|
#include "MetaCoreFoundation/MetaCoreArchive.h"
|
|
#include "MetaCoreFoundation/MetaCoreGeneratedReflection.h"
|
|
|
|
namespace MetaCore {
|
|
|
|
namespace {
|
|
|
|
void MetaCoreTrace(const char* message);
|
|
[[nodiscard]] NodePath MetaCoreBuildMeshFromBinary(
|
|
const std::string& name,
|
|
std::span<const std::byte> payload,
|
|
std::span<const MetaCoreMeshSubMeshDocument> subMeshes
|
|
);
|
|
[[nodiscard]] PT(Texture) MetaCoreBuildTextureFromBinary(const std::string& name, const MetaCoreTextureAssetDocument& doc, std::span<const std::byte> payload);
|
|
[[nodiscard]] PT(Texture) MetaCoreResolveTextureWithFallback(const std::filesystem::path& projectRoot, const std::string& relativeTexturePath, const PT(Texture)& fallbackTexture);
|
|
[[nodiscard]] PT(Texture) MetaCoreGetDefaultBaseColorTexture();
|
|
[[nodiscard]] PT(Texture) MetaCoreGetDefaultMetalRoughnessTexture();
|
|
[[nodiscard]] PT(Texture) MetaCoreGetDefaultNormalTexture();
|
|
[[nodiscard]] PT(Texture) MetaCoreGetDefaultEmissionTexture();
|
|
[[nodiscard]] PT(Texture) MetaCoreGetDefaultAoTexture();
|
|
[[nodiscard]] PT(Shader) MetaCoreLoadSimplePbrShader();
|
|
void MetaCoreApplySimplePbrViewInputs(NodePath& meshNode, const NodePath& sceneRootNode, const NodePath& cameraNode);
|
|
|
|
void MetaCoreTrace(const char* message) {
|
|
if (message == nullptr) {
|
|
return;
|
|
}
|
|
|
|
const auto now = std::chrono::system_clock::now();
|
|
const auto time = std::chrono::system_clock::to_time_t(now);
|
|
struct tm timeInfo {};
|
|
localtime_s(&timeInfo, &time);
|
|
|
|
char timeBuffer[32]{};
|
|
std::strftime(timeBuffer, sizeof(timeBuffer), "[%H:%M:%S] ", &timeInfo);
|
|
|
|
FILE* file = nullptr;
|
|
if (fopen_s(&file, "editor.crash.log", "a") == 0 && file != nullptr) {
|
|
std::fputs(timeBuffer, file);
|
|
std::fputs(message, file);
|
|
std::fputs("\n", file);
|
|
std::fflush(file);
|
|
std::fclose(file);
|
|
}
|
|
|
|
std::printf("%s%s\n", timeBuffer, message);
|
|
}
|
|
|
|
glm::mat4 MetaCoreBuildBasisSwapMatrix() {
|
|
glm::mat4 basis(1.0F);
|
|
basis[0] = glm::vec4(1.0F, 0.0F, 0.0F, 0.0F);
|
|
basis[1] = glm::vec4(0.0F, 0.0F, 1.0F, 0.0F);
|
|
basis[2] = glm::vec4(0.0F, 1.0F, 0.0F, 0.0F);
|
|
basis[3] = glm::vec4(0.0F, 0.0F, 0.0F, 1.0F);
|
|
return basis;
|
|
}
|
|
|
|
LMatrix4f MetaCoreConvertTransformToPanda(const MetaCoreTransformComponent& transform) {
|
|
const glm::mat4 translation = glm::translate(glm::mat4(1.0F), transform.Position);
|
|
const glm::mat4 rotation = glm::yawPitchRoll(
|
|
glm::radians(transform.RotationEulerDegrees.y),
|
|
glm::radians(transform.RotationEulerDegrees.x),
|
|
glm::radians(transform.RotationEulerDegrees.z)
|
|
);
|
|
const glm::mat4 scale = glm::scale(glm::mat4(1.0F), transform.Scale);
|
|
|
|
const glm::mat4 metaCoreMatrix = translation * rotation * scale;
|
|
const glm::mat4 basis = MetaCoreBuildBasisSwapMatrix();
|
|
const glm::mat4 pandaMatrix = basis * metaCoreMatrix * basis;
|
|
|
|
LMatrix4f result;
|
|
for (int row = 0; row < 4; ++row) {
|
|
for (int column = 0; column < 4; ++column) {
|
|
result.set_cell(row, column, pandaMatrix[column][row]);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
LPoint3f MetaCoreToPandaPoint(const glm::vec3& value) {
|
|
return LPoint3f(value.x, -value.z, value.y);
|
|
}
|
|
|
|
LVector3f MetaCoreToPandaVector(const glm::vec3& value) {
|
|
return LVector3f(value.x, -value.z, value.y);
|
|
}
|
|
|
|
LVecBase3f MetaCoreToPandaScale(const glm::vec3& value) {
|
|
return LVecBase3f(value.x, value.z, value.y);
|
|
}
|
|
|
|
glm::mat4 MetaCoreBuildLocalTransformMatrix(const MetaCoreTransformComponent& transform) {
|
|
const glm::mat4 translation = glm::translate(glm::mat4(1.0F), transform.Position);
|
|
const glm::mat4 rotation = glm::yawPitchRoll(
|
|
glm::radians(transform.RotationEulerDegrees.y),
|
|
glm::radians(transform.RotationEulerDegrees.x),
|
|
glm::radians(transform.RotationEulerDegrees.z)
|
|
);
|
|
const glm::mat4 scale = glm::scale(glm::mat4(1.0F), transform.Scale);
|
|
return translation * rotation * scale;
|
|
}
|
|
|
|
MetaCoreTransformComponent MetaCoreBuildWorldTransformComponent(const MetaCoreScene& scene, const MetaCoreGameObject& gameObject) {
|
|
glm::mat4 worldMatrix = MetaCoreBuildLocalTransformMatrix(gameObject.GetComponent<MetaCoreTransformComponent>());
|
|
|
|
MetaCoreGameObject current = gameObject;
|
|
std::size_t guard = 0;
|
|
while (current && current.GetParentId() != 0 && guard++ < scene.GetGameObjects().size()) {
|
|
current = scene.FindGameObject(current.GetParentId());
|
|
if (current) {
|
|
worldMatrix = MetaCoreBuildLocalTransformMatrix(current.GetComponent<MetaCoreTransformComponent>()) * worldMatrix;
|
|
}
|
|
}
|
|
|
|
MetaCoreTransformComponent worldTransform{};
|
|
glm::vec3 skew{};
|
|
glm::vec4 perspective{};
|
|
glm::quat rotation{};
|
|
glm::decompose(worldMatrix, worldTransform.Scale, rotation, worldTransform.Position, skew, perspective);
|
|
worldTransform.RotationEulerDegrees = glm::degrees(glm::eulerAngles(rotation));
|
|
return worldTransform;
|
|
}
|
|
|
|
void MetaCoreApplyTransformToPandaNode(const MetaCoreTransformComponent& transform, NodePath& nodePath) {
|
|
nodePath.set_pos(MetaCoreToPandaPoint(transform.Position));
|
|
nodePath.set_hpr(
|
|
transform.RotationEulerDegrees.y,
|
|
transform.RotationEulerDegrees.x,
|
|
transform.RotationEulerDegrees.z
|
|
);
|
|
nodePath.set_scale(MetaCoreToPandaScale(transform.Scale));
|
|
}
|
|
|
|
NodePath MetaCoreCreateGridNode(const NodePath& parentNode) {
|
|
(void)parentNode;
|
|
MetaCoreTrace("metacore.render: debug scene grid paused due to backend runtime instability");
|
|
return NodePath();
|
|
}
|
|
|
|
[[nodiscard]] std::filesystem::path MetaCoreEnsureBuiltinCubeEggPath() {
|
|
const std::filesystem::path cubePath = std::filesystem::current_path() / "metacore_builtin_cube.egg";
|
|
if (std::filesystem::exists(cubePath)) {
|
|
return cubePath;
|
|
}
|
|
|
|
std::ofstream cubeFile(cubePath, std::ios::trunc);
|
|
if (!cubeFile.is_open()) {
|
|
return {};
|
|
}
|
|
|
|
cubeFile
|
|
<< "<CoordinateSystem> { Y-Up }\n"
|
|
<< "<Group> MetaCoreUnitCube {\n"
|
|
<< " <VertexPool> cube.verts {\n"
|
|
<< " <Vertex> 1 { -0.5 -0.5 -0.5 <Normal> { 0 0 -1 } <UV> { 0 0 } }\n"
|
|
<< " <Vertex> 2 { 0.5 -0.5 -0.5 <Normal> { 0 0 -1 } <UV> { 1 0 } }\n"
|
|
<< " <Vertex> 3 { 0.5 0.5 -0.5 <Normal> { 0 0 -1 } <UV> { 1 1 } }\n"
|
|
<< " <Vertex> 4 { -0.5 0.5 -0.5 <Normal> { 0 0 -1 } <UV> { 0 1 } }\n"
|
|
<< " <Vertex> 5 { -0.5 -0.5 0.5 <Normal> { 0 0 1 } <UV> { 0 0 } }\n"
|
|
<< " <Vertex> 6 { 0.5 -0.5 0.5 <Normal> { 0 0 1 } <UV> { 1 0 } }\n"
|
|
<< " <Vertex> 7 { 0.5 0.5 0.5 <Normal> { 0 0 1 } <UV> { 1 1 } }\n"
|
|
<< " <Vertex> 8 { -0.5 0.5 0.5 <Normal> { 0 0 1 } <UV> { 0 1 } }\n"
|
|
<< " }\n"
|
|
<< " <Polygon> { <RGBA> { 0.75 0.78 0.84 1 } <VertexRef> { 1 2 3 4 <Ref> { cube.verts } } }\n"
|
|
<< " <Polygon> { <RGBA> { 0.75 0.78 0.84 1 } <VertexRef> { 5 8 7 6 <Ref> { cube.verts } } }\n"
|
|
<< " <Polygon> { <RGBA> { 0.75 0.78 0.84 1 } <VertexRef> { 1 5 6 2 <Ref> { cube.verts } } }\n"
|
|
<< " <Polygon> { <RGBA> { 0.75 0.78 0.84 1 } <VertexRef> { 2 6 7 3 <Ref> { cube.verts } } }\n"
|
|
<< " <Polygon> { <RGBA> { 0.75 0.78 0.84 1 } <VertexRef> { 3 7 8 4 <Ref> { cube.verts } } }\n"
|
|
<< " <Polygon> { <RGBA> { 0.75 0.78 0.84 1 } <VertexRef> { 4 8 5 1 <Ref> { cube.verts } } }\n"
|
|
<< "}\n";
|
|
return cubePath;
|
|
}
|
|
|
|
[[nodiscard]] std::filesystem::path MetaCoreEnsureBuiltinCubeModelPath() {
|
|
const std::filesystem::path bamPath = std::filesystem::current_path() / "metacore_builtin_cube.bam";
|
|
if (std::filesystem::exists(bamPath)) {
|
|
return bamPath;
|
|
}
|
|
|
|
const std::filesystem::path eggPath = MetaCoreEnsureBuiltinCubeEggPath();
|
|
if (eggPath.empty()) {
|
|
return {};
|
|
}
|
|
|
|
const std::filesystem::path converterPath =
|
|
std::filesystem::current_path() / ".." / ".." / ".." / ".metacore" / "deps" / "panda3d" / "1.10.16-x64" / "bin" / "egg2bam.exe";
|
|
if (std::filesystem::exists(converterPath)) {
|
|
const std::string command =
|
|
"\"" + converterPath.lexically_normal().string() + "\" \"" + eggPath.string() + "\" \"" + bamPath.string() + "\"";
|
|
const int result = std::system(command.c_str());
|
|
if (result == 0 && std::filesystem::exists(bamPath)) {
|
|
return bamPath;
|
|
}
|
|
}
|
|
|
|
return eggPath;
|
|
}
|
|
|
|
|
|
NodePath MetaCoreCreateUnitCubeNode(WindowFramework* windowFrameworkHandle, const NodePath& parentNode) {
|
|
const std::filesystem::path cubePath = MetaCoreEnsureBuiltinCubeModelPath();
|
|
if (windowFrameworkHandle != nullptr && !cubePath.empty()) {
|
|
NodePath loadedNode = windowFrameworkHandle->load_model(parentNode, Filename::from_os_specific(cubePath.string()));
|
|
if (!loadedNode.is_empty()) {
|
|
return loadedNode;
|
|
}
|
|
MetaCoreTrace("metacore.render.sync: builtin cube asset load failed");
|
|
}
|
|
|
|
#if defined(_DEBUG)
|
|
MetaCoreTrace("metacore.render.sync: debug fallback skipped for manual GeomVertexData cube");
|
|
return NodePath();
|
|
#else
|
|
MetaCoreTrace("metacore.render.sync: create cube vertex data begin");
|
|
PT(GeomVertexData) vertexData = new GeomVertexData(
|
|
"MetaCoreUnitCube",
|
|
GeomVertexFormat::get_v3n3(),
|
|
Geom::UH_static
|
|
);
|
|
|
|
MetaCoreTrace("metacore.render.sync: create cube vertex writers begin");
|
|
GeomVertexWriter vertexWriter(vertexData, "vertex");
|
|
GeomVertexWriter normalWriter(vertexData, "normal");
|
|
|
|
const auto addFace = [&](const glm::vec3& normal, const glm::vec3& a, const glm::vec3& b, const glm::vec3& c, const glm::vec3& d) {
|
|
const glm::vec3 corners[4] = {a, b, c, d};
|
|
for (const glm::vec3& corner : corners) {
|
|
const LPoint3f pandaPoint = MetaCoreToPandaPoint(corner);
|
|
const LVector3f pandaNormal = MetaCoreToPandaVector(normal);
|
|
vertexWriter.add_data3(pandaPoint);
|
|
normalWriter.add_data3(pandaNormal);
|
|
}
|
|
};
|
|
|
|
MetaCoreTrace("metacore.render.sync: write cube vertices begin");
|
|
addFace(glm::vec3(0.0F, 0.0F, 1.0F),
|
|
glm::vec3(-0.5F, -0.5F, 0.5F),
|
|
glm::vec3(0.5F, -0.5F, 0.5F),
|
|
glm::vec3(0.5F, 0.5F, 0.5F),
|
|
glm::vec3(-0.5F, 0.5F, 0.5F));
|
|
addFace(glm::vec3(0.0F, 0.0F, -1.0F),
|
|
glm::vec3(0.5F, -0.5F, -0.5F),
|
|
glm::vec3(-0.5F, -0.5F, -0.5F),
|
|
glm::vec3(-0.5F, 0.5F, -0.5F),
|
|
glm::vec3(0.5F, 0.5F, -0.5F));
|
|
addFace(glm::vec3(-1.0F, 0.0F, 0.0F),
|
|
glm::vec3(-0.5F, -0.5F, -0.5F),
|
|
glm::vec3(-0.5F, -0.5F, 0.5F),
|
|
glm::vec3(-0.5F, 0.5F, 0.5F),
|
|
glm::vec3(-0.5F, 0.5F, -0.5F));
|
|
addFace(glm::vec3(1.0F, 0.0F, 0.0F),
|
|
glm::vec3(0.5F, -0.5F, 0.5F),
|
|
glm::vec3(0.5F, -0.5F, -0.5F),
|
|
glm::vec3(0.5F, 0.5F, -0.5F),
|
|
glm::vec3(0.5F, 0.5F, 0.5F));
|
|
addFace(glm::vec3(0.0F, 1.0F, 0.0F),
|
|
glm::vec3(-0.5F, 0.5F, 0.5F),
|
|
glm::vec3(0.5F, 0.5F, 0.5F),
|
|
glm::vec3(0.5F, 0.5F, -0.5F),
|
|
glm::vec3(-0.5F, 0.5F, -0.5F));
|
|
addFace(glm::vec3(0.0F, -1.0F, 0.0F),
|
|
glm::vec3(-0.5F, -0.5F, -0.5F),
|
|
glm::vec3(0.5F, -0.5F, -0.5F),
|
|
glm::vec3(0.5F, -0.5F, 0.5F),
|
|
glm::vec3(-0.5F, -0.5F, 0.5F));
|
|
|
|
MetaCoreTrace("metacore.render.sync: create cube triangles begin");
|
|
PT(GeomTriangles) triangles = new GeomTriangles(Geom::UH_static);
|
|
for (int faceIndex = 0; faceIndex < 6; ++faceIndex) {
|
|
const int baseVertex = faceIndex * 4;
|
|
triangles->add_vertices(baseVertex + 0, baseVertex + 1, baseVertex + 2);
|
|
triangles->add_vertices(baseVertex + 0, baseVertex + 2, baseVertex + 3);
|
|
}
|
|
|
|
MetaCoreTrace("metacore.render.sync: create cube geom begin");
|
|
PT(Geom) geom = new Geom(vertexData);
|
|
geom->add_primitive(triangles);
|
|
|
|
MetaCoreTrace("metacore.render.sync: create cube geom node begin");
|
|
PT(GeomNode) geomNode = new GeomNode("MetaCoreUnitCubeNode");
|
|
geomNode->add_geom(geom);
|
|
MetaCoreTrace("metacore.render.sync: attach cube geom node begin");
|
|
return parentNode.attach_new_node(geomNode);
|
|
#endif
|
|
}
|
|
|
|
[[nodiscard]] std::filesystem::path MetaCoreResolveProjectRootFromEnvironment() {
|
|
char* rawProjectPath = nullptr;
|
|
std::size_t valueLength = 0;
|
|
if (_dupenv_s(&rawProjectPath, &valueLength, "METACORE_PROJECT_PATH") != 0 || rawProjectPath == nullptr || valueLength == 0) {
|
|
if (rawProjectPath != nullptr) {
|
|
std::free(rawProjectPath);
|
|
}
|
|
return {};
|
|
}
|
|
|
|
const std::filesystem::path projectRoot(rawProjectPath);
|
|
std::free(rawProjectPath);
|
|
return projectRoot;
|
|
}
|
|
|
|
[[nodiscard]] std::string MetaCoreBuildModelCacheKey(
|
|
const MetaCoreAssetGuid& sourceModelAssetGuid,
|
|
const std::string& relativeSourcePath
|
|
) {
|
|
if (sourceModelAssetGuid.IsValid()) {
|
|
return "model:" + sourceModelAssetGuid.ToString();
|
|
}
|
|
return "path:" + relativeSourcePath;
|
|
}
|
|
|
|
[[nodiscard]] bool MetaCoreShouldCompareSourceModelPath(
|
|
const MetaCoreAssetGuid& previousSourceModelGuid,
|
|
const MetaCoreAssetGuid& nextSourceModelGuid
|
|
) {
|
|
return !previousSourceModelGuid.IsValid() && !nextSourceModelGuid.IsValid();
|
|
}
|
|
|
|
struct MetaCoreRuntimeModelLoadRequest {
|
|
MetaCoreAssetGuid SourceModelAssetGuid{};
|
|
std::filesystem::path ProjectRoot{};
|
|
std::string RelativeSourcePath{};
|
|
bool PreferSourceLoader = false;
|
|
};
|
|
|
|
[[nodiscard]] std::filesystem::path MetaCoreResolveModelRuntimePackagePath(
|
|
const MetaCoreRuntimeModelLoadRequest& request,
|
|
const std::filesystem::path& absoluteSourcePath
|
|
) {
|
|
if (request.SourceModelAssetGuid.IsValid() && !request.ProjectRoot.empty()) {
|
|
const std::filesystem::path libraryPackagePath =
|
|
request.ProjectRoot / "Library" / "RuntimeAssets" / "Models" /
|
|
(request.SourceModelAssetGuid.ToString() + ".mcasset");
|
|
if (std::filesystem::exists(libraryPackagePath)) {
|
|
return libraryPackagePath;
|
|
}
|
|
}
|
|
|
|
if (absoluteSourcePath.empty()) {
|
|
return {};
|
|
}
|
|
|
|
const std::filesystem::path sourceAdjacentPackagePath =
|
|
std::filesystem::path(absoluteSourcePath.string() + ".mcasset");
|
|
if (std::filesystem::exists(sourceAdjacentPackagePath)) {
|
|
return sourceAdjacentPackagePath;
|
|
}
|
|
|
|
return sourceAdjacentPackagePath;
|
|
}
|
|
|
|
[[nodiscard]] std::filesystem::path MetaCoreResolveAbsoluteModelSourcePath(
|
|
const std::filesystem::path& projectRoot,
|
|
const std::string& relativeSourcePath
|
|
) {
|
|
return relativeSourcePath.empty()
|
|
? std::filesystem::path{}
|
|
: (projectRoot / std::filesystem::path(relativeSourcePath)).lexically_normal();
|
|
}
|
|
|
|
[[nodiscard]] std::optional<MetaCoreModelAssetDocument> MetaCoreReadRuntimeModelDocument(
|
|
const MetaCoreRuntimeModelLoadRequest& request
|
|
) {
|
|
const std::filesystem::path absoluteSourcePath =
|
|
MetaCoreResolveAbsoluteModelSourcePath(request.ProjectRoot, request.RelativeSourcePath);
|
|
const std::filesystem::path binaryPackagePath =
|
|
MetaCoreResolveModelRuntimePackagePath(request, absoluteSourcePath);
|
|
if (binaryPackagePath.empty() || !std::filesystem::exists(binaryPackagePath)) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
MetaCoreTypeRegistry registry;
|
|
MetaCoreRegisterFoundationGeneratedTypes(registry);
|
|
|
|
const auto package = MetaCoreReadPackageFile(binaryPackagePath, registry);
|
|
if (!package.has_value() || package->PayloadSections.empty()) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
MetaCoreModelAssetDocument modelDoc;
|
|
if (!MetaCoreDeserializeFromBytes(package->PayloadSections[0], modelDoc, registry)) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
return modelDoc;
|
|
}
|
|
|
|
[[nodiscard]] NodePath MetaCoreTryLoadBinaryModelPackage(const std::filesystem::path& binaryPackagePath) {
|
|
if (binaryPackagePath.empty() || !std::filesystem::exists(binaryPackagePath)) {
|
|
return NodePath();
|
|
}
|
|
|
|
MetaCoreTypeRegistry registry;
|
|
MetaCoreRegisterFoundationGeneratedTypes(registry);
|
|
|
|
const auto package = MetaCoreReadPackageFile(binaryPackagePath, registry);
|
|
if (!package.has_value() || package->PayloadSections.empty()) {
|
|
MetaCoreTrace(("metacore.render: model binary package missing payload: " + binaryPackagePath.string()).c_str());
|
|
return NodePath();
|
|
}
|
|
|
|
MetaCoreModelAssetDocument modelDoc;
|
|
if (!MetaCoreDeserializeFromBytes(package->PayloadSections[0], modelDoc, registry)) {
|
|
MetaCoreTrace(("metacore.render: model binary metadata failed: " + binaryPackagePath.string()).c_str());
|
|
return NodePath();
|
|
}
|
|
|
|
NodePath rootNode("ModelRoot");
|
|
std::vector<NodePath> pandaNodes;
|
|
pandaNodes.resize(modelDoc.Nodes.size());
|
|
|
|
for (std::size_t i = 0; i < modelDoc.Nodes.size(); ++i) {
|
|
const auto& nodeDoc = modelDoc.Nodes[i];
|
|
pandaNodes[i] = NodePath(new PandaNode(nodeDoc.Name));
|
|
pandaNodes[i].set_tag("MetaCoreNodeIndex", std::to_string(i));
|
|
|
|
const std::size_t meshPayloadIndex =
|
|
nodeDoc.MeshIndex >= 0 ? static_cast<std::size_t>(nodeDoc.MeshIndex) + 1U : 0U;
|
|
if (nodeDoc.MeshIndex >= 0 && meshPayloadIndex < package->PayloadSections.size()) {
|
|
std::span<const MetaCoreMeshSubMeshDocument> subMeshes;
|
|
if (static_cast<std::size_t>(nodeDoc.MeshIndex) < modelDoc.GeneratedMeshAssets.size()) {
|
|
subMeshes = modelDoc.GeneratedMeshAssets[static_cast<std::size_t>(nodeDoc.MeshIndex)].SubMeshes;
|
|
}
|
|
NodePath meshGeom = MetaCoreBuildMeshFromBinary(
|
|
nodeDoc.Name + "_mesh",
|
|
package->PayloadSections[meshPayloadIndex],
|
|
subMeshes
|
|
);
|
|
if (!meshGeom.is_empty()) {
|
|
meshGeom.reparent_to(pandaNodes[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (std::size_t i = 0; i < modelDoc.Nodes.size(); ++i) {
|
|
const auto& nodeDoc = modelDoc.Nodes[i];
|
|
if (nodeDoc.ParentIndex >= 0 && static_cast<std::size_t>(nodeDoc.ParentIndex) < pandaNodes.size()) {
|
|
pandaNodes[i].reparent_to(pandaNodes[static_cast<std::size_t>(nodeDoc.ParentIndex)]);
|
|
} else {
|
|
pandaNodes[i].reparent_to(rootNode);
|
|
}
|
|
}
|
|
|
|
MetaCoreTrace(("metacore.render: model binary load success: " + binaryPackagePath.string()).c_str());
|
|
return rootNode;
|
|
}
|
|
|
|
[[nodiscard]] NodePath MetaCoreTryLoadSourceModelNode(const std::filesystem::path& absoluteSourcePath) {
|
|
if (!std::filesystem::exists(absoluteSourcePath)) {
|
|
MetaCoreTrace(("metacore.render: model source file missing: " + absoluteSourcePath.string()).c_str());
|
|
return NodePath();
|
|
}
|
|
|
|
const Filename pandaPath = Filename::from_os_specific(absoluteSourcePath.string());
|
|
|
|
// Fallback to naive Panda3D loader for raw assets.
|
|
PointerTo<PandaNode> loadedNode = Loader::get_global_ptr()->load_sync(pandaPath);
|
|
|
|
if (loadedNode == nullptr) {
|
|
MetaCoreTrace(("metacore.render: backend model load failed: " + absoluteSourcePath.string()).c_str());
|
|
return NodePath();
|
|
}
|
|
|
|
MetaCoreTrace(("metacore.render: model source load success: " + absoluteSourcePath.string()).c_str());
|
|
return NodePath(loadedNode);
|
|
}
|
|
|
|
// Must be called on the render/main thread. This function creates Panda3D nodes.
|
|
[[nodiscard]] NodePath MetaCoreTryLoadModelRuntimeAsset(const MetaCoreRuntimeModelLoadRequest& request) {
|
|
if (request.ProjectRoot.empty()) {
|
|
MetaCoreTrace("metacore.render: model project root is empty");
|
|
return NodePath();
|
|
}
|
|
if (!request.SourceModelAssetGuid.IsValid() && request.RelativeSourcePath.empty()) {
|
|
MetaCoreTrace("metacore.render: model has neither asset guid nor source path");
|
|
return NodePath();
|
|
}
|
|
|
|
const std::filesystem::path absoluteSourcePath =
|
|
MetaCoreResolveAbsoluteModelSourcePath(request.ProjectRoot, request.RelativeSourcePath);
|
|
const std::filesystem::path binaryPackagePath =
|
|
MetaCoreResolveModelRuntimePackagePath(request, absoluteSourcePath);
|
|
|
|
if (!request.PreferSourceLoader) {
|
|
NodePath binaryModel = MetaCoreTryLoadBinaryModelPackage(binaryPackagePath);
|
|
if (!binaryModel.is_empty()) {
|
|
return binaryModel;
|
|
}
|
|
if (!absoluteSourcePath.empty() && std::filesystem::exists(binaryPackagePath)) {
|
|
MetaCoreTrace(("metacore.render: model binary fallback to source: " + absoluteSourcePath.string()).c_str());
|
|
}
|
|
}
|
|
|
|
if (absoluteSourcePath.empty()) {
|
|
MetaCoreTrace(("metacore.render: model runtime package missing for guid: " + request.SourceModelAssetGuid.ToString()).c_str());
|
|
return NodePath();
|
|
}
|
|
|
|
return MetaCoreTryLoadSourceModelNode(absoluteSourcePath);
|
|
}
|
|
|
|
|
|
// Build a Panda3D Mesh from MetaCore's binary mesh payload.
|
|
// format: [u32 vcount, u32 icount, Vertex[vcount], u32[icount]]
|
|
[[nodiscard]] NodePath MetaCoreBuildMeshFromBinary(
|
|
const std::string& name,
|
|
std::span<const std::byte> payload,
|
|
std::span<const MetaCoreMeshSubMeshDocument> subMeshes
|
|
) {
|
|
if (payload.size() < sizeof(std::uint32_t) * 2) {
|
|
MetaCoreTrace("metacore.render: mesh payload too small for header");
|
|
return NodePath();
|
|
}
|
|
|
|
std::uint32_t vCount = 0;
|
|
std::uint32_t iCount = 0;
|
|
std::memcpy(&vCount, payload.data(), sizeof(std::uint32_t));
|
|
std::memcpy(&iCount, payload.data() + sizeof(std::uint32_t), sizeof(std::uint32_t));
|
|
|
|
const std::size_t expectedSize = sizeof(std::uint32_t) * 2 +
|
|
vCount * sizeof(MetaCoreMeshVertex) +
|
|
iCount * sizeof(std::uint32_t);
|
|
|
|
if (payload.size() < expectedSize) {
|
|
MetaCoreTrace(("metacore.render: mesh payload size mismatch. expected=" +
|
|
std::to_string(expectedSize) + " actual=" + std::to_string(payload.size())).c_str());
|
|
return NodePath();
|
|
}
|
|
if (iCount % 3 != 0) {
|
|
MetaCoreTrace(("metacore.render: mesh payload index count is not triangular: " + std::to_string(iCount)).c_str());
|
|
return NodePath();
|
|
}
|
|
|
|
const MetaCoreMeshVertex* vertices = reinterpret_cast<const MetaCoreMeshVertex*>(payload.data() + sizeof(std::uint32_t) * 2);
|
|
const std::uint32_t* indices = reinterpret_cast<const std::uint32_t*>(payload.data() + sizeof(std::uint32_t) * 2 + vCount * sizeof(MetaCoreMeshVertex));
|
|
|
|
PT(GeomVertexData) vdata = new GeomVertexData(name, GeomVertexFormat::get_v3n3t2(), Geom::UH_static);
|
|
vdata->unclean_set_num_rows(vCount);
|
|
|
|
GeomVertexWriter vertexWriter(vdata, "vertex");
|
|
GeomVertexWriter normalWriter(vdata, "normal");
|
|
GeomVertexWriter texcoordWriter(vdata, "texcoord");
|
|
|
|
for (std::uint32_t i = 0; i < vCount; ++i) {
|
|
const LPoint3f pandaPoint = MetaCoreToPandaPoint(glm::vec3(vertices[i].px, vertices[i].py, vertices[i].pz));
|
|
const LVector3f pandaNormal = MetaCoreToPandaVector(glm::vec3(vertices[i].nx, vertices[i].ny, vertices[i].nz));
|
|
vertexWriter.add_data3(pandaPoint);
|
|
normalWriter.add_data3(pandaNormal);
|
|
texcoordWriter.add_data2(vertices[i].u, vertices[i].v);
|
|
}
|
|
|
|
NodePath meshRoot(new PandaNode(name));
|
|
auto appendSubMesh = [&](
|
|
const std::string& subMeshName,
|
|
std::int32_t materialSlotIndex,
|
|
std::uint32_t firstIndex,
|
|
std::uint32_t subMeshIndexCount
|
|
) {
|
|
if (firstIndex >= iCount || subMeshIndexCount == 0) {
|
|
return;
|
|
}
|
|
|
|
const std::uint32_t clampedEnd = std::min<std::uint32_t>(iCount, firstIndex + subMeshIndexCount);
|
|
const std::uint32_t triangleEnd = firstIndex + ((clampedEnd - firstIndex) / 3U) * 3U;
|
|
if (triangleEnd <= firstIndex) {
|
|
return;
|
|
}
|
|
|
|
PT(GeomTriangles) triangles = new GeomTriangles(Geom::UH_static);
|
|
for (std::uint32_t i = firstIndex; i + 2 < triangleEnd; i += 3) {
|
|
triangles->add_vertices(indices[i], indices[i + 1], indices[i + 2]);
|
|
}
|
|
|
|
PT(Geom) geom = new Geom(vdata);
|
|
geom->add_primitive(triangles);
|
|
|
|
PT(GeomNode) node = new GeomNode(subMeshName);
|
|
node->add_geom(geom);
|
|
NodePath subMeshNode = meshRoot.attach_new_node(node);
|
|
subMeshNode.set_tag("MetaCoreMaterialSlotIndex", std::to_string(materialSlotIndex));
|
|
};
|
|
|
|
bool appendedAnySubMesh = false;
|
|
for (const MetaCoreMeshSubMeshDocument& subMesh : subMeshes) {
|
|
const std::uint32_t firstIndex = subMesh.FirstIndex;
|
|
const std::uint32_t subMeshIndexCount = subMesh.IndexCount == 0 ? iCount : subMesh.IndexCount;
|
|
const int childCountBefore = meshRoot.get_num_children();
|
|
appendSubMesh(
|
|
subMesh.Name.empty() ? (name + "_submesh") : subMesh.Name,
|
|
subMesh.MaterialSlotIndex,
|
|
firstIndex,
|
|
subMeshIndexCount
|
|
);
|
|
appendedAnySubMesh = appendedAnySubMesh || meshRoot.get_num_children() > childCountBefore;
|
|
}
|
|
|
|
if (!appendedAnySubMesh) {
|
|
appendSubMesh(name + "_submesh_0", 0, 0, iCount);
|
|
}
|
|
|
|
return meshRoot;
|
|
}
|
|
|
|
|
|
// Build a Panda3D Texture from MetaCore's binary texture payload.
|
|
[[nodiscard]] PT(Texture) MetaCoreBuildTextureFromBinary(
|
|
const std::string& name,
|
|
const MetaCoreTextureAssetDocument& doc,
|
|
std::span<const std::byte> payload
|
|
) {
|
|
if (doc.Width <= 0 || doc.Height <= 0 || doc.Channels <= 0) {
|
|
MetaCoreTrace("metacore.render: texture payload has invalid dimensions");
|
|
return nullptr;
|
|
}
|
|
|
|
PT(Texture) texture = new Texture(name);
|
|
|
|
// Choose the right format based on channel count
|
|
Texture::Format format = Texture::F_rgba8;
|
|
if (doc.Channels == 3) format = Texture::F_rgb8;
|
|
else if (doc.Channels == 1) format = Texture::F_luminance;
|
|
|
|
texture->setup_2d_texture(doc.Width, doc.Height, Texture::T_unsigned_byte, format);
|
|
|
|
// Copy payload data directly to Panda3D's RAM image buffer
|
|
PTA_uchar ramImage = texture->modify_ram_image();
|
|
if (ramImage.size() == payload.size()) {
|
|
std::memcpy(&ramImage[0], reinterpret_cast<const void*>(payload.data()), payload.size());
|
|
} else {
|
|
MetaCoreTrace(("metacore.render: texture payload size mismatch. expected=" +
|
|
std::to_string(ramImage.size()) + " actual=" + std::to_string(payload.size())).c_str());
|
|
return nullptr;
|
|
}
|
|
|
|
// Enable linear filtering by default for smoother look
|
|
texture->set_minfilter(SamplerState::FT_linear_mipmap_linear);
|
|
texture->set_magfilter(SamplerState::FT_linear);
|
|
|
|
return texture;
|
|
}
|
|
|
|
|
|
[[nodiscard]] PT(Shader) MetaCoreLoadSimplePbrShader() {
|
|
static PT(Shader) cachedShader;
|
|
static bool attemptedLoad = false;
|
|
if (attemptedLoad) {
|
|
return cachedShader;
|
|
}
|
|
|
|
attemptedLoad = true;
|
|
const std::filesystem::path shaderRoot = std::filesystem::current_path() / "simplepbr" / "shaders";
|
|
const std::filesystem::path vertexPath = shaderRoot / "simplepbr.vert";
|
|
const std::filesystem::path fragmentPath = shaderRoot / "simplepbr.frag";
|
|
if (!std::filesystem::exists(vertexPath) || !std::filesystem::exists(fragmentPath)) {
|
|
MetaCoreTrace("simplepbr: shader files missing in runtime directory");
|
|
return nullptr;
|
|
}
|
|
|
|
cachedShader = Shader::load(
|
|
Shader::SL_GLSL,
|
|
Filename::from_os_specific(vertexPath.string()),
|
|
Filename::from_os_specific(fragmentPath.string())
|
|
);
|
|
if (cachedShader == nullptr) {
|
|
MetaCoreTrace("simplepbr: failed to load GLSL shader");
|
|
} else {
|
|
MetaCoreTrace("simplepbr: shader loaded");
|
|
}
|
|
return cachedShader;
|
|
}
|
|
|
|
[[nodiscard]] PT(Texture) MetaCoreCreateSolidTexture(
|
|
const std::string& textureName,
|
|
unsigned char r,
|
|
unsigned char g,
|
|
unsigned char b,
|
|
unsigned char a
|
|
) {
|
|
PT(Texture) texture = new Texture(textureName);
|
|
texture->setup_2d_texture(1, 1, Texture::T_unsigned_byte, Texture::F_rgba8);
|
|
PTA_uchar image = texture->modify_ram_image();
|
|
if (image.size() >= 4) {
|
|
image[0] = r;
|
|
image[1] = g;
|
|
image[2] = b;
|
|
image[3] = a;
|
|
}
|
|
texture->set_minfilter(SamplerState::FT_nearest);
|
|
texture->set_magfilter(SamplerState::FT_nearest);
|
|
texture->set_wrap_u(SamplerState::WM_repeat);
|
|
texture->set_wrap_v(SamplerState::WM_repeat);
|
|
return texture;
|
|
}
|
|
|
|
[[nodiscard]] PT(Texture) MetaCoreCreateSolidCubeMap(
|
|
const std::string& textureName,
|
|
unsigned char r,
|
|
unsigned char g,
|
|
unsigned char b,
|
|
unsigned char a
|
|
) {
|
|
PT(Texture) texture = new Texture(textureName);
|
|
texture->setup_cube_map(1, Texture::T_unsigned_byte, Texture::F_rgba8);
|
|
PTA_uchar image = texture->modify_ram_image();
|
|
for (size_t index = 0; index + 3 < image.size(); index += 4) {
|
|
image[index + 0] = r;
|
|
image[index + 1] = g;
|
|
image[index + 2] = b;
|
|
image[index + 3] = a;
|
|
}
|
|
texture->set_minfilter(SamplerState::FT_nearest);
|
|
texture->set_magfilter(SamplerState::FT_nearest);
|
|
texture->set_wrap_u(SamplerState::WM_clamp);
|
|
texture->set_wrap_v(SamplerState::WM_clamp);
|
|
texture->set_wrap_w(SamplerState::WM_clamp);
|
|
return texture;
|
|
}
|
|
|
|
[[nodiscard]] PT(Texture) MetaCoreGetDefaultBaseColorTexture() {
|
|
static PT(Texture) texture = MetaCoreCreateSolidTexture("MetaCoreDefaultBaseColor", 255, 255, 255, 255);
|
|
return texture;
|
|
}
|
|
|
|
[[nodiscard]] PT(Texture) MetaCoreGetDefaultMetalRoughnessTexture() {
|
|
static PT(Texture) texture = MetaCoreCreateSolidTexture("MetaCoreDefaultMetalRoughness", 255, 255, 255, 255);
|
|
return texture;
|
|
}
|
|
|
|
[[nodiscard]] PT(Texture) MetaCoreGetDefaultEmissionTexture() {
|
|
static PT(Texture) texture = MetaCoreCreateSolidTexture("MetaCoreDefaultEmission", 0, 0, 0, 255);
|
|
return texture;
|
|
}
|
|
|
|
[[nodiscard]] PT(Texture) MetaCoreGetDefaultAoTexture() {
|
|
static PT(Texture) texture = MetaCoreCreateSolidTexture("MetaCoreDefaultAo", 255, 255, 255, 255);
|
|
return texture;
|
|
}
|
|
|
|
[[nodiscard]] PT(Texture) MetaCoreGetDefaultNormalTexture() {
|
|
static PT(Texture) texture = MetaCoreCreateSolidTexture("MetaCoreDefaultNormal", 128, 128, 255, 255);
|
|
return texture;
|
|
}
|
|
|
|
[[nodiscard]] PT(Texture) MetaCoreLoadBrdfLutTexture() {
|
|
static PT(Texture) cachedTexture;
|
|
static bool attemptedLoad = false;
|
|
if (attemptedLoad) {
|
|
return cachedTexture;
|
|
}
|
|
|
|
attemptedLoad = true;
|
|
const std::filesystem::path texturePath = std::filesystem::current_path() / "simplepbr" / "textures" / "brdf_lut.txo";
|
|
if (!std::filesystem::exists(texturePath)) {
|
|
MetaCoreTrace("simplepbr: brdf_lut.txo missing in runtime directory");
|
|
cachedTexture = MetaCoreCreateSolidTexture("MetaCoreFallbackBrdfLut", 255, 255, 255, 255);
|
|
return cachedTexture;
|
|
}
|
|
|
|
cachedTexture = TexturePool::load_texture(Filename::from_os_specific(texturePath.string()));
|
|
if (cachedTexture == nullptr) {
|
|
MetaCoreTrace("simplepbr: failed to load brdf_lut.txo");
|
|
cachedTexture = MetaCoreCreateSolidTexture("MetaCoreFallbackBrdfLut", 255, 255, 255, 255);
|
|
}
|
|
return cachedTexture;
|
|
}
|
|
|
|
[[nodiscard]] PT(Texture) MetaCoreGetDefaultFilteredEnvMap() {
|
|
static PT(Texture) texture = MetaCoreCreateSolidCubeMap("MetaCoreDefaultFilteredEnvMap", 0, 0, 0, 255);
|
|
return texture;
|
|
}
|
|
|
|
[[nodiscard]] PT(Texture) MetaCoreResolveTextureWithFallback(
|
|
const std::filesystem::path& projectRoot,
|
|
const MetaCoreAssetGuid& textureGuid,
|
|
const std::string& relativeTexturePath,
|
|
const PT(Texture)& fallbackTexture
|
|
) {
|
|
if (projectRoot.empty() || (!textureGuid.IsValid() && relativeTexturePath.empty())) {
|
|
return fallbackTexture;
|
|
}
|
|
|
|
const std::filesystem::path absoluteTexturePath =
|
|
relativeTexturePath.empty() ? std::filesystem::path{} : projectRoot / std::filesystem::path(relativeTexturePath);
|
|
std::filesystem::path binaryPackagePath;
|
|
if (textureGuid.IsValid()) {
|
|
binaryPackagePath =
|
|
projectRoot / "Library" / "RuntimeAssets" / "Textures" / (textureGuid.ToString() + ".mcasset");
|
|
}
|
|
if ((binaryPackagePath.empty() || !std::filesystem::exists(binaryPackagePath)) && !absoluteTexturePath.empty()) {
|
|
binaryPackagePath = std::filesystem::path(absoluteTexturePath.string() + ".mcasset");
|
|
}
|
|
|
|
if (std::filesystem::exists(binaryPackagePath)) {
|
|
MetaCoreTypeRegistry registry;
|
|
// We only need basic types for the asset document
|
|
MetaCoreRegisterFoundationGeneratedTypes(registry);
|
|
|
|
const auto package = MetaCoreReadPackageFile(binaryPackagePath, registry);
|
|
if (package.has_value() && package->PayloadSections.size() > 1) {
|
|
// First payload is the metadata (MetaCoreTextureAssetDocument)
|
|
MetaCoreTextureAssetDocument texDoc;
|
|
if (MetaCoreDeserializeFromBytes(package->PayloadSections[0], texDoc, registry)) {
|
|
PT(Texture) binaryTex = MetaCoreBuildTextureFromBinary(
|
|
relativeTexturePath,
|
|
texDoc,
|
|
package->PayloadSections[1]
|
|
);
|
|
if (binaryTex != nullptr) {
|
|
MetaCoreTrace(("metacore.render: texture binary load success: " + binaryPackagePath.string()).c_str());
|
|
return binaryTex;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (absoluteTexturePath.empty()) {
|
|
return fallbackTexture;
|
|
}
|
|
|
|
if (!std::filesystem::exists(absoluteTexturePath)) {
|
|
return fallbackTexture;
|
|
}
|
|
|
|
PT(Texture) texture = TexturePool::load_texture(Filename::from_os_specific(absoluteTexturePath.string()));
|
|
|
|
if (texture == nullptr) {
|
|
MetaCoreTrace(("metacore.render: backend texture load failed: " + absoluteTexturePath.string()).c_str());
|
|
return fallbackTexture;
|
|
}
|
|
|
|
return texture;
|
|
}
|
|
|
|
[[nodiscard]] PT(Texture) MetaCoreResolveBaseColorTexture(
|
|
const std::filesystem::path& projectRoot,
|
|
const MetaCoreAssetGuid& textureGuid,
|
|
const std::string& relativeTexturePath
|
|
) {
|
|
return MetaCoreResolveTextureWithFallback(projectRoot, textureGuid, relativeTexturePath, MetaCoreGetDefaultBaseColorTexture());
|
|
}
|
|
|
|
|
|
void MetaCoreApplyBaseColorTexture(
|
|
NodePath& meshNode,
|
|
const std::filesystem::path& projectRoot,
|
|
const MetaCoreAssetGuid& textureGuid,
|
|
const std::string& relativeTexturePath
|
|
) {
|
|
if (meshNode.is_empty()) {
|
|
return;
|
|
}
|
|
|
|
PT(Texture) texture = MetaCoreResolveBaseColorTexture(projectRoot, textureGuid, relativeTexturePath);
|
|
if (texture == nullptr) {
|
|
meshNode.set_texture_off(1);
|
|
return;
|
|
}
|
|
|
|
meshNode.set_texture(texture, 1);
|
|
meshNode.set_shader_input(InternalName::make("p3d_TextureBaseColor"), texture);
|
|
}
|
|
|
|
void MetaCoreApplyMetallicRoughnessTexture(
|
|
NodePath& meshNode,
|
|
const std::filesystem::path& projectRoot,
|
|
const MetaCoreAssetGuid& textureGuid,
|
|
const std::string& relativeTexturePath
|
|
) {
|
|
if (meshNode.is_empty()) {
|
|
return;
|
|
}
|
|
|
|
PT(Texture) texture = MetaCoreResolveTextureWithFallback(
|
|
projectRoot,
|
|
textureGuid,
|
|
relativeTexturePath,
|
|
MetaCoreGetDefaultMetalRoughnessTexture()
|
|
);
|
|
if (texture == nullptr) {
|
|
return;
|
|
}
|
|
|
|
meshNode.set_shader_input(InternalName::make("p3d_TextureMetalRoughness"), texture);
|
|
}
|
|
|
|
void MetaCoreApplyNormalTexture(
|
|
NodePath& meshNode,
|
|
const std::filesystem::path& projectRoot,
|
|
const MetaCoreAssetGuid& textureGuid,
|
|
const std::string& relativeTexturePath
|
|
) {
|
|
if (meshNode.is_empty()) {
|
|
return;
|
|
}
|
|
|
|
PT(Texture) texture = MetaCoreResolveTextureWithFallback(
|
|
projectRoot,
|
|
textureGuid,
|
|
relativeTexturePath,
|
|
MetaCoreGetDefaultNormalTexture()
|
|
);
|
|
if (texture == nullptr) {
|
|
return;
|
|
}
|
|
|
|
meshNode.set_shader_input(InternalName::make("p3d_TextureNormal"), texture);
|
|
}
|
|
|
|
void MetaCoreApplyEmissionTexture(
|
|
NodePath& meshNode,
|
|
const std::filesystem::path& projectRoot,
|
|
const MetaCoreAssetGuid& textureGuid,
|
|
const std::string& relativeTexturePath
|
|
) {
|
|
if (meshNode.is_empty()) {
|
|
return;
|
|
}
|
|
|
|
PT(Texture) texture = MetaCoreResolveTextureWithFallback(
|
|
projectRoot,
|
|
textureGuid,
|
|
relativeTexturePath,
|
|
MetaCoreGetDefaultEmissionTexture()
|
|
);
|
|
if (texture == nullptr) {
|
|
return;
|
|
}
|
|
|
|
meshNode.set_shader_input(InternalName::make("p3d_TextureEmission"), texture);
|
|
}
|
|
|
|
void MetaCoreApplyAoTexture(
|
|
NodePath& meshNode,
|
|
const std::filesystem::path& projectRoot,
|
|
const MetaCoreAssetGuid& textureGuid,
|
|
const std::string& relativeTexturePath
|
|
) {
|
|
if (meshNode.is_empty()) {
|
|
return;
|
|
}
|
|
|
|
PT(Texture) texture = MetaCoreResolveTextureWithFallback(
|
|
projectRoot,
|
|
textureGuid,
|
|
relativeTexturePath,
|
|
MetaCoreGetDefaultAoTexture()
|
|
);
|
|
if (texture == nullptr) {
|
|
return;
|
|
}
|
|
|
|
meshNode.set_shader_input(InternalName::make("p3d_TextureOcclusion"), texture);
|
|
}
|
|
|
|
void MetaCoreApplySimplePbrPreview(NodePath& meshNode) {
|
|
if (meshNode.is_empty()) {
|
|
return;
|
|
}
|
|
|
|
PT(Shader) simplePbrShader = MetaCoreLoadSimplePbrShader();
|
|
if (simplePbrShader == nullptr) {
|
|
meshNode.clear_shader();
|
|
return;
|
|
}
|
|
|
|
meshNode.set_shader(simplePbrShader, 1);
|
|
}
|
|
|
|
void MetaCoreApplySimplePbrMaterialInputs(
|
|
NodePath& meshNode,
|
|
const MetaCoreMeshRendererComponent& meshRenderer
|
|
) {
|
|
if (meshNode.is_empty()) {
|
|
return;
|
|
}
|
|
|
|
meshNode.set_shader_input(
|
|
InternalName::make("p3d_Material.baseColor"),
|
|
LVecBase4(
|
|
meshRenderer.BaseColor.r,
|
|
meshRenderer.BaseColor.g,
|
|
meshRenderer.BaseColor.b,
|
|
1.0F
|
|
)
|
|
);
|
|
meshNode.set_shader_input(
|
|
InternalName::make("p3d_Material.roughness"),
|
|
LVecBase4(meshRenderer.Roughness, 0.0F, 0.0F, 0.0F)
|
|
);
|
|
meshNode.set_shader_input(
|
|
InternalName::make("p3d_Material.metallic"),
|
|
LVecBase4(meshRenderer.Metallic, 0.0F, 0.0F, 0.0F)
|
|
);
|
|
meshNode.set_shader_input(
|
|
InternalName::make("p3d_Material.emission"),
|
|
LVecBase4(
|
|
meshRenderer.EmissiveColor.r,
|
|
meshRenderer.EmissiveColor.g,
|
|
meshRenderer.EmissiveColor.b,
|
|
1.0F
|
|
)
|
|
);
|
|
meshNode.set_shader_input(
|
|
InternalName::make("p3d_TextureMetalRoughness"),
|
|
MetaCoreGetDefaultMetalRoughnessTexture()
|
|
);
|
|
meshNode.set_shader_input(
|
|
InternalName::make("p3d_TextureNormal"),
|
|
MetaCoreGetDefaultNormalTexture()
|
|
);
|
|
meshNode.set_shader_input(
|
|
InternalName::make("p3d_TextureEmission"),
|
|
MetaCoreGetDefaultEmissionTexture()
|
|
);
|
|
meshNode.set_shader_input(
|
|
InternalName::make("p3d_TextureOcclusion"),
|
|
MetaCoreGetDefaultAoTexture()
|
|
);
|
|
meshNode.set_shader_input(
|
|
InternalName::make("brdf_lut"),
|
|
MetaCoreLoadBrdfLutTexture()
|
|
);
|
|
meshNode.set_shader_input(
|
|
InternalName::make("filtered_env_map"),
|
|
MetaCoreGetDefaultFilteredEnvMap()
|
|
);
|
|
meshNode.set_shader_input(
|
|
InternalName::make("max_reflection_lod"),
|
|
LVecBase4(0.0F, 0.0F, 0.0F, 0.0F)
|
|
);
|
|
meshNode.set_shader_input(
|
|
InternalName::make("metacore_AlphaCutoff"),
|
|
LVecBase4(meshRenderer.AlphaCutoff, 0.0F, 0.0F, 0.0F)
|
|
);
|
|
meshNode.set_shader_input(
|
|
InternalName::make("metacore_AlphaMode"),
|
|
LVecBase4(static_cast<float>(meshRenderer.AlphaMode), 0.0F, 0.0F, 0.0F)
|
|
);
|
|
}
|
|
|
|
[[nodiscard]] std::string MetaCoreFindTextureSourcePath(
|
|
const MetaCoreModelAssetDocument& modelDoc,
|
|
const MetaCoreAssetGuid& textureGuid
|
|
) {
|
|
if (!textureGuid.IsValid()) {
|
|
return {};
|
|
}
|
|
|
|
const auto textureIterator = std::find_if(
|
|
modelDoc.GeneratedTextureAssets.begin(),
|
|
modelDoc.GeneratedTextureAssets.end(),
|
|
[&](const MetaCoreTextureAssetDocument& textureAsset) {
|
|
return textureAsset.AssetGuid == textureGuid;
|
|
}
|
|
);
|
|
return textureIterator != modelDoc.GeneratedTextureAssets.end()
|
|
? textureIterator->SourcePath.generic_string()
|
|
: std::string{};
|
|
}
|
|
|
|
[[nodiscard]] MetaCoreMeshRendererComponent MetaCoreBuildMaterialPreviewComponent(
|
|
const MetaCoreModelAssetDocument& modelDoc,
|
|
const MetaCoreMaterialAssetDocument& materialAsset
|
|
) {
|
|
MetaCoreMeshRendererComponent preview;
|
|
preview.BaseColor = materialAsset.BaseColor;
|
|
preview.DoubleSided = materialAsset.DoubleSided;
|
|
preview.Metallic = materialAsset.Metallic;
|
|
preview.Roughness = materialAsset.Roughness;
|
|
preview.AlphaCutoff = materialAsset.AlphaCutoff;
|
|
preview.EmissiveColor = materialAsset.EmissiveColor;
|
|
preview.AlphaMode =
|
|
materialAsset.AlphaMode == MetaCoreMaterialAlphaMode::Mask
|
|
? MetaCoreMeshAlphaMode::Mask
|
|
: (materialAsset.AlphaMode == MetaCoreMaterialAlphaMode::Blend
|
|
? MetaCoreMeshAlphaMode::Blend
|
|
: MetaCoreMeshAlphaMode::Opaque);
|
|
preview.BaseColorTextureGuid = materialAsset.BaseColorTexture;
|
|
preview.MetallicRoughnessTextureGuid = materialAsset.MetallicRoughnessTexture;
|
|
preview.NormalTextureGuid = materialAsset.NormalTexture;
|
|
preview.EmissiveTextureGuid = materialAsset.EmissiveTexture;
|
|
preview.AoTextureGuid = materialAsset.AoTexture;
|
|
preview.BaseColorTexturePath = MetaCoreFindTextureSourcePath(modelDoc, materialAsset.BaseColorTexture);
|
|
preview.MetallicRoughnessTexturePath = MetaCoreFindTextureSourcePath(modelDoc, materialAsset.MetallicRoughnessTexture);
|
|
preview.NormalTexturePath = MetaCoreFindTextureSourcePath(modelDoc, materialAsset.NormalTexture);
|
|
preview.EmissiveTexturePath = MetaCoreFindTextureSourcePath(modelDoc, materialAsset.EmissiveTexture);
|
|
preview.AoTexturePath = MetaCoreFindTextureSourcePath(modelDoc, materialAsset.AoTexture);
|
|
return preview;
|
|
}
|
|
|
|
void MetaCoreApplyMaterialPreviewToNode(
|
|
NodePath& meshNode,
|
|
const std::filesystem::path& projectRoot,
|
|
const MetaCoreMeshRendererComponent& materialPreview,
|
|
const NodePath& sceneRootNode,
|
|
const NodePath* cameraNode
|
|
) {
|
|
if (meshNode.is_empty()) {
|
|
return;
|
|
}
|
|
|
|
meshNode.set_material_off(1);
|
|
meshNode.set_light_off(1);
|
|
meshNode.set_two_sided(materialPreview.DoubleSided);
|
|
meshNode.set_color(
|
|
materialPreview.BaseColor.r,
|
|
materialPreview.BaseColor.g,
|
|
materialPreview.BaseColor.b,
|
|
1.0F
|
|
);
|
|
MetaCoreApplyBaseColorTexture(
|
|
meshNode,
|
|
projectRoot,
|
|
materialPreview.BaseColorTextureGuid,
|
|
materialPreview.BaseColorTexturePath
|
|
);
|
|
MetaCoreApplyMetallicRoughnessTexture(
|
|
meshNode,
|
|
projectRoot,
|
|
materialPreview.MetallicRoughnessTextureGuid,
|
|
materialPreview.MetallicRoughnessTexturePath
|
|
);
|
|
MetaCoreApplyNormalTexture(
|
|
meshNode,
|
|
projectRoot,
|
|
materialPreview.NormalTextureGuid,
|
|
materialPreview.NormalTexturePath
|
|
);
|
|
MetaCoreApplyEmissionTexture(
|
|
meshNode,
|
|
projectRoot,
|
|
materialPreview.EmissiveTextureGuid,
|
|
materialPreview.EmissiveTexturePath
|
|
);
|
|
MetaCoreApplyAoTexture(
|
|
meshNode,
|
|
projectRoot,
|
|
materialPreview.AoTextureGuid,
|
|
materialPreview.AoTexturePath
|
|
);
|
|
MetaCoreApplySimplePbrPreview(meshNode);
|
|
MetaCoreApplySimplePbrMaterialInputs(meshNode, materialPreview);
|
|
if (cameraNode != nullptr) {
|
|
MetaCoreApplySimplePbrViewInputs(meshNode, sceneRootNode, *cameraNode);
|
|
}
|
|
|
|
if (materialPreview.AlphaMode == MetaCoreMeshAlphaMode::Blend) {
|
|
meshNode.set_transparency(TransparencyAttrib::M_alpha);
|
|
} else if (materialPreview.AlphaMode == MetaCoreMeshAlphaMode::Mask) {
|
|
meshNode.set_transparency(TransparencyAttrib::M_binary);
|
|
} else {
|
|
meshNode.clear_transparency();
|
|
}
|
|
}
|
|
|
|
void MetaCoreApplyMaterialSlotsToSubMeshes(
|
|
NodePath& meshNode,
|
|
const std::filesystem::path& projectRoot,
|
|
const MetaCoreMeshRendererComponent& meshRenderer,
|
|
const MetaCoreModelAssetDocument& modelDoc,
|
|
const NodePath& sceneRootNode,
|
|
const NodePath* cameraNode
|
|
) {
|
|
if (meshNode.is_empty()) {
|
|
return;
|
|
}
|
|
|
|
NodePathCollection subMeshNodes = meshNode.find_all_matches("**/=MetaCoreMaterialSlotIndex");
|
|
for (int nodeIndex = 0; nodeIndex < subMeshNodes.get_num_paths(); ++nodeIndex) {
|
|
NodePath subMeshNode = subMeshNodes.get_path(nodeIndex);
|
|
const std::string slotText = subMeshNode.get_tag("MetaCoreMaterialSlotIndex");
|
|
char* parseEnd = nullptr;
|
|
const long slotIndex = std::strtol(slotText.c_str(), &parseEnd, 10);
|
|
if (parseEnd == slotText.c_str() || slotIndex < 0 ||
|
|
static_cast<std::size_t>(slotIndex) >= meshRenderer.MaterialAssetGuids.size()) {
|
|
MetaCoreApplyMaterialPreviewToNode(subMeshNode, projectRoot, meshRenderer, sceneRootNode, cameraNode);
|
|
continue;
|
|
}
|
|
|
|
const MetaCoreAssetGuid materialGuid =
|
|
meshRenderer.MaterialAssetGuids[static_cast<std::size_t>(slotIndex)];
|
|
if (!materialGuid.IsValid()) {
|
|
MetaCoreApplyMaterialPreviewToNode(subMeshNode, projectRoot, meshRenderer, sceneRootNode, cameraNode);
|
|
continue;
|
|
}
|
|
|
|
const auto materialIterator = std::find_if(
|
|
modelDoc.GeneratedMaterialAssets.begin(),
|
|
modelDoc.GeneratedMaterialAssets.end(),
|
|
[&](const MetaCoreMaterialAssetDocument& materialAsset) {
|
|
return materialAsset.AssetGuid == materialGuid;
|
|
}
|
|
);
|
|
if (materialIterator == modelDoc.GeneratedMaterialAssets.end()) {
|
|
MetaCoreApplyMaterialPreviewToNode(subMeshNode, projectRoot, meshRenderer, sceneRootNode, cameraNode);
|
|
continue;
|
|
}
|
|
|
|
MetaCoreMeshRendererComponent materialPreview =
|
|
MetaCoreBuildMaterialPreviewComponent(modelDoc, *materialIterator);
|
|
MetaCoreApplyMaterialPreviewToNode(
|
|
subMeshNode,
|
|
projectRoot,
|
|
materialPreview,
|
|
sceneRootNode,
|
|
cameraNode
|
|
);
|
|
}
|
|
}
|
|
|
|
void MetaCoreApplySimplePbrViewInputs(
|
|
NodePath& meshNode,
|
|
const NodePath& sceneRootNode,
|
|
const NodePath& cameraNode
|
|
) {
|
|
if (meshNode.is_empty()) {
|
|
return;
|
|
}
|
|
|
|
LPoint3f cameraWorldPosition(0.0F, 0.0F, 0.0F);
|
|
if (!cameraNode.is_empty()) {
|
|
cameraWorldPosition = cameraNode.get_pos(sceneRootNode);
|
|
}
|
|
|
|
meshNode.set_shader_input(
|
|
InternalName::make("camera_world_position"),
|
|
LVecBase3f(cameraWorldPosition.get_x(), cameraWorldPosition.get_y(), cameraWorldPosition.get_z())
|
|
);
|
|
}
|
|
|
|
glm::mat4 MetaCoreConvertPandaMatrixToGlm(const LMatrix4f& matrix) {
|
|
glm::mat4 result(1.0F);
|
|
for (int col = 0; col < 4; ++col) {
|
|
for (int row = 0; row < 4; ++row) {
|
|
result[col][row] = matrix.get_cell(col, row);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
class MetaCorePandaSceneBridge::MetaCorePandaSceneBridgeImpl {
|
|
public:
|
|
struct MetaCorePandaObjectState {
|
|
NodePath RootNode{};
|
|
NodePath MeshNode{};
|
|
NodePath LightNode{};
|
|
MetaCoreMeshSourceKind MeshSource = MetaCoreMeshSourceKind::Builtin;
|
|
MetaCoreBuiltinMeshType BuiltinMesh = MetaCoreBuiltinMeshType::Cube;
|
|
MetaCoreAssetGuid MeshAssetGuid{};
|
|
MetaCoreAssetGuid SourceModelAssetGuid{};
|
|
std::string SourceModelPath{};
|
|
std::int32_t ModelNodeIndex = -1;
|
|
std::vector<MetaCoreAssetGuid> MaterialAssetGuids{};
|
|
bool IsUsingPlaceholder = false;
|
|
};
|
|
|
|
MetaCoreRenderDevice* RenderDevice = nullptr;
|
|
NodePath GridNode{};
|
|
NodePath AmbientLightNode{};
|
|
std::filesystem::path ProjectRootPath{};
|
|
MetaCoreId SelectedObjectId = 0;
|
|
std::unordered_map<MetaCoreId, MetaCorePandaObjectState> ObjectStates{};
|
|
|
|
// Asset Management
|
|
std::mutex CacheMutex{};
|
|
std::unordered_map<std::string, NodePath> ModelCache{};
|
|
bool RuntimeSyncFailure = false;
|
|
std::string LastRuntimeSyncFailure{};
|
|
};
|
|
|
|
MetaCorePandaSceneBridge::MetaCorePandaSceneBridge()
|
|
: Impl_(std::make_unique<MetaCorePandaSceneBridgeImpl>()) {
|
|
}
|
|
|
|
MetaCorePandaSceneBridge::~MetaCorePandaSceneBridge() {
|
|
Shutdown();
|
|
}
|
|
|
|
bool MetaCorePandaSceneBridge::Initialize(MetaCoreRenderDevice& renderDevice) {
|
|
Shutdown();
|
|
|
|
auto* windowFrameworkHandle = static_cast<WindowFramework*>(renderDevice.GetNativeWindowFrameworkHandle());
|
|
auto* sceneRootHandle = static_cast<NodePath*>(renderDevice.GetNativeSceneRootHandle());
|
|
if (windowFrameworkHandle == nullptr || sceneRootHandle == nullptr || sceneRootHandle->is_empty()) {
|
|
return false;
|
|
}
|
|
|
|
Impl_->RenderDevice = &renderDevice;
|
|
Impl_->ProjectRootPath = MetaCoreResolveProjectRootFromEnvironment();
|
|
|
|
Impl_->GridNode = MetaCoreCreateGridNode(*sceneRootHandle);
|
|
if (!Impl_->GridNode.is_empty()) {
|
|
Impl_->GridNode.set_light_off(1);
|
|
}
|
|
|
|
PT(AmbientLight) ambientLight = new AmbientLight("MetaCoreAmbientLight");
|
|
ambientLight->set_color(LColor(0.85F, 0.85F, 0.85F, 1.0F));
|
|
Impl_->AmbientLightNode = sceneRootHandle->attach_new_node(ambientLight);
|
|
sceneRootHandle->set_light(Impl_->AmbientLightNode);
|
|
|
|
return true;
|
|
}
|
|
|
|
void MetaCorePandaSceneBridge::Shutdown() {
|
|
if (Impl_ == nullptr) {
|
|
return;
|
|
}
|
|
|
|
for (auto& [objectId, objectState] : Impl_->ObjectStates) {
|
|
(void)objectId;
|
|
if (!objectState.MeshNode.is_empty()) {
|
|
objectState.MeshNode.remove_node();
|
|
objectState.MeshNode = NodePath();
|
|
}
|
|
if (!objectState.LightNode.is_empty()) {
|
|
objectState.LightNode.remove_node();
|
|
objectState.LightNode = NodePath();
|
|
}
|
|
if (!objectState.RootNode.is_empty()) {
|
|
objectState.RootNode.remove_node();
|
|
objectState.RootNode = NodePath();
|
|
}
|
|
}
|
|
Impl_->ObjectStates.clear();
|
|
|
|
// Clear asset cache
|
|
{
|
|
std::lock_guard<std::mutex> lock(Impl_->CacheMutex);
|
|
for (auto& [path, node] : Impl_->ModelCache) {
|
|
node.remove_node();
|
|
}
|
|
Impl_->ModelCache.clear();
|
|
}
|
|
|
|
if (!Impl_->AmbientLightNode.is_empty()) {
|
|
Impl_->AmbientLightNode.remove_node();
|
|
Impl_->AmbientLightNode = NodePath();
|
|
}
|
|
|
|
|
|
if (!Impl_->GridNode.is_empty()) {
|
|
Impl_->GridNode.remove_node();
|
|
Impl_->GridNode = NodePath();
|
|
}
|
|
|
|
Impl_->RenderDevice = nullptr;
|
|
Impl_->ProjectRootPath.clear();
|
|
Impl_->SelectedObjectId = 0;
|
|
Impl_->RuntimeSyncFailure = false;
|
|
Impl_->LastRuntimeSyncFailure.clear();
|
|
}
|
|
|
|
void MetaCorePandaSceneBridge::SetProjectRootPath(const std::filesystem::path& projectRootPath) {
|
|
if (Impl_ == nullptr) {
|
|
return;
|
|
}
|
|
if (Impl_->ProjectRootPath != projectRootPath) {
|
|
std::lock_guard<std::mutex> lock(Impl_->CacheMutex);
|
|
for (auto& [cacheKey, node] : Impl_->ModelCache) {
|
|
(void)cacheKey;
|
|
node.remove_node();
|
|
}
|
|
Impl_->ModelCache.clear();
|
|
}
|
|
Impl_->ProjectRootPath = projectRootPath;
|
|
MetaCoreTrace(("metacore.render: project root path set to " + projectRootPath.string()).c_str());
|
|
}
|
|
|
|
void MetaCorePandaSceneBridge::SyncScene(const MetaCoreScene& scene, bool compatibilityMeshOnly) {
|
|
if (Impl_->RuntimeSyncFailure) {
|
|
return;
|
|
}
|
|
|
|
if (Impl_->RenderDevice == nullptr) {
|
|
return;
|
|
}
|
|
|
|
auto* windowFrameworkHandle = static_cast<WindowFramework*>(Impl_->RenderDevice->GetNativeWindowFrameworkHandle());
|
|
auto* sceneRootHandle = static_cast<NodePath*>(Impl_->RenderDevice->GetNativeSceneRootHandle());
|
|
if (windowFrameworkHandle == nullptr || sceneRootHandle == nullptr || sceneRootHandle->is_empty()) {
|
|
return;
|
|
}
|
|
|
|
std::unordered_set<MetaCoreId> aliveObjectIds;
|
|
|
|
for (const MetaCoreGameObject& gameObject : scene.GetGameObjects()) {
|
|
if (compatibilityMeshOnly && !gameObject.HasComponent<MetaCoreMeshRendererComponent>()) {
|
|
continue;
|
|
}
|
|
std::string syncStage = "begin";
|
|
try {
|
|
aliveObjectIds.insert(gameObject.GetId());
|
|
syncStage = "object_state_lookup";
|
|
auto [iterator, inserted] = Impl_->ObjectStates.try_emplace(gameObject.GetId());
|
|
MetaCorePandaSceneBridgeImpl::MetaCorePandaObjectState& objectState = iterator->second;
|
|
if (!compatibilityMeshOnly) {
|
|
if (inserted || objectState.RootNode.is_empty()) {
|
|
syncStage = "create_root_node";
|
|
PT(PandaNode) rootNode = new PandaNode("MetaCoreObject");
|
|
syncStage = "attach_root_node";
|
|
objectState.RootNode = sceneRootHandle->attach_new_node(rootNode);
|
|
}
|
|
|
|
syncStage = "apply_transform";
|
|
MetaCoreApplyTransformToPandaNode(gameObject.GetComponent<MetaCoreTransformComponent>(), objectState.RootNode);
|
|
|
|
if (gameObject.GetParentId() != 0) {
|
|
syncStage = "reparent_parent";
|
|
const auto parentIterator = Impl_->ObjectStates.find(gameObject.GetParentId());
|
|
if (parentIterator != Impl_->ObjectStates.end() && !parentIterator->second.RootNode.is_empty()) {
|
|
objectState.RootNode.reparent_to(parentIterator->second.RootNode);
|
|
} else {
|
|
syncStage = "reparent_scene_root_from_parent";
|
|
objectState.RootNode.reparent_to(*sceneRootHandle);
|
|
}
|
|
} else {
|
|
syncStage = "reparent_scene_root";
|
|
objectState.RootNode.reparent_to(*sceneRootHandle);
|
|
}
|
|
} else if (!objectState.RootNode.is_empty()) {
|
|
objectState.RootNode.remove_node();
|
|
objectState.RootNode = NodePath();
|
|
}
|
|
|
|
if (gameObject.HasComponent<MetaCoreMeshRendererComponent>()) {
|
|
syncStage = "mesh_renderer";
|
|
const bool materialSlotsChanged =
|
|
objectState.MaterialAssetGuids != gameObject.GetComponent<MetaCoreMeshRendererComponent>().MaterialAssetGuids;
|
|
const bool requiresMeshRebuild =
|
|
objectState.MeshNode.is_empty() ||
|
|
objectState.MeshSource != gameObject.GetComponent<MetaCoreMeshRendererComponent>().MeshSource ||
|
|
(gameObject.GetComponent<MetaCoreMeshRendererComponent>().MeshSource == MetaCoreMeshSourceKind::Builtin &&
|
|
objectState.BuiltinMesh != gameObject.GetComponent<MetaCoreMeshRendererComponent>().BuiltinMesh) ||
|
|
(gameObject.GetComponent<MetaCoreMeshRendererComponent>().MeshSource == MetaCoreMeshSourceKind::Asset &&
|
|
(objectState.MeshAssetGuid != gameObject.GetComponent<MetaCoreMeshRendererComponent>().MeshAssetGuid ||
|
|
objectState.SourceModelAssetGuid != gameObject.GetComponent<MetaCoreMeshRendererComponent>().SourceModelAssetGuid ||
|
|
(MetaCoreShouldCompareSourceModelPath(
|
|
objectState.SourceModelAssetGuid,
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().SourceModelAssetGuid
|
|
) &&
|
|
objectState.SourceModelPath != gameObject.GetComponent<MetaCoreMeshRendererComponent>().SourceModelPath) ||
|
|
objectState.ModelNodeIndex != gameObject.GetComponent<MetaCoreMeshRendererComponent>().ModelNodeIndex));
|
|
|
|
if (requiresMeshRebuild && !objectState.MeshNode.is_empty()) {
|
|
objectState.MeshNode.remove_node();
|
|
objectState.MeshNode = NodePath();
|
|
}
|
|
|
|
if (requiresMeshRebuild) {
|
|
NodePath meshParent = compatibilityMeshOnly ? *sceneRootHandle : objectState.RootNode;
|
|
if (gameObject.GetComponent<MetaCoreMeshRendererComponent>().MeshSource == MetaCoreMeshSourceKind::Builtin) {
|
|
objectState.MeshNode = MetaCoreCreateUnitCubeNode(windowFrameworkHandle, meshParent);
|
|
objectState.IsUsingPlaceholder = false;
|
|
} else {
|
|
const std::string& path = gameObject.GetComponent<MetaCoreMeshRendererComponent>().SourceModelPath;
|
|
const std::string modelCacheKey = MetaCoreBuildModelCacheKey(
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().SourceModelAssetGuid,
|
|
path
|
|
);
|
|
|
|
// 1. Check Model Cache
|
|
bool foundInCache = false;
|
|
{
|
|
std::lock_guard<std::mutex> lock(Impl_->CacheMutex);
|
|
auto it = Impl_->ModelCache.find(modelCacheKey);
|
|
if (it != Impl_->ModelCache.end()) {
|
|
NodePath masterNode = it->second;
|
|
if (gameObject.GetComponent<MetaCoreMeshRendererComponent>().ModelNodeIndex < 0) {
|
|
objectState.MeshNode = masterNode.copy_to(meshParent);
|
|
} else {
|
|
NodePath subNode = masterNode.find("**/=MetaCoreNodeIndex=" + std::to_string(gameObject.GetComponent<MetaCoreMeshRendererComponent>().ModelNodeIndex));
|
|
if (!subNode.is_empty()) {
|
|
objectState.MeshNode = subNode.copy_to(meshParent);
|
|
objectState.MeshNode.set_mat(LMatrix4::ident_mat());
|
|
|
|
// Only remove children that are tagged as MetaCore model nodes,
|
|
// as these represent separate game objects in our hierarchy.
|
|
// This preserves internal geometry nodes (GeomNodes) of the targeted node.
|
|
NodePathCollection children = objectState.MeshNode.get_children();
|
|
for (int i = 0; i < children.get_num_paths(); ++i) {
|
|
NodePath child = children.get_path(i);
|
|
if (child.has_tag("MetaCoreNodeIndex")) {
|
|
child.remove_node();
|
|
}
|
|
}
|
|
} else {
|
|
objectState.MeshNode = masterNode.copy_to(meshParent);
|
|
}
|
|
}
|
|
objectState.IsUsingPlaceholder = false;
|
|
foundInCache = true;
|
|
}
|
|
}
|
|
|
|
if (!foundInCache) {
|
|
const std::filesystem::path& projectRoot =
|
|
!Impl_->ProjectRootPath.empty()
|
|
? Impl_->ProjectRootPath
|
|
: (Impl_->ProjectRootPath = MetaCoreResolveProjectRootFromEnvironment());
|
|
|
|
NodePath masterNode = MetaCoreTryLoadModelRuntimeAsset(MetaCoreRuntimeModelLoadRequest{
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().SourceModelAssetGuid,
|
|
projectRoot,
|
|
path,
|
|
false
|
|
});
|
|
if (!masterNode.is_empty()) {
|
|
{
|
|
std::lock_guard<std::mutex> lock(Impl_->CacheMutex);
|
|
Impl_->ModelCache[modelCacheKey] = masterNode;
|
|
}
|
|
|
|
if (gameObject.GetComponent<MetaCoreMeshRendererComponent>().ModelNodeIndex < 0) {
|
|
objectState.MeshNode = masterNode.copy_to(meshParent);
|
|
} else {
|
|
NodePath subNode = masterNode.find("**/=MetaCoreNodeIndex=" + std::to_string(gameObject.GetComponent<MetaCoreMeshRendererComponent>().ModelNodeIndex));
|
|
if (!subNode.is_empty()) {
|
|
objectState.MeshNode = subNode.copy_to(meshParent);
|
|
objectState.MeshNode.set_mat(LMatrix4::ident_mat());
|
|
|
|
NodePathCollection children = objectState.MeshNode.get_children();
|
|
for (int i = 0; i < children.get_num_paths(); ++i) {
|
|
NodePath child = children.get_path(i);
|
|
if (child.has_tag("MetaCoreNodeIndex")) {
|
|
child.remove_node();
|
|
}
|
|
}
|
|
} else {
|
|
objectState.MeshNode = masterNode.copy_to(meshParent);
|
|
}
|
|
}
|
|
objectState.IsUsingPlaceholder = false;
|
|
} else {
|
|
objectState.MeshNode = MetaCoreCreateUnitCubeNode(windowFrameworkHandle, meshParent);
|
|
objectState.MeshNode.set_scale(0.2F);
|
|
objectState.IsUsingPlaceholder = true;
|
|
}
|
|
}
|
|
}
|
|
objectState.MeshSource = gameObject.GetComponent<MetaCoreMeshRendererComponent>().MeshSource;
|
|
objectState.BuiltinMesh = gameObject.GetComponent<MetaCoreMeshRendererComponent>().BuiltinMesh;
|
|
objectState.MeshAssetGuid = gameObject.GetComponent<MetaCoreMeshRendererComponent>().MeshAssetGuid;
|
|
objectState.SourceModelAssetGuid = gameObject.GetComponent<MetaCoreMeshRendererComponent>().SourceModelAssetGuid;
|
|
objectState.SourceModelPath = gameObject.GetComponent<MetaCoreMeshRendererComponent>().SourceModelPath;
|
|
objectState.ModelNodeIndex = gameObject.GetComponent<MetaCoreMeshRendererComponent>().ModelNodeIndex;
|
|
}
|
|
|
|
if (!objectState.MeshNode.is_empty()) {
|
|
if (compatibilityMeshOnly) {
|
|
syncStage = "apply_mesh_transform";
|
|
const MetaCoreTransformComponent worldTransform = MetaCoreBuildWorldTransformComponent(scene, gameObject);
|
|
MetaCoreApplyTransformToPandaNode(worldTransform, objectState.MeshNode);
|
|
}
|
|
if (materialSlotsChanged) {
|
|
syncStage = "refresh_material_slots";
|
|
}
|
|
const bool useAssetPreviewPath =
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().MeshSource == MetaCoreMeshSourceKind::Asset &&
|
|
!objectState.IsUsingPlaceholder;
|
|
objectState.MeshNode.set_material_off(1);
|
|
objectState.MeshNode.set_light_off(1);
|
|
objectState.MeshNode.set_two_sided(gameObject.GetComponent<MetaCoreMeshRendererComponent>().DoubleSided);
|
|
objectState.MeshNode.set_color(
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().BaseColor.r,
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().BaseColor.g,
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().BaseColor.b,
|
|
1.0F
|
|
);
|
|
if (useAssetPreviewPath) {
|
|
MetaCoreApplyBaseColorTexture(
|
|
objectState.MeshNode,
|
|
Impl_->ProjectRootPath,
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().BaseColorTextureGuid,
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().BaseColorTexturePath
|
|
);
|
|
MetaCoreApplyMetallicRoughnessTexture(
|
|
objectState.MeshNode,
|
|
Impl_->ProjectRootPath,
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().MetallicRoughnessTextureGuid,
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().MetallicRoughnessTexturePath
|
|
);
|
|
MetaCoreApplyNormalTexture(
|
|
objectState.MeshNode,
|
|
Impl_->ProjectRootPath,
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().NormalTextureGuid,
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().NormalTexturePath
|
|
);
|
|
MetaCoreApplyEmissionTexture(
|
|
objectState.MeshNode,
|
|
Impl_->ProjectRootPath,
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().EmissiveTextureGuid,
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().EmissiveTexturePath
|
|
);
|
|
MetaCoreApplyAoTexture(
|
|
objectState.MeshNode,
|
|
Impl_->ProjectRootPath,
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().AoTextureGuid,
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().AoTexturePath
|
|
);
|
|
MetaCoreApplySimplePbrPreview(objectState.MeshNode);
|
|
MetaCoreApplySimplePbrMaterialInputs(objectState.MeshNode, gameObject.GetComponent<MetaCoreMeshRendererComponent>());
|
|
auto* editorCameraHandle = static_cast<NodePath*>(Impl_->RenderDevice->GetNativeEditorCameraHandle());
|
|
if (editorCameraHandle != nullptr) {
|
|
MetaCoreApplySimplePbrViewInputs(objectState.MeshNode, *sceneRootHandle, *editorCameraHandle);
|
|
}
|
|
const std::filesystem::path& projectRoot =
|
|
!Impl_->ProjectRootPath.empty()
|
|
? Impl_->ProjectRootPath
|
|
: (Impl_->ProjectRootPath = MetaCoreResolveProjectRootFromEnvironment());
|
|
const auto modelDoc = MetaCoreReadRuntimeModelDocument(MetaCoreRuntimeModelLoadRequest{
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().SourceModelAssetGuid,
|
|
projectRoot,
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>().SourceModelPath,
|
|
false
|
|
});
|
|
if (modelDoc.has_value()) {
|
|
MetaCoreApplyMaterialSlotsToSubMeshes(
|
|
objectState.MeshNode,
|
|
projectRoot,
|
|
gameObject.GetComponent<MetaCoreMeshRendererComponent>(),
|
|
*modelDoc,
|
|
*sceneRootHandle,
|
|
editorCameraHandle
|
|
);
|
|
}
|
|
objectState.MaterialAssetGuids = gameObject.GetComponent<MetaCoreMeshRendererComponent>().MaterialAssetGuids;
|
|
} else {
|
|
objectState.MeshNode.set_texture_off(1);
|
|
objectState.MeshNode.set_shader_off(1);
|
|
objectState.MaterialAssetGuids.clear();
|
|
}
|
|
|
|
if (gameObject.GetComponent<MetaCoreMeshRendererComponent>().AlphaMode == MetaCoreMeshAlphaMode::Blend) {
|
|
objectState.MeshNode.set_transparency(TransparencyAttrib::M_alpha);
|
|
} else if (gameObject.GetComponent<MetaCoreMeshRendererComponent>().AlphaMode == MetaCoreMeshAlphaMode::Mask) {
|
|
objectState.MeshNode.set_transparency(TransparencyAttrib::M_binary);
|
|
} else {
|
|
objectState.MeshNode.clear_transparency();
|
|
}
|
|
|
|
if (gameObject.GetComponent<MetaCoreMeshRendererComponent>().Visible) {
|
|
objectState.MeshNode.show();
|
|
} else {
|
|
objectState.MeshNode.hide();
|
|
}
|
|
|
|
if (gameObject.GetId() == Impl_->SelectedObjectId) {
|
|
objectState.MeshNode.set_color_scale(1.18F, 1.02F, 0.72F, 1.0F);
|
|
} else {
|
|
objectState.MeshNode.clear_color_scale();
|
|
}
|
|
}
|
|
} else if (!objectState.MeshNode.is_empty()) {
|
|
objectState.MeshNode.remove_node();
|
|
objectState.MeshNode = NodePath();
|
|
objectState.MaterialAssetGuids.clear();
|
|
}
|
|
|
|
if (gameObject.HasComponent<MetaCoreLightComponent>()) {
|
|
syncStage = "light_component";
|
|
if (objectState.LightNode.is_empty()) {
|
|
PT(DirectionalLight) newLight = new DirectionalLight("MetaCoreDirectionalLight");
|
|
objectState.LightNode = objectState.RootNode.attach_new_node(newLight);
|
|
sceneRootHandle->set_light(objectState.LightNode);
|
|
}
|
|
|
|
auto* directionalLight = DCAST(DirectionalLight, objectState.LightNode.node());
|
|
if (directionalLight != nullptr) {
|
|
directionalLight->set_color(LColor(
|
|
gameObject.GetComponent<MetaCoreLightComponent>().Color.x * gameObject.GetComponent<MetaCoreLightComponent>().Intensity,
|
|
gameObject.GetComponent<MetaCoreLightComponent>().Color.y * gameObject.GetComponent<MetaCoreLightComponent>().Intensity,
|
|
gameObject.GetComponent<MetaCoreLightComponent>().Color.z * gameObject.GetComponent<MetaCoreLightComponent>().Intensity,
|
|
1.0F
|
|
));
|
|
}
|
|
} else if (!objectState.LightNode.is_empty()) {
|
|
sceneRootHandle->clear_light(objectState.LightNode);
|
|
objectState.LightNode.remove_node();
|
|
objectState.LightNode = NodePath();
|
|
}
|
|
} catch (const std::exception& exceptionObject) {
|
|
Impl_->RuntimeSyncFailure = true;
|
|
Impl_->LastRuntimeSyncFailure =
|
|
"metacore.render object " + std::to_string(gameObject.GetId()) + " (" + gameObject.GetName() + ") stage=" + syncStage + ": " + exceptionObject.what();
|
|
MetaCoreTrace(Impl_->LastRuntimeSyncFailure.c_str());
|
|
return;
|
|
} catch (...) {
|
|
Impl_->RuntimeSyncFailure = true;
|
|
Impl_->LastRuntimeSyncFailure =
|
|
"metacore.render object " + std::to_string(gameObject.GetId()) + " (" + gameObject.GetName() + ") stage=" + syncStage + ": non-std exception";
|
|
MetaCoreTrace(Impl_->LastRuntimeSyncFailure.c_str());
|
|
return;
|
|
}
|
|
}
|
|
|
|
for (auto iterator = Impl_->ObjectStates.begin(); iterator != Impl_->ObjectStates.end();) {
|
|
if (!aliveObjectIds.contains(iterator->first)) {
|
|
if (!iterator->second.MeshNode.is_empty()) {
|
|
iterator->second.MeshNode.remove_node();
|
|
}
|
|
if (!iterator->second.LightNode.is_empty()) {
|
|
iterator->second.LightNode.remove_node();
|
|
}
|
|
if (!iterator->second.RootNode.is_empty()) {
|
|
iterator->second.RootNode.remove_node();
|
|
}
|
|
iterator = Impl_->ObjectStates.erase(iterator);
|
|
} else {
|
|
++iterator;
|
|
}
|
|
}
|
|
}
|
|
|
|
void MetaCorePandaSceneBridge::ApplySceneView(const MetaCoreSceneView& sceneView) {
|
|
if (Impl_->RenderDevice == nullptr) {
|
|
return;
|
|
}
|
|
|
|
auto* editorCameraHandle = static_cast<NodePath*>(Impl_->RenderDevice->GetNativeEditorCameraHandle());
|
|
if (editorCameraHandle == nullptr || editorCameraHandle->is_empty()) {
|
|
return;
|
|
}
|
|
|
|
Impl_->SelectedObjectId = sceneView.SelectedObjectId;
|
|
|
|
editorCameraHandle->set_pos(MetaCoreToPandaPoint(sceneView.CameraPosition));
|
|
editorCameraHandle->look_at(MetaCoreToPandaPoint(sceneView.CameraTarget), MetaCoreToPandaVector(sceneView.CameraUp));
|
|
|
|
auto* cameraNode = DCAST(Camera, editorCameraHandle->node());
|
|
if (cameraNode != nullptr) {
|
|
auto* perspectiveLens = DCAST(PerspectiveLens, cameraNode->get_lens());
|
|
if (perspectiveLens != nullptr) {
|
|
const float aspect = std::max(0.001F, perspectiveLens->get_aspect_ratio());
|
|
const float vFovRad = glm::radians(sceneView.VerticalFieldOfViewDegrees);
|
|
const float hFovDeg = glm::degrees(2.0F * std::atan(aspect * std::tan(vFovRad * 0.5F)));
|
|
perspectiveLens->set_fov(LVecBase2f(std::max(0.001F, hFovDeg), std::max(0.001F, sceneView.VerticalFieldOfViewDegrees)));
|
|
}
|
|
}
|
|
}
|
|
|
|
bool MetaCorePandaSceneBridge::TryGetObjectWorldMatrix(MetaCoreId objectId, glm::mat4& worldMatrix) const {
|
|
if (Impl_ == nullptr || Impl_->RenderDevice == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
auto* sceneRootHandle = static_cast<NodePath*>(Impl_->RenderDevice->GetNativeSceneRootHandle());
|
|
if (sceneRootHandle == nullptr || sceneRootHandle->is_empty()) {
|
|
return false;
|
|
}
|
|
|
|
const auto objectIterator = Impl_->ObjectStates.find(objectId);
|
|
if (objectIterator == Impl_->ObjectStates.end()) {
|
|
return false;
|
|
}
|
|
|
|
const NodePath& targetNode =
|
|
!objectIterator->second.RootNode.is_empty()
|
|
? objectIterator->second.RootNode
|
|
: objectIterator->second.MeshNode;
|
|
if (targetNode.is_empty()) {
|
|
return false;
|
|
}
|
|
|
|
worldMatrix = MetaCoreConvertPandaMatrixToGlm(targetNode.get_mat(*sceneRootHandle));
|
|
return true;
|
|
}
|
|
|
|
bool MetaCorePandaSceneBridge::HasRuntimeSyncFailure() const {
|
|
return Impl_ != nullptr && Impl_->RuntimeSyncFailure;
|
|
}
|
|
|
|
const std::string& MetaCorePandaSceneBridge::GetLastRuntimeSyncFailure() const {
|
|
static const std::string empty;
|
|
if (Impl_ == nullptr) {
|
|
return empty;
|
|
}
|
|
return Impl_->LastRuntimeSyncFailure;
|
|
}
|
|
|
|
} // namespace MetaCore
|