988 lines
35 KiB
C++
988 lines
35 KiB
C++
#include "MetaCoreRender/MetaCorePandaSceneBridge.h"
|
|
|
|
#include "MetaCoreRender/MetaCoreRenderDevice.h"
|
|
#include "MetaCoreRender/MetaCoreRenderTypes.h"
|
|
#include "MetaCoreScene/MetaCoreComponents.h"
|
|
#include "MetaCoreScene/MetaCoreScene.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"
|
|
|
|
#define GLM_ENABLE_EXPERIMENTAL
|
|
#include <glm/ext/matrix_transform.hpp>
|
|
#include <glm/gtx/euler_angles.hpp>
|
|
#include <glm/mat4x4.hpp>
|
|
|
|
#include <chrono>
|
|
#include <cstdlib>
|
|
#include <cstdio>
|
|
#include <ctime>
|
|
#include <memory>
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
|
|
namespace MetaCore {
|
|
|
|
namespace {
|
|
|
|
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);
|
|
}
|
|
|
|
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) {
|
|
MetaCoreTrace("create_grid: begin");
|
|
try {
|
|
MetaCoreTrace("create_grid: create vertex data");
|
|
PT(GeomVertexData) vertexData = new GeomVertexData(
|
|
"MetaCoreGrid",
|
|
GeomVertexFormat::get_v3c4(),
|
|
Geom::UH_static
|
|
);
|
|
|
|
GeomVertexWriter vertexWriter(vertexData, "vertex");
|
|
GeomVertexWriter colorWriter(vertexData, "color");
|
|
|
|
MetaCoreTrace("create_grid: loop start");
|
|
constexpr int gridHalfExtent = 10;
|
|
int vertexCount = 0;
|
|
for (int lineIndex = -gridHalfExtent; lineIndex <= gridHalfExtent; ++lineIndex) {
|
|
const bool isAxisLine = (lineIndex == 0);
|
|
const LColor color(isAxisLine ? 0.42F : 0.30F, isAxisLine ? 0.45F : 0.33F, isAxisLine ? 0.50F : 0.36F, 1.0F);
|
|
|
|
// X-direction lines
|
|
vertexWriter.add_data3(MetaCoreToPandaPoint(glm::vec3(static_cast<float>(lineIndex), 0.0F, static_cast<float>(-gridHalfExtent))));
|
|
colorWriter.add_data4(color);
|
|
vertexWriter.add_data3(MetaCoreToPandaPoint(glm::vec3(static_cast<float>(lineIndex), 0.0F, static_cast<float>(gridHalfExtent))));
|
|
colorWriter.add_data4(color);
|
|
|
|
// Z-direction lines
|
|
vertexWriter.add_data3(MetaCoreToPandaPoint(glm::vec3(static_cast<float>(-gridHalfExtent), 0.0F, static_cast<float>(lineIndex))));
|
|
colorWriter.add_data4(color);
|
|
vertexWriter.add_data3(MetaCoreToPandaPoint(glm::vec3(static_cast<float>(gridHalfExtent), 0.0F, static_cast<float>(lineIndex))));
|
|
colorWriter.add_data4(color);
|
|
|
|
vertexCount += 4;
|
|
}
|
|
MetaCoreTrace("create_grid: loop end");
|
|
|
|
MetaCoreTrace("create_grid: create primitive");
|
|
PT(GeomLines) lines = new GeomLines(Geom::UH_static);
|
|
for (int i = 0; i < vertexCount; i += 2) {
|
|
lines->add_vertices(i, i + 1);
|
|
}
|
|
|
|
MetaCoreTrace("create_grid: create geom");
|
|
PT(Geom) geom = new Geom(vertexData);
|
|
geom->add_primitive(lines.p());
|
|
|
|
PT(GeomNode) geomNode = new GeomNode("MetaCoreGridNode");
|
|
geomNode->add_geom(geom);
|
|
|
|
return parentNode.attach_new_node(geomNode);
|
|
} catch (...) {
|
|
return NodePath();
|
|
}
|
|
}
|
|
|
|
|
|
NodePath MetaCoreCreateUnitCubeNode(const NodePath& parentNode) {
|
|
PT(GeomVertexData) vertexData = new GeomVertexData(
|
|
"MetaCoreUnitCube",
|
|
GeomVertexFormat::get_v3n3(),
|
|
Geom::UH_static
|
|
);
|
|
|
|
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);
|
|
}
|
|
};
|
|
|
|
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));
|
|
|
|
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);
|
|
}
|
|
|
|
PT(Geom) geom = new Geom(vertexData);
|
|
geom->add_primitive(triangles);
|
|
|
|
PT(GeomNode) geomNode = new GeomNode("MetaCoreUnitCubeNode");
|
|
geomNode->add_geom(geom);
|
|
return parentNode.attach_new_node(geomNode);
|
|
}
|
|
|
|
[[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]] NodePath MetaCoreTryLoadModelNode(
|
|
WindowFramework& windowFramework,
|
|
const NodePath& parentNode,
|
|
const std::filesystem::path& projectRoot,
|
|
const std::string& relativeSourcePath
|
|
) {
|
|
if (projectRoot.empty() || relativeSourcePath.empty()) {
|
|
return NodePath();
|
|
}
|
|
|
|
const std::filesystem::path absoluteSourcePath = projectRoot / std::filesystem::path(relativeSourcePath);
|
|
if (!std::filesystem::exists(absoluteSourcePath)) {
|
|
MetaCoreTrace(("load_model: source file missing: " + absoluteSourcePath.string()).c_str());
|
|
return NodePath();
|
|
}
|
|
|
|
const Filename pandaPath = Filename::from_os_specific(absoluteSourcePath.string());
|
|
NodePath loadedNode = windowFramework.load_model(parentNode, pandaPath);
|
|
if (loadedNode.is_empty()) {
|
|
MetaCoreTrace(("load_model: Panda3D failed to load: " + absoluteSourcePath.string()).c_str());
|
|
return NodePath();
|
|
}
|
|
MetaCoreTrace(("load_model: success: " + absoluteSourcePath.string()).c_str());
|
|
return loadedNode;
|
|
}
|
|
|
|
[[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) MetaCoreResolveBaseColorTexture(
|
|
const std::filesystem::path& projectRoot,
|
|
const std::string& relativeTexturePath
|
|
) {
|
|
if (projectRoot.empty() || relativeTexturePath.empty()) {
|
|
return MetaCoreGetDefaultBaseColorTexture();
|
|
}
|
|
|
|
const std::filesystem::path absoluteTexturePath = projectRoot / std::filesystem::path(relativeTexturePath);
|
|
if (!std::filesystem::exists(absoluteTexturePath)) {
|
|
return MetaCoreGetDefaultBaseColorTexture();
|
|
}
|
|
|
|
PT(Texture) texture = TexturePool::load_texture(Filename::from_os_specific(absoluteTexturePath.string()));
|
|
if (texture == nullptr) {
|
|
MetaCoreTrace(("load_texture: Panda3D failed to load: " + absoluteTexturePath.string()).c_str());
|
|
return MetaCoreGetDefaultBaseColorTexture();
|
|
}
|
|
|
|
return texture;
|
|
}
|
|
|
|
[[nodiscard]] PT(Texture) MetaCoreResolveTextureWithFallback(
|
|
const std::filesystem::path& projectRoot,
|
|
const std::string& relativeTexturePath,
|
|
const PT(Texture)& fallbackTexture
|
|
) {
|
|
if (projectRoot.empty() || relativeTexturePath.empty()) {
|
|
return fallbackTexture;
|
|
}
|
|
|
|
const std::filesystem::path absoluteTexturePath = projectRoot / std::filesystem::path(relativeTexturePath);
|
|
if (!std::filesystem::exists(absoluteTexturePath)) {
|
|
return fallbackTexture;
|
|
}
|
|
|
|
PT(Texture) texture = TexturePool::load_texture(Filename::from_os_specific(absoluteTexturePath.string()));
|
|
if (texture == nullptr) {
|
|
MetaCoreTrace(("load_texture: Panda3D failed to load: " + absoluteTexturePath.string()).c_str());
|
|
return fallbackTexture;
|
|
}
|
|
|
|
return texture;
|
|
}
|
|
|
|
void MetaCoreApplyBaseColorTexture(
|
|
NodePath& meshNode,
|
|
const std::filesystem::path& projectRoot,
|
|
const std::string& relativeTexturePath
|
|
) {
|
|
if (meshNode.is_empty()) {
|
|
return;
|
|
}
|
|
|
|
PT(Texture) texture = MetaCoreResolveBaseColorTexture(projectRoot, 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 std::string& relativeTexturePath
|
|
) {
|
|
if (meshNode.is_empty()) {
|
|
return;
|
|
}
|
|
|
|
PT(Texture) texture = MetaCoreResolveTextureWithFallback(
|
|
projectRoot,
|
|
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 std::string& relativeTexturePath
|
|
) {
|
|
if (meshNode.is_empty()) {
|
|
return;
|
|
}
|
|
|
|
PT(Texture) texture = MetaCoreResolveTextureWithFallback(
|
|
projectRoot,
|
|
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 std::string& relativeTexturePath
|
|
) {
|
|
if (meshNode.is_empty()) {
|
|
return;
|
|
}
|
|
|
|
PT(Texture) texture = MetaCoreResolveTextureWithFallback(
|
|
projectRoot,
|
|
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 std::string& relativeTexturePath
|
|
) {
|
|
if (meshNode.is_empty()) {
|
|
return;
|
|
}
|
|
|
|
PT(Texture) texture = MetaCoreResolveTextureWithFallback(
|
|
projectRoot,
|
|
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)
|
|
);
|
|
}
|
|
|
|
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{};
|
|
std::string SourceModelPath{};
|
|
};
|
|
|
|
MetaCoreRenderDevice* RenderDevice = nullptr;
|
|
NodePath GridNode{};
|
|
NodePath AmbientLightNode{};
|
|
std::filesystem::path ProjectRootPath{};
|
|
MetaCoreId SelectedObjectId = 0;
|
|
std::unordered_map<MetaCoreId, MetaCorePandaObjectState> ObjectStates{};
|
|
};
|
|
|
|
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);
|
|
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.RootNode.is_empty()) {
|
|
objectState.RootNode.remove_node();
|
|
}
|
|
}
|
|
Impl_->ObjectStates.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;
|
|
}
|
|
|
|
void MetaCorePandaSceneBridge::SyncScene(const MetaCoreScene& scene) {
|
|
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()) {
|
|
aliveObjectIds.insert(gameObject.Id);
|
|
auto [iterator, inserted] = Impl_->ObjectStates.try_emplace(gameObject.Id);
|
|
MetaCorePandaSceneBridgeImpl::MetaCorePandaObjectState& objectState = iterator->second;
|
|
|
|
if (inserted || objectState.RootNode.is_empty()) {
|
|
PT(PandaNode) rootNode = new PandaNode(gameObject.Name);
|
|
objectState.RootNode = sceneRootHandle->attach_new_node(rootNode);
|
|
}
|
|
|
|
objectState.RootNode.set_name(gameObject.Name);
|
|
MetaCoreApplyTransformToPandaNode(gameObject.Transform, objectState.RootNode);
|
|
|
|
if (gameObject.ParentId != 0) {
|
|
const auto parentIterator = Impl_->ObjectStates.find(gameObject.ParentId);
|
|
if (parentIterator != Impl_->ObjectStates.end() && !parentIterator->second.RootNode.is_empty()) {
|
|
objectState.RootNode.reparent_to(parentIterator->second.RootNode);
|
|
} else {
|
|
objectState.RootNode.reparent_to(*sceneRootHandle);
|
|
}
|
|
} else {
|
|
objectState.RootNode.reparent_to(*sceneRootHandle);
|
|
}
|
|
|
|
if (gameObject.MeshRenderer.has_value()) {
|
|
const bool requiresMeshRebuild =
|
|
objectState.MeshNode.is_empty() ||
|
|
objectState.MeshSource != gameObject.MeshRenderer->MeshSource ||
|
|
(gameObject.MeshRenderer->MeshSource == MetaCoreMeshSourceKind::Builtin &&
|
|
objectState.BuiltinMesh != gameObject.MeshRenderer->BuiltinMesh) ||
|
|
(gameObject.MeshRenderer->MeshSource == MetaCoreMeshSourceKind::Asset &&
|
|
(objectState.MeshAssetGuid != gameObject.MeshRenderer->MeshAssetGuid ||
|
|
objectState.SourceModelPath != gameObject.MeshRenderer->SourceModelPath));
|
|
|
|
if (requiresMeshRebuild && !objectState.MeshNode.is_empty()) {
|
|
objectState.MeshNode.remove_node();
|
|
objectState.MeshNode = NodePath();
|
|
}
|
|
|
|
if (requiresMeshRebuild) {
|
|
if (gameObject.MeshRenderer->MeshSource == MetaCoreMeshSourceKind::Builtin) {
|
|
objectState.MeshNode = MetaCoreCreateUnitCubeNode(objectState.RootNode);
|
|
} else {
|
|
objectState.MeshNode = MetaCoreTryLoadModelNode(
|
|
*windowFrameworkHandle,
|
|
objectState.RootNode,
|
|
Impl_->ProjectRootPath,
|
|
gameObject.MeshRenderer->SourceModelPath
|
|
);
|
|
if (objectState.MeshNode.is_empty()) {
|
|
objectState.MeshNode = MetaCoreCreateUnitCubeNode(objectState.RootNode);
|
|
}
|
|
}
|
|
objectState.MeshSource = gameObject.MeshRenderer->MeshSource;
|
|
objectState.BuiltinMesh = gameObject.MeshRenderer->BuiltinMesh;
|
|
objectState.MeshAssetGuid = gameObject.MeshRenderer->MeshAssetGuid;
|
|
objectState.SourceModelPath = gameObject.MeshRenderer->SourceModelPath;
|
|
}
|
|
|
|
if (!objectState.MeshNode.is_empty()) {
|
|
objectState.MeshNode.set_material_off(1);
|
|
objectState.MeshNode.set_light_off(1);
|
|
objectState.MeshNode.set_two_sided(gameObject.MeshRenderer->DoubleSided);
|
|
objectState.MeshNode.set_color(
|
|
gameObject.MeshRenderer->BaseColor.r,
|
|
gameObject.MeshRenderer->BaseColor.g,
|
|
gameObject.MeshRenderer->BaseColor.b,
|
|
1.0F
|
|
);
|
|
MetaCoreApplyBaseColorTexture(
|
|
objectState.MeshNode,
|
|
Impl_->ProjectRootPath,
|
|
gameObject.MeshRenderer->BaseColorTexturePath
|
|
);
|
|
MetaCoreApplyMetallicRoughnessTexture(
|
|
objectState.MeshNode,
|
|
Impl_->ProjectRootPath,
|
|
gameObject.MeshRenderer->MetallicRoughnessTexturePath
|
|
);
|
|
MetaCoreApplyNormalTexture(
|
|
objectState.MeshNode,
|
|
Impl_->ProjectRootPath,
|
|
gameObject.MeshRenderer->NormalTexturePath
|
|
);
|
|
MetaCoreApplyEmissionTexture(
|
|
objectState.MeshNode,
|
|
Impl_->ProjectRootPath,
|
|
gameObject.MeshRenderer->EmissiveTexturePath
|
|
);
|
|
MetaCoreApplyAoTexture(
|
|
objectState.MeshNode,
|
|
Impl_->ProjectRootPath,
|
|
gameObject.MeshRenderer->AoTexturePath
|
|
);
|
|
if (gameObject.MeshRenderer->MeshSource == MetaCoreMeshSourceKind::Asset) {
|
|
MetaCoreApplySimplePbrPreview(objectState.MeshNode);
|
|
MetaCoreApplySimplePbrMaterialInputs(objectState.MeshNode, *gameObject.MeshRenderer);
|
|
auto* editorCameraHandle = static_cast<NodePath*>(Impl_->RenderDevice->GetNativeEditorCameraHandle());
|
|
if (editorCameraHandle != nullptr) {
|
|
MetaCoreApplySimplePbrViewInputs(objectState.MeshNode, *sceneRootHandle, *editorCameraHandle);
|
|
}
|
|
} else {
|
|
objectState.MeshNode.set_shader_off(1);
|
|
}
|
|
|
|
if (gameObject.MeshRenderer->AlphaMode == MetaCoreMeshAlphaMode::Blend) {
|
|
objectState.MeshNode.set_transparency(TransparencyAttrib::M_alpha);
|
|
} else if (gameObject.MeshRenderer->AlphaMode == MetaCoreMeshAlphaMode::Mask) {
|
|
objectState.MeshNode.set_transparency(TransparencyAttrib::M_binary);
|
|
} else {
|
|
objectState.MeshNode.clear_transparency();
|
|
}
|
|
|
|
if (gameObject.MeshRenderer->Visible) {
|
|
objectState.MeshNode.show();
|
|
} else {
|
|
objectState.MeshNode.hide();
|
|
}
|
|
|
|
if (gameObject.Id == 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();
|
|
}
|
|
|
|
if (gameObject.Light.has_value()) {
|
|
if (objectState.LightNode.is_empty()) {
|
|
PT(DirectionalLight) directionalLight = new DirectionalLight(gameObject.Name);
|
|
objectState.LightNode = objectState.RootNode.attach_new_node(directionalLight);
|
|
sceneRootHandle->set_light(objectState.LightNode);
|
|
}
|
|
|
|
auto* directionalLight = DCAST(DirectionalLight, objectState.LightNode.node());
|
|
if (directionalLight != nullptr) {
|
|
directionalLight->set_color(LColor(
|
|
gameObject.Light->Color.r * gameObject.Light->Intensity,
|
|
gameObject.Light->Color.g * gameObject.Light->Intensity,
|
|
gameObject.Light->Color.b * gameObject.Light->Intensity,
|
|
1.0F
|
|
));
|
|
}
|
|
} else if (!objectState.LightNode.is_empty()) {
|
|
sceneRootHandle->clear_light(objectState.LightNode);
|
|
objectState.LightNode.remove_node();
|
|
objectState.LightNode = NodePath();
|
|
}
|
|
}
|
|
|
|
for (auto iterator = Impl_->ObjectStates.begin(); iterator != Impl_->ObjectStates.end();) {
|
|
if (!aliveObjectIds.contains(iterator->first)) {
|
|
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() || objectIterator->second.RootNode.is_empty()) {
|
|
return false;
|
|
}
|
|
|
|
worldMatrix = MetaCoreConvertPandaMatrixToGlm(objectIterator->second.RootNode.get_mat(*sceneRootHandle));
|
|
return true;
|
|
}
|
|
|
|
} // namespace MetaCore
|