maobo/cup_edit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

temporarily disable UnprojectTexture

Browse Source
This commit is contained in:
Nick Fisher
2024-11-02 10:17:18 +08:00
parent 902f67e97d
commit 124938dbc2
7 changed files with 396 additions and 350 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
thermion_dart/native/include/CustomGeometry.hpp
View File

@@ -3,13 +3,16 @@
#include <stddef.h> #include <stddef.h>
#include <filament/Engine.h> #include <filament/Engine.h>
#include <filament/Frustum.h>
#include <filament/VertexBuffer.h> #include <filament/VertexBuffer.h>
#include <filament/IndexBuffer.h> #include <filament/IndexBuffer.h>
#include <filament/TransformManager.h> #include <filament/TransformManager.h>
#include <filament/Texture.h> #include <filament/Texture.h>
#include <filament/RenderableManager.h> #include <filament/RenderableManager.h>
#include <filament/Viewport.h> #include <filament/Viewport.h>
#include <filament/Frustum.h>
#include <utils/Entity.h>
#include <utils/EntityManager.h>
namespace thermion namespace thermion
{ {
@@ -32,9 +35,13 @@ public:
Engine* engine); Engine* engine);
~CustomGeometry(); ~CustomGeometry();
VertexBuffer* vertexBuffer() const; utils::Entity createInstance(MaterialInstance *materialInstance);
IndexBuffer* indexBuffer() const;
Box getBoundingBox() const; private:
Engine* _engine;
VertexBuffer* vertexBuffer;
IndexBuffer* indexBuffer;
float* vertices = nullptr; float* vertices = nullptr;
float* normals = nullptr; float* normals = nullptr;
@@ -45,11 +52,6 @@ public:
Box boundingBox; Box boundingBox;
RenderableManager::PrimitiveType primitiveType; RenderableManager::PrimitiveType primitiveType;
private:
Engine* _engine;
bool _vertexBufferFreed = false;
bool _indexBufferFreed = false;
void computeBoundingBox(); void computeBoundingBox();
}; };

14
thermion_dart/native/include/SceneManager.hpp
View File

@@ -230,7 +230,12 @@ namespace thermion
/// @param out a pointer large enough to store four floats (the min/max coordinates of the bounding box) /// @param out a pointer large enough to store four floats (the min/max coordinates of the bounding box)
/// @return /// @return
/// ///
Aabb2 getBoundingBox(View* view, EntityId entity); Aabb2 getScreenSpaceBoundingBox(View* view, EntityId entity);
/// @brief returns the 3D bounding box of the renderable instance for the given entity.
/// @return the bounding box
///
Aabb3 getRenderableBoundingBox(EntityId entity);
/// ///
/// Creates an entity with the specified geometry/material/normals and adds to the scene. /// Creates an entity with the specified geometry/material/normals and adds to the scene.
@@ -256,11 +261,15 @@ namespace thermion
return _unlitMaterialProvider; return _unlitMaterialProvider;
} }
bool isGeometryInstance(EntityId entity) {
return std::find(_geometryInstances.begin(), _geometryInstances.end(), entity) != _geometryInstances.end();
}
bool isGeometryEntity(EntityId entity) { bool isGeometryEntity(EntityId entity) {
return _geometry.find(entity) != _geometry.end(); return _geometry.find(entity) != _geometry.end();
} }
const CustomGeometry* const getGeometry(EntityId entityId) { CustomGeometry* const getGeometry(EntityId entityId) {
return _geometry[entityId].get(); return _geometry[entityId].get();
} }
@@ -336,6 +345,7 @@ namespace thermion
_instances; _instances;
tsl::robin_map<EntityId, gltfio::FilamentAsset *> _assets; tsl::robin_map<EntityId, gltfio::FilamentAsset *> _assets;
tsl::robin_map<EntityId, unique_ptr<CustomGeometry>> _geometry; tsl::robin_map<EntityId, unique_ptr<CustomGeometry>> _geometry;
std::vector<EntityId> _geometryInstances;
tsl::robin_map<EntityId, unique_ptr<HighlightOverlay>> _highlighted; tsl::robin_map<EntityId, unique_ptr<HighlightOverlay>> _highlighted;
tsl::robin_map<EntityId, math::mat4> _transformUpdates; tsl::robin_map<EntityId, math::mat4> _transformUpdates;
std::set<Texture*> _textures; std::set<Texture*> _textures;

388
thermion_dart/native/src/CustomGeometry.cpp
View File

@@ -1,4 +1,7 @@
#include "math.h" #include "math.h"
#include <vector>
#include <filament/Engine.h> #include <filament/Engine.h>
#include <filament/Frustum.h> #include <filament/Frustum.h>
#include <filament/RenderableManager.h> #include <filament/RenderableManager.h>
@@ -6,207 +9,232 @@
#include <filament/TransformManager.h> #include <filament/TransformManager.h>
#include <filament/Viewport.h> #include <filament/Viewport.h>
#include <filament/geometry/SurfaceOrientation.h> #include <filament/geometry/SurfaceOrientation.h>
#include <vector>
#include "CustomGeometry.hpp" #include "CustomGeometry.hpp"
#include "Log.hpp" #include "Log.hpp"
namespace thermion
{
namespace thermion { using namespace filament;
using namespace filament; CustomGeometry::CustomGeometry(float *vertices, uint32_t numVertices,
float *normals, uint32_t numNormals, float *uvs,
uint32_t numUvs, uint16_t *indices,
uint32_t numIndices,
RenderableManager::PrimitiveType primitiveType,
Engine *engine)
: numVertices(numVertices), numIndices(numIndices), _engine(engine)
{
CustomGeometry::CustomGeometry(float *vertices, uint32_t numVertices, this->primitiveType = primitiveType;
float *normals, uint32_t numNormals, float *uvs, this->vertices = new float[numVertices];
uint32_t numUvs, uint16_t *indices,
uint32_t numIndices,
RenderableManager::PrimitiveType primitiveType,
Engine *engine)
: numVertices(numVertices), numIndices(numIndices), _engine(engine) {
this->primitiveType = primitiveType;
this->vertices = new float[numVertices];
std::memcpy(this->vertices, vertices, numVertices * sizeof(float));
if (numNormals > 0) { std::memcpy(this->vertices, vertices, numVertices * sizeof(float));
this->normals = new float[numNormals];
std::memcpy(this->normals, normals, numNormals * sizeof(float));
}
if (numUvs > 0) { if (numNormals > 0)
this->uvs = new float[numUvs]; {
std::memcpy(this->uvs, uvs, numUvs * sizeof(float)); this->normals = new float[numNormals];
} else { std::memcpy(this->normals, normals, numNormals * sizeof(float));
this->uvs = nullptr;
}
this->indices = new uint16_t[numIndices];
std::memcpy(this->indices, indices, numIndices * sizeof(uint16_t));
computeBoundingBox();
}
IndexBuffer *CustomGeometry::indexBuffer() const {
IndexBuffer::BufferDescriptor::Callback indexCallback = [](void *buf, size_t,
void *data) {
// free((void *)buf);
};
auto indexBuffer = IndexBuffer::Builder()
.indexCount(numIndices)
.bufferType(IndexBuffer::IndexType::USHORT)
.build(*_engine);
indexBuffer->setBuffer(*_engine,
IndexBuffer::BufferDescriptor(
this->indices,
indexBuffer->getIndexCount() * sizeof(uint16_t),
indexCallback));
return indexBuffer;
}
VertexBuffer *CustomGeometry::vertexBuffer() const {
VertexBuffer::BufferDescriptor::Callback vertexCallback =
[](void *buf, size_t, void *data) {
// free((void *)buf);
};
// Use provided UVs or create dummy UV data
std::vector<filament::math::float2> *uvData;
if (this->uvs != nullptr) {
uvData = new std::vector<filament::math::float2>(
(filament::math::float2 *)this->uvs,
(filament::math::float2 *)(this->uvs + numVertices * 2));
} else {
uvData = new std::vector<filament::math::float2>(
numVertices, filament::math::float2{0.0f, 0.0f});
}
// Create dummy vertex color data (white color for all vertices)
auto dummyColors = new std::vector<filament::math::float4>(
numVertices, filament::math::float4{1.0f, 1.0f, 1.0f, 1.0f});
auto vertexBufferBuilder =
VertexBuffer::Builder()
.vertexCount(numVertices)
.attribute(VertexAttribute::POSITION, 0,
VertexBuffer::AttributeType::FLOAT3)
.attribute(VertexAttribute::UV0, 1,
VertexBuffer::AttributeType::FLOAT2)
.attribute(VertexAttribute::UV1, 2,
VertexBuffer::AttributeType::FLOAT2)
.attribute(VertexAttribute::COLOR, 3,
VertexBuffer::AttributeType::FLOAT4);
if (this->normals) {
vertexBufferBuilder.bufferCount(5).attribute(
VertexAttribute::TANGENTS, 4,
filament::VertexBuffer::AttributeType::FLOAT4);
} else {
vertexBufferBuilder = vertexBufferBuilder.bufferCount(4);
}
auto vertexBuffer = vertexBufferBuilder.build(*_engine);
vertexBuffer->setBufferAt(
*_engine, 0,
VertexBuffer::BufferDescriptor(
this->vertices, vertexBuffer->getVertexCount() * sizeof(math::float3),
vertexCallback));
// Set UV0 buffer
vertexBuffer->setBufferAt(
*_engine, 1,
VertexBuffer::BufferDescriptor(
uvData->data(), uvData->size() * sizeof(math::float2),
[](void *buf, size_t, void *data) {
delete static_cast<std::vector<math::float2> *>(data);
},
uvData));
// Set UV1 buffer (reusing UV0 data)
vertexBuffer->setBufferAt(*_engine, 2,
VertexBuffer::BufferDescriptor(
uvData->data(),
uvData->size() * sizeof(math::float2),
[](void *buf, size_t, void *data) {
// Do nothing here, as we're reusing the same
// data as UV0
},
nullptr));
// Set vertex color buffer
vertexBuffer->setBufferAt(
*_engine, 3,
VertexBuffer::BufferDescriptor(
dummyColors->data(), dummyColors->size() * sizeof(math::float4),
[](void *buf, size_t, void *data) {
delete static_cast<std::vector<math::float4> *>(data);
},
dummyColors));
if (this->normals) {
assert(this->primitiveType == RenderableManager::PrimitiveType::TRIANGLES);
std::vector<filament::math::ushort3> triangles;
for (int i = 0; i < numIndices; i += 3) {
filament::math::ushort3 triangle;
triangle.x = this->indices[i];
triangle.y = this->indices[i + 1];
triangle.z = this->indices[i + 2];
triangles.push_back(triangle);
} }
// Create a SurfaceOrientation builder if (numUvs > 0)
geometry::SurfaceOrientation::Builder builder; {
builder.vertexCount(numVertices) this->uvs = new float[numUvs];
.normals((filament::math::float3 *)normals) std::memcpy(this->uvs, uvs, numUvs * sizeof(float));
.positions((filament::math::float3 *)this->vertices) }
.triangleCount(triangles.size()) else
.triangles(triangles.data()); {
this->uvs = nullptr;
}
// Build the SurfaceOrientation object this->indices = new uint16_t[numIndices];
auto orientation = builder.build();
// Retrieve the quaternions std::memcpy(this->indices, indices, numIndices * sizeof(uint16_t));
auto quats = new std::vector<filament::math::quatf>(numVertices);
orientation->getQuats(quats->data(), numVertices);
vertexBuffer->setBufferAt(*_engine, 4, computeBoundingBox();
indexBuffer = IndexBuffer::Builder()
.indexCount(numIndices)
.bufferType(IndexBuffer::IndexType::USHORT)
.build(*_engine);
indexBuffer->setBuffer(*_engine,
IndexBuffer::BufferDescriptor(
this->indices,
indexBuffer->getIndexCount() * sizeof(uint16_t),
[](void *buf, size_t,
void *data)
{
free((void *)buf);
}));
std::vector<filament::math::float2> *uvData;
if (this->uvs != nullptr)
{
uvData = new std::vector<filament::math::float2>(
(filament::math::float2 *)this->uvs,
(filament::math::float2 *)(this->uvs + numVertices * 2));
}
else
{
uvData = new std::vector<filament::math::float2>(
numVertices, filament::math::float2{0.0f, 0.0f});
}
// Create dummy vertex color data (white color for all vertices)
auto dummyColors = new std::vector<filament::math::float4>(
numVertices, filament::math::float4{1.0f, 1.0f, 1.0f, 1.0f});
auto vertexBufferBuilder =
VertexBuffer::Builder()
.vertexCount(numVertices)
.attribute(VertexAttribute::POSITION, 0,
VertexBuffer::AttributeType::FLOAT3)
.attribute(VertexAttribute::UV0, 1,
VertexBuffer::AttributeType::FLOAT2)
.attribute(VertexAttribute::UV1, 2,
VertexBuffer::AttributeType::FLOAT2)
.attribute(VertexAttribute::COLOR, 3,
VertexBuffer::AttributeType::FLOAT4);
if (this->normals)
{
vertexBufferBuilder.bufferCount(5).attribute(
VertexAttribute::TANGENTS, 4,
filament::VertexBuffer::AttributeType::FLOAT4);
}
else
{
vertexBufferBuilder = vertexBufferBuilder.bufferCount(4);
}
vertexBuffer = vertexBufferBuilder.build(*_engine);
vertexBuffer->setBufferAt(
*_engine, 0,
VertexBuffer::BufferDescriptor(
this->vertices, numVertices * sizeof(math::float3),
[](void *buf, size_t, void *data)
{
free((void *)buf);
}));
// Set UV0 buffer
vertexBuffer->setBufferAt(
*_engine, 1,
VertexBuffer::BufferDescriptor(
uvData->data(), uvData->size() * sizeof(math::float2),
[](void *buf, size_t, void *data)
{
delete static_cast<std::vector<math::float2> *>(data);
},
uvData));
// Set UV1 buffer (reusing UV0 data)
vertexBuffer->setBufferAt(*_engine, 2,
VertexBuffer::BufferDescriptor( VertexBuffer::BufferDescriptor(
quats->data(), uvData->data(),
quats->size() * sizeof(math::quatf), uvData->size() * sizeof(math::float2),
[](void *buf, size_t, void *data) { [](void *buf, size_t, void *data)
delete (std::vector<math::quatf> *)data; {
// Do nothing here, as we're reusing the same
// data as UV0
}, },
(void *)quats)); nullptr));
}
return vertexBuffer;
}
CustomGeometry::~CustomGeometry() { // Set vertex color buffer
delete[] vertices; vertexBuffer->setBufferAt(
delete[] indices; *_engine, 3,
if (normals) VertexBuffer::BufferDescriptor(
delete[] normals; dummyColors->data(), dummyColors->size() * sizeof(math::float4),
if (uvs) [](void *buf, size_t, void *data)
delete[] uvs; {
} delete static_cast<std::vector<math::float4> *>(data);
},
dummyColors));
void CustomGeometry::computeBoundingBox() { if (this->normals)
float minX = FLT_MAX, minY = FLT_MAX, minZ = FLT_MAX; {
float maxX = -FLT_MAX, maxY = -FLT_MAX, maxZ = -FLT_MAX;
for (uint32_t i = 0; i < numVertices; i += 3) { assert(this->primitiveType == RenderableManager::PrimitiveType::TRIANGLES);
minX = std::min(vertices[i], minX); std::vector<filament::math::ushort3> triangles;
minY = std::min(vertices[i + 1], minY); for (int i = 0; i < numIndices; i += 3)
minZ = std::min(vertices[i + 2], minZ); {
maxX = std::max(vertices[i], maxX); filament::math::ushort3 triangle;
maxY = std::max(vertices[i + 1], maxY); triangle.x = this->indices[i];
maxZ = std::max(vertices[i + 2], maxZ); triangle.y = this->indices[i + 1];
triangle.z = this->indices[i + 2];
triangles.push_back(triangle);
}
// Create a SurfaceOrientation builder
geometry::SurfaceOrientation::Builder builder;
builder.vertexCount(numVertices)
.normals((filament::math::float3 *)normals)
.positions((filament::math::float3 *)this->vertices)
.triangleCount(triangles.size())
.triangles(triangles.data());
// Build the SurfaceOrientation object
auto orientation = builder.build();
// Retrieve the quaternions
auto quats = new std::vector<filament::math::quatf>(numVertices);
orientation->getQuats(quats->data(), numVertices);
vertexBuffer->setBufferAt(*_engine, 4,
VertexBuffer::BufferDescriptor(
quats->data(),
quats->size() * sizeof(math::quatf),
[](void *buf, size_t, void *data)
{
delete (std::vector<math::quatf> *)data;
},
(void *)quats));
}
} }
boundingBox = Box{{minX, minY, minZ}, {maxX, maxY, maxZ}}; utils::Entity CustomGeometry::createInstance(MaterialInstance *materialInstance) {
} auto entity = utils::EntityManager::get().create();
RenderableManager::Builder builder(1);
Box CustomGeometry::getBoundingBox() const { return boundingBox; } builder.boundingBox(boundingBox)
.geometry(0, primitiveType, vertexBuffer, indexBuffer, 0, numIndices)
.culling(true)
.receiveShadows(true)
.castShadows(true);
builder.material(0, materialInstance);
builder.build(*_engine, entity);
return entity;
}
CustomGeometry::~CustomGeometry()
{
Log("GEOMETRY DESTRUCTOR");
_engine->destroy(vertexBuffer);
_engine->destroy(indexBuffer);
}
void CustomGeometry::computeBoundingBox()
{
float minX = FLT_MAX, minY = FLT_MAX, minZ = FLT_MAX;
float maxX = -FLT_MAX, maxY = -FLT_MAX, maxZ = -FLT_MAX;
for (uint32_t i = 0; i < numVertices; i += 3)
{
minX = std::min(vertices[i], minX);
minY = std::min(vertices[i + 1], minY);
minZ = std::min(vertices[i + 2], minZ);
maxX = std::max(vertices[i], maxX);
maxY = std::max(vertices[i + 1], maxY);
maxZ = std::max(vertices[i + 2], maxZ);
}
boundingBox = Box{{minX, minY, minZ}, {maxX, maxY, maxZ}};
}
} // namespace thermion } // namespace thermion

10
thermion_dart/native/src/FilamentViewer.cpp
View File

@@ -1206,11 +1206,11 @@ namespace thermion
void FilamentViewer::unprojectTexture(EntityId entityId, uint8_t *input, uint32_t inputWidth, uint32_t inputHeight, uint8_t *out, uint32_t outWidth, uint32_t outHeight) void FilamentViewer::unprojectTexture(EntityId entityId, uint8_t *input, uint32_t inputWidth, uint32_t inputHeight, uint8_t *out, uint32_t outWidth, uint32_t outHeight)
{ {
const auto *geometry = _sceneManager->getGeometry(entityId); const auto *geometry = _sceneManager->getGeometry(entityId);
if (!geometry->uvs) // if (!geometry->uvs)
{ // {
Log("No UVS"); // Log("No UVS");
return; // return;
} // }
// UnprojectTexture unproject(geometry, _view->getCamera(), _engine); // UnprojectTexture unproject(geometry, _view->getCamera(), _engine);

14
thermion_dart/native/src/HighlightOverlay.cpp
View File

@@ -55,8 +55,6 @@ namespace thermion
if (_isGeometryEntity) if (_isGeometryEntity)
{ {
Log("Entity %d is geometry", entityId);
auto geometryEntity = Entity::import(entityId); auto geometryEntity = Entity::import(entityId);
auto renderable = rm.getInstance(geometryEntity); auto renderable = rm.getInstance(geometryEntity);
@@ -74,17 +72,7 @@ namespace thermion
auto geometry = sceneManager->getGeometry(entityId); auto geometry = sceneManager->getGeometry(entityId);
_entity = utils::EntityManager::get().create(); _entity = geometry->createInstance(materialInstance);
RenderableManager::Builder builder(1);
builder.boundingBox(geometry->getBoundingBox())
.geometry(0, geometry->primitiveType, geometry->vertexBuffer(), geometry->indexBuffer(), 0, geometry->numIndices)
.culling(true)
.material(0, _highlightMaterialInstance)
.priority(0)
.receiveShadows(false)
.castShadows(false);
builder.build(*engine, _entity);
scene->addEntity(_entity); scene->addEntity(_entity);
auto outlineTransformInstance = tm.getInstance(_entity); auto outlineTransformInstance = tm.getInstance(_entity);

60
thermion_dart/native/src/SceneManager.cpp
View File

@@ -412,6 +412,15 @@ namespace thermion
{ {
std::lock_guard lock(_mutex); std::lock_guard lock(_mutex);
if(isGeometryEntity(entityId)) {
auto geometry = getGeometry(entityId);
auto materialInstance = createUnlitMaterialInstance();
auto instanceEntity = geometry->createInstance(materialInstance);
_scene->addEntity(instanceEntity);
return Entity::smuggle(instanceEntity);
}
const auto &pos = _assets.find(entityId); const auto &pos = _assets.find(entityId);
if (pos == _assets.end()) if (pos == _assets.end())
{ {
@@ -696,9 +705,19 @@ namespace thermion
if (isGeometryEntity(entityId)) if (isGeometryEntity(entityId))
{ {
return;
} else if(isGeometryInstance(entityId)) {
// destroy renderable
auto & rm = _engine->getRenderableManager();
auto & em = _engine->getEntityManager();
auto instanceEntity = utils::Entity::import(entityId);
auto it = std::find(_geometryInstances.begin(), _geometryInstances.end(), entityId);
_geometryInstances.erase(it);
rm.destroy(instanceEntity);
em.destroy(instanceEntity);
_engine->destroy(instanceEntity);
return; return;
} }
const auto *instance = getInstanceByEntityId(entityId); const auto *instance = getInstanceByEntityId(entityId);
if (instance) if (instance)
@@ -2203,7 +2222,17 @@ namespace thermion
rm.setPriority(renderableInstance, priority); rm.setPriority(renderableInstance, priority);
} }
Aabb2 SceneManager::getBoundingBox(View *view, EntityId entityId) Aabb3 SceneManager::getRenderableBoundingBox(EntityId entityId) {
auto& rm = _engine->getRenderableManager();
auto instance = rm.getInstance(Entity::import(entityId));
if(!instance.isValid()) {
return Aabb3 {};
}
auto box = rm.getAxisAlignedBoundingBox(instance);
return Aabb3 { box.center.x, box.center.y, box.center.z, box.halfExtent.x, box.halfExtent.y, box.halfExtent.z };
}
Aabb2 SceneManager::getScreenSpaceBoundingBox(View *view, EntityId entityId)
{ {
const auto &camera = view->getCamera(); const auto &camera = view->getCamera();
const auto &viewport = view->getViewport(); const auto &viewport = view->getViewport();
@@ -2316,16 +2345,7 @@ namespace thermion
bool keepData) bool keepData)
{ {
auto geometry = std::make_unique<CustomGeometry>(vertices, numVertices, normals, numNormals, uvs, numUvs, indices, numIndices, primitiveType, _engine); auto geometry = std::make_unique<CustomGeometry>(vertices, numVertices, normals, numNormals, uvs, numUvs, indices, numIndices, primitiveType, _engine);
auto entity = utils::EntityManager::get().create();
RenderableManager::Builder builder(1);
builder.boundingBox(geometry->getBoundingBox())
.geometry(0, primitiveType, geometry->vertexBuffer(), geometry->indexBuffer(), 0, numIndices)
.culling(true)
.receiveShadows(true)
.castShadows(true);
filament::Material *mat = nullptr; filament::Material *mat = nullptr;
if (!materialInstance) if (!materialInstance)
@@ -2399,16 +2419,14 @@ namespace thermion
} }
} }
builder.material(0, materialInstance); auto instanceEntity = geometry->createInstance(materialInstance);
builder.build(*_engine, entity); auto instanceEntityId = Entity::smuggle(instanceEntity);
_scene->addEntity(instanceEntity);
_geometryInstances.push_back(instanceEntityId);
_scene->addEntity(entity); _geometry.emplace(instanceEntityId, std::move(geometry));
auto entityId = Entity::smuggle(entity); return instanceEntityId;
_geometry.emplace(entityId, std::move(geometry));
return entityId;
} }
MaterialInstance *SceneManager::getMaterialInstanceAt(EntityId entityId, int materialIndex) MaterialInstance *SceneManager::getMaterialInstanceAt(EntityId entityId, int materialIndex)

240
thermion_dart/native/src/UnprojectTexture.cpp
View File

@@ -57,154 +57,154 @@ namespace thermion
uint32_t outputWidth, uint32_t outputHeight) uint32_t outputWidth, uint32_t outputHeight)
{ {
auto &rm = _engine->getRenderableManager(); // auto &rm = _engine->getRenderableManager();
auto &tm = _engine->getTransformManager(); // auto &tm = _engine->getTransformManager();
math::mat4 invViewProj = Camera::inverseProjection(_camera.getProjectionMatrix()) * _camera.getModelMatrix(); // math::mat4 invViewProj = Camera::inverseProjection(_camera.getProjectionMatrix()) * _camera.getModelMatrix();
auto ti = tm.getInstance(entity); // auto ti = tm.getInstance(entity);
math::mat4f worldTransform = tm.getWorldTransform(ti); // math::mat4f worldTransform = tm.getWorldTransform(ti);
auto inverseWorldTransform = inverse(worldTransform); // auto inverseWorldTransform = inverse(worldTransform);
const float *vertices = _geometry->vertices; // const float *vertices = _geometry->vertices;
const float *uvs = _geometry->uvs; // const float *uvs = _geometry->uvs;
const uint16_t *indices = _geometry->indices; // const uint16_t *indices = _geometry->indices;
uint32_t numIndices = _geometry->numIndices; // uint32_t numIndices = _geometry->numIndices;
// Create a depth buffer // // Create a depth buffer
std::vector<float> depthBuffer(inputWidth * inputHeight, std::numeric_limits<float>::infinity()); // std::vector<float> depthBuffer(inputWidth * inputHeight, std::numeric_limits<float>::infinity());
// Create a buffer to store the triangle index for each pixel // // Create a buffer to store the triangle index for each pixel
std::vector<int> triangleIndexBuffer(inputWidth * inputHeight, -1); // std::vector<int> triangleIndexBuffer(inputWidth * inputHeight, -1);
auto max = 0.0f; // auto max = 0.0f;
auto min = 99.0f; // auto min = 99.0f;
// Depth pre-pass // // Depth pre-pass
for (size_t i = 0; i < numIndices; i += 3) // for (size_t i = 0; i < numIndices; i += 3)
{ // {
math::float3 v0(vertices[indices[i] * 3], vertices[indices[i] * 3 + 1], vertices[indices[i] * 3 + 2]); // math::float3 v0(vertices[indices[i] * 3], vertices[indices[i] * 3 + 1], vertices[indices[i] * 3 + 2]);
math::float3 v1(vertices[indices[i + 1] * 3], vertices[indices[i + 1] * 3 + 1], vertices[indices[i + 1] * 3 + 2]); // math::float3 v1(vertices[indices[i + 1] * 3], vertices[indices[i + 1] * 3 + 1], vertices[indices[i + 1] * 3 + 2]);
math::float3 v2(vertices[indices[i + 2] * 3], vertices[indices[i + 2] * 3 + 1], vertices[indices[i + 2] * 3 + 2]); // math::float3 v2(vertices[indices[i + 2] * 3], vertices[indices[i + 2] * 3 + 1], vertices[indices[i + 2] * 3 + 2]);
math::float2 uv0(uvs[(indices[i] * 2)], uvs[(indices[i] * 2) + 1]); // math::float2 uv0(uvs[(indices[i] * 2)], uvs[(indices[i] * 2) + 1]);
math::float2 uv1(uvs[(indices[i + 1] * 2)], uvs[(indices[i + 1] * 2) + 1]); // math::float2 uv1(uvs[(indices[i + 1] * 2)], uvs[(indices[i + 1] * 2) + 1]);
math::float2 uv2(uvs[(indices[i + 2] * 2)], uvs[(indices[i + 2] * 2) + 1]); // math::float2 uv2(uvs[(indices[i + 2] * 2)], uvs[(indices[i + 2] * 2) + 1]);
// Transform vertices to world space // // Transform vertices to world space
v0 = (worldTransform * math::float4(v0, 1.0f)).xyz; // v0 = (worldTransform * math::float4(v0, 1.0f)).xyz;
v1 = (worldTransform * math::float4(v1, 1.0f)).xyz; // v1 = (worldTransform * math::float4(v1, 1.0f)).xyz;
v2 = (worldTransform * math::float4(v2, 1.0f)).xyz; // v2 = (worldTransform * math::float4(v2, 1.0f)).xyz;
// Project vertices to screen space // // Project vertices to screen space
math::float4 clipPos0 = _camera.getProjectionMatrix() * _camera.getViewMatrix() * math::float4(v0, 1.0f); // math::float4 clipPos0 = _camera.getProjectionMatrix() * _camera.getViewMatrix() * math::float4(v0, 1.0f);
math::float4 clipPos1 = _camera.getProjectionMatrix() * _camera.getViewMatrix() * math::float4(v1, 1.0f); // math::float4 clipPos1 = _camera.getProjectionMatrix() * _camera.getViewMatrix() * math::float4(v1, 1.0f);
math::float4 clipPos2 = _camera.getProjectionMatrix() * _camera.getViewMatrix() * math::float4(v2, 1.0f); // math::float4 clipPos2 = _camera.getProjectionMatrix() * _camera.getViewMatrix() * math::float4(v2, 1.0f);
math::float3 ndcPos0 = clipPos0.xyz / clipPos0.w; // math::float3 ndcPos0 = clipPos0.xyz / clipPos0.w;
math::float3 ndcPos1 = clipPos1.xyz / clipPos1.w; // math::float3 ndcPos1 = clipPos1.xyz / clipPos1.w;
math::float3 ndcPos2 = clipPos2.xyz / clipPos2.w; // math::float3 ndcPos2 = clipPos2.xyz / clipPos2.w;
// Convert NDC to screen coordinates // // Convert NDC to screen coordinates
math::float2 screenPos0((ndcPos0.x * 0.5f + 0.5f) * inputWidth, (1.0f - (ndcPos0.y * 0.5f + 0.5f)) * inputHeight); // math::float2 screenPos0((ndcPos0.x * 0.5f + 0.5f) * inputWidth, (1.0f - (ndcPos0.y * 0.5f + 0.5f)) * inputHeight);
math::float2 screenPos1((ndcPos1.x * 0.5f + 0.5f) * inputWidth, (1.0f - (ndcPos1.y * 0.5f + 0.5f)) * inputHeight); // math::float2 screenPos1((ndcPos1.x * 0.5f + 0.5f) * inputWidth, (1.0f - (ndcPos1.y * 0.5f + 0.5f)) * inputHeight);
math::float2 screenPos2((ndcPos2.x * 0.5f + 0.5f) * inputWidth, (1.0f - (ndcPos2.y * 0.5f + 0.5f)) * inputHeight); // math::float2 screenPos2((ndcPos2.x * 0.5f + 0.5f) * inputWidth, (1.0f - (ndcPos2.y * 0.5f + 0.5f)) * inputHeight);
// Compute bounding box of the triangle // // Compute bounding box of the triangle
int minX = std::max(0, static_cast<int>(std::min({screenPos0.x, screenPos1.x, screenPos2.x}))); // int minX = std::max(0, static_cast<int>(std::min({screenPos0.x, screenPos1.x, screenPos2.x})));
int maxX = std::min(static_cast<int>(inputWidth) - 1, static_cast<int>(std::max({screenPos0.x, screenPos1.x, screenPos2.x}))); // int maxX = std::min(static_cast<int>(inputWidth) - 1, static_cast<int>(std::max({screenPos0.x, screenPos1.x, screenPos2.x})));
int minY = std::max(0, static_cast<int>(std::min({screenPos0.y, screenPos1.y, screenPos2.y}))); // int minY = std::max(0, static_cast<int>(std::min({screenPos0.y, screenPos1.y, screenPos2.y})));
int maxY = std::min(static_cast<int>(inputHeight) - 1, static_cast<int>(std::max({screenPos0.y, screenPos1.y, screenPos2.y}))); // int maxY = std::min(static_cast<int>(inputHeight) - 1, static_cast<int>(std::max({screenPos0.y, screenPos1.y, screenPos2.y})));
// Iterate over the bounding box // // Iterate over the bounding box
for (int y = minY; y <= maxY; ++y) // for (int y = minY; y <= maxY; ++y)
{ // {
for (int x = minX; x <= maxX; ++x) // for (int x = minX; x <= maxX; ++x)
{ // {
math::float2 pixelPos(x + 0.5f, y + 0.5f); // math::float2 pixelPos(x + 0.5f, y + 0.5f);
if (isInsideTriangle(pixelPos, screenPos0, screenPos1, screenPos2)) // if (isInsideTriangle(pixelPos, screenPos0, screenPos1, screenPos2))
{ // {
math::float3 bary = barycentric(pixelPos, screenPos0, screenPos1, screenPos2); // math::float3 bary = barycentric(pixelPos, screenPos0, screenPos1, screenPos2);
// Interpolate depth // // Interpolate depth
float depth = bary.x * ndcPos0.z + bary.y * ndcPos1.z + bary.z * ndcPos2.z; // float depth = bary.x * ndcPos0.z + bary.y * ndcPos1.z + bary.z * ndcPos2.z;
// Depth test // // Depth test
if (depth < depthBuffer[y * inputWidth + x]) // if (depth < depthBuffer[y * inputWidth + x])
{ // {
if (depth > max) // if (depth > max)
{ // {
max = depth; // max = depth;
} // }
if (depth < min) // if (depth < min)
{ // {
min = depth; // min = depth;
} // }
depthBuffer[y * inputWidth + x] = depth; // depthBuffer[y * inputWidth + x] = depth;
triangleIndexBuffer[y * inputWidth + x] = i / 3; // Store triangle index // triangleIndexBuffer[y * inputWidth + x] = i / 3; // Store triangle index
} // }
} // }
} // }
} // }
} // }
for (uint32_t y = 0; y < outputHeight; ++y) // for (uint32_t y = 0; y < outputHeight; ++y)
{ // {
for (uint32_t x = 0; x < outputWidth; ++x) // for (uint32_t x = 0; x < outputWidth; ++x)
{ // {
math::float2 uv(static_cast<float>(x) / outputWidth, static_cast<float>(y) / outputHeight); // math::float2 uv(static_cast<float>(x) / outputWidth, static_cast<float>(y) / outputHeight);
// Use the UV coordinates to get the corresponding 3D position on the renderable // // Use the UV coordinates to get the corresponding 3D position on the renderable
math::float3 objectPos; // math::float3 objectPos;
math::float2 interpolatedUV; // math::float2 interpolatedUV;
bool found = false; // bool found = false;
// Iterate over triangles to find which one contains this UV coordinate // // Iterate over triangles to find which one contains this UV coordinate
for (size_t i = 0; i < numIndices; i += 3) // for (size_t i = 0; i < numIndices; i += 3)
{ // {
math::float2 uv0 = *(math::float2 *)&uvs[indices[i] * 2]; // math::float2 uv0 = *(math::float2 *)&uvs[indices[i] * 2];
math::float2 uv1 = *(math::float2 *)&uvs[indices[i + 1] * 2]; // math::float2 uv1 = *(math::float2 *)&uvs[indices[i + 1] * 2];
math::float2 uv2 = *(math::float2 *)&uvs[indices[i + 2] * 2]; // math::float2 uv2 = *(math::float2 *)&uvs[indices[i + 2] * 2];
if (isInsideTriangle(uv, uv0, uv1, uv2)) // if (isInsideTriangle(uv, uv0, uv1, uv2))
{ // {
// Compute barycentric coordinates in UV space // // Compute barycentric coordinates in UV space
math::float3 bary = barycentric(uv, uv0, uv1, uv2); // math::float3 bary = barycentric(uv, uv0, uv1, uv2);
// Interpolate 3D position // // Interpolate 3D position
math::float3 v0(vertices[indices[i] * 3], vertices[indices[i] * 3 + 1], vertices[indices[i] * 3 + 2]); // math::float3 v0(vertices[indices[i] * 3], vertices[indices[i] * 3 + 1], vertices[indices[i] * 3 + 2]);
math::float3 v1(vertices[indices[i + 1] * 3], vertices[indices[i + 1] * 3 + 1], vertices[indices[i + 1] * 3 + 2]); // math::float3 v1(vertices[indices[i + 1] * 3], vertices[indices[i + 1] * 3 + 1], vertices[indices[i + 1] * 3 + 2]);
math::float3 v2(vertices[indices[i + 2] * 3], vertices[indices[i + 2] * 3 + 1], vertices[indices[i + 2] * 3 + 2]); // math::float3 v2(vertices[indices[i + 2] * 3], vertices[indices[i + 2] * 3 + 1], vertices[indices[i + 2] * 3 + 2]);
objectPos = v0 * bary.x + v1 * bary.y + v2 * bary.z; // objectPos = v0 * bary.x + v1 * bary.y + v2 * bary.z;
interpolatedUV = uv; // interpolatedUV = uv;
// Find the screen coordinates on the input texture // // Find the screen coordinates on the input texture
math::float3 worldPos = (worldTransform * math::float4(objectPos, 1.0f)).xyz; // math::float3 worldPos = (worldTransform * math::float4(objectPos, 1.0f)).xyz;
// Project the world position to screen space // // Project the world position to screen space
math::float4 clipPos = _camera.getProjectionMatrix() * _camera.getViewMatrix() * math::float4(worldPos, 1.0f); // math::float4 clipPos = _camera.getProjectionMatrix() * _camera.getViewMatrix() * math::float4(worldPos, 1.0f);
math::float3 ndcPos = clipPos.xyz / clipPos.w; // math::float3 ndcPos = clipPos.xyz / clipPos.w;
// Convert NDC to screen coordinates // // Convert NDC to screen coordinates
uint32_t screenX = (ndcPos.x * 0.5f + 0.5f) * inputWidth; // uint32_t screenX = (ndcPos.x * 0.5f + 0.5f) * inputWidth;
uint32_t screenY = (1.0f - (ndcPos.y * 0.5f + 0.5f)) * inputHeight; // uint32_t screenY = (1.0f - (ndcPos.y * 0.5f + 0.5f)) * inputHeight;
if (triangleIndexBuffer[(screenY * inputWidth) + screenX] == i / 3) // if (triangleIndexBuffer[(screenY * inputWidth) + screenX] == i / 3)
{ // {
if (screenX >= 0 && screenX < inputWidth && screenY >= 0 && screenY < inputHeight) // if (screenX >= 0 && screenX < inputWidth && screenY >= 0 && screenY < inputHeight)
{ // {
int inputIndex = (screenY * inputWidth + screenX) * 4; // int inputIndex = (screenY * inputWidth + screenX) * 4;
int outputIndex = (y * outputWidth + x) * 4; // int outputIndex = (y * outputWidth + x) * 4;
std::copy_n(&inputTexture[inputIndex], 4, &outputTexture[outputIndex]); // std::copy_n(&inputTexture[inputIndex], 4, &outputTexture[outputIndex]);
} // }
} // }
} // }
} // }
} // }
} // }
} }
} // namespace thermion } // namespace thermion