//! Deprecated
Mesh * MeshBuilder::createMeshFromBitmaps(const VertexDescription& vd, Util::Reference<Util::Bitmap> depth, Util::Reference<Util::Bitmap> color, Util::Reference<Util::Bitmap> normals) {
Util::Reference<Util::PixelAccessor> depthAcc = Util::PixelAccessor::create(std::move(depth));
if( depth.isNull() || depth->getPixelFormat()!=Util::PixelFormat::MONO_FLOAT ){
WARN("createMeshFromBitmaps: unsupported depth texture format");
return nullptr;
}
Util::Reference<Util::PixelAccessor> colorReader;
if(color.isNotNull()) {
colorReader = Util::PixelAccessor::create(std::move(color));
if(colorReader.isNull() || (colorReader->getPixelFormat() != Util::PixelFormat::RGBA && colorReader->getPixelFormat() != Util::PixelFormat::RGB)) {
WARN("createMeshFromBitmaps: unsupported color texture format");
return nullptr;
}
}
Util::Reference<Util::PixelAccessor> normalReader;
if(normals.isNotNull()) {
normalReader = Util::PixelAccessor::create(std::move(normals));
if(normalReader.isNull()){
WARN("createMeshFromBitmaps: unsupported normal texture format");
return nullptr;
}
}
return MeshUtils::createMeshFromBitmaps(vd,depthAcc,colorReader,normalReader);
}
void drawVector(RenderingContext & rc, const Geometry::Vec3 & from, const Geometry::Vec3 & to) {
static Util::Reference<Mesh> mesh;
if (mesh.isNull()) {
VertexDescription vertexDescription;
vertexDescription.appendPosition3D();
mesh = new Mesh(vertexDescription, 2, 2);
mesh->setDrawMode(Mesh::DRAW_LINES);
MeshIndexData & id = mesh->openIndexData();
uint32_t * indices = id.data();
indices[0] = 0;
indices[1] = 1;
id.updateIndexRange();
id.markAsChanged();
mesh->setDataStrategy(SimpleMeshDataStrategy::getPureLocalStrategy());
}
MeshVertexData & vd = mesh->openVertexData();
float * vertices = reinterpret_cast<float *> (vd.data());
*vertices++ = from.getX(); // From
*vertices++ = from.getY();
*vertices++ = from.getZ();
*vertices++ = to.getX(); // To
*vertices++ = to.getY();
*vertices++ = to.getZ();
vd.updateBoundingBox();
vd.markAsChanged();
rc.displayMesh(mesh.get());
}
void drawTriangle(RenderingContext & rc, const Geometry::Vec3f & vertexA, const Geometry::Vec3f & vertexB, const Geometry::Vec3f & vertexC) {
static Util::Reference<Mesh> mesh;
if (mesh.isNull()) {
VertexDescription vertexDescription;
vertexDescription.appendPosition3D();
mesh = new Mesh(vertexDescription, 3, 3);
MeshIndexData & id = mesh->openIndexData();
uint32_t * indices = id.data();
indices[0] = 0;
indices[1] = 1;
indices[2] = 2;
id.updateIndexRange();
id.markAsChanged();
}
MeshVertexData & vd = mesh->openVertexData();
float * vertices = reinterpret_cast<float *>(vd.data());
// First vertex
*vertices++ = vertexA.getX();
*vertices++ = vertexA.getY();
*vertices++ = vertexA.getZ();
// Second vertex
*vertices++ = vertexB.getX();
*vertices++ = vertexB.getY();
*vertices++ = vertexB.getZ();
// Third vertex
*vertices++ = vertexC.getX();
*vertices++ = vertexC.getY();
*vertices++ = vertexC.getZ();
vd.updateBoundingBox();
vd.markAsChanged();
rc.displayMesh(mesh.get());
}
void drawFullScreenRect(RenderingContext & rc){
GET_GL_ERROR();
static Geometry::Matrix4x4f projectionMatrix(Geometry::Matrix4x4f::orthographicProjection(-1, 1, -1, 1, -1, 1));
static Geometry::Matrix4x4f modelViewMatrix;
static Util::Reference<Mesh> mesh;
if(mesh.isNull()) {
VertexDescription vertexDescription;
vertexDescription.appendPosition3D();
vertexDescription.appendTexCoord();
MeshUtils::MeshBuilder mb(vertexDescription);
mb.position(Geometry::Vec3f(-1,-1,0)); mb.texCoord0(Geometry::Vec2f(0,0)); uint32_t a = mb.addVertex();
mb.position(Geometry::Vec3f(1,-1,0)); mb.texCoord0(Geometry::Vec2f(1,0)); uint32_t b = mb.addVertex();
mb.position(Geometry::Vec3f(-1,1,0)); mb.texCoord0(Geometry::Vec2f(0,1)); uint32_t c = mb.addVertex();
mb.position(Geometry::Vec3f(1,1,0)); mb.texCoord0(Geometry::Vec2f(1,1)); uint32_t d = mb.addVertex();
mb.addTriangle(a, b, c);
mb.addTriangle(c, b, d);
mesh = mb.buildMesh();
}
rc.pushMatrix_cameraToClipping();
rc.setMatrix_cameraToClipping(projectionMatrix);
rc.pushMatrix_modelToCamera();
rc.setMatrix_modelToCamera(modelViewMatrix);
rc.displayMesh(mesh.get());
rc.popMatrix_modelToCamera();
rc.popMatrix_cameraToClipping();
GET_GL_ERROR();
}
void drawWireframeBox(RenderingContext & rc, const Geometry::Box & box) {
static Util::Reference<Mesh> mesh;
if (mesh.isNull()) {
VertexDescription vertexDescription;
vertexDescription.appendPosition3D();
mesh = new Mesh(vertexDescription, 8, 16);
mesh->setDataStrategy(SimpleMeshDataStrategy::getPureLocalStrategy());
mesh->setDrawMode(Mesh::DRAW_LINE_STRIP);
MeshIndexData & id = mesh->openIndexData();
uint32_t * indices = id.data();
/*
* Corners:
* 6---------7
* /| /|
* / | / |
* 2---------3 |
* | | | |
* | 4------|--5
* | / | /
* |/ |/
* 0---------1
*/
indices[0] = 0;
indices[1] = 2;
indices[2] = 3;
indices[3] = 1;
indices[4] = 5;
indices[5] = 7;
indices[6] = 6;
indices[7] = 4;
indices[8] = 0;
indices[9] = 1;
indices[10] = 3;
indices[11] = 7;
indices[12] = 5;
indices[13] = 4;
indices[14] = 6;
indices[15] = 2;
id.updateIndexRange();
id.markAsChanged();
}
MeshVertexData & vd = mesh->openVertexData();
float * vertices = reinterpret_cast<float *>(vd.data());
for (uint_fast8_t c = 0; c < 8; ++c) {
const Geometry::Vec3 & corner = box.getCorner(static_cast<Geometry::corner_t> (c));
*vertices++ = corner.getX();
*vertices++ = corner.getY();
*vertices++ = corner.getZ();
}
vd._setBoundingBox(box);
vd.markAsChanged();
rc.displayMesh(mesh.get());
}
void drawGrid(RenderingContext & rc, float scale) {
static Util::Reference<Mesh> mesh;
if (mesh.isNull()) {
VertexDescription vertexDescription;
vertexDescription.appendPosition3D();
mesh = new Mesh(vertexDescription, 4 * 101, 4 * 101);
mesh->setDrawMode(Mesh::DRAW_LINES);
MeshVertexData & vd = mesh->openVertexData();
float * vertices = reinterpret_cast<float *> (vd.data());
MeshIndexData & id = mesh->openIndexData();
uint32_t * indices = id.data();
uint32_t nextIndex = 0;
const float step = 1.0f / 100.0f;
for (uint_fast8_t line = 0; line < 101; ++line) {
const float pos = -0.5f + static_cast<float> (line) * step;
*vertices++ = -0.5f;
*vertices++ = 0.0f;
*vertices++ = pos;
*vertices++ = 0.5f;
*vertices++ = 0.0f;
*vertices++ = pos;
*indices++ = nextIndex++;
*indices++ = nextIndex++;
*vertices++ = pos;
*vertices++ = 0.0f;
*vertices++ = -0.5f;
*vertices++ = pos;
*vertices++ = 0.0f;
*vertices++ = 0.5f;
*indices++ = nextIndex++;
*indices++ = nextIndex++;
}
vd.updateBoundingBox();
vd.markAsChanged();
id.updateIndexRange();
id.markAsChanged();
}
Geometry::Matrix4x4 matrix;
matrix.scale(scale);
rc.pushMatrix_modelToCamera();
rc.multMatrix_modelToCamera(matrix);
rc.displayMesh(mesh.get());
rc.popMatrix_modelToCamera();
}
void drawFrustum(RenderingContext & rc, const Geometry::Frustum & frustum, const Util::Color4f & color, float lineWidth) {
static Util::Reference<Mesh> mesh;
if (mesh.isNull()) {
VertexDescription vertexDescription;
vertexDescription.appendPosition3D();
mesh = new Mesh(vertexDescription, 8, 16);
mesh->setDrawMode(Mesh::DRAW_LINE_STRIP);
MeshIndexData & id = mesh->openIndexData();
uint32_t * indices = id.data();
indices[0] = 0;
indices[1] = 2;
indices[2] = 3;
indices[3] = 1;
indices[4] = 5;
indices[5] = 7;
indices[6] = 6;
indices[7] = 4;
indices[8] = 0;
indices[9] = 1;
indices[10] = 3;
indices[11] = 7;
indices[12] = 5;
indices[13] = 4;
indices[14] = 6;
indices[15] = 2;
id.updateIndexRange();
}
MeshVertexData & vd = mesh->openVertexData();
float * vertices = reinterpret_cast<float *>(vd.data());
for (uint_fast8_t c = 0; c < 8; ++c) {
const Geometry::Vec3 & corner = frustum[static_cast<Geometry::corner_t> (c)];
*vertices++ = corner.getX();
*vertices++ = corner.getY();
*vertices++ = corner.getZ();
}
vd.updateBoundingBox();
vd.markAsChanged();
rc.pushAndSetLine(lineWidth);
rc.pushAndSetLighting(LightingParameters(false));
rc.pushAndSetColorMaterial(color);
rc.displayMesh(mesh.get());
rc.popMaterial();
rc.popLighting();
rc.popLine();
}
void drawBox(RenderingContext & rc, const Geometry::Box & box) {
static Util::Reference<Mesh> mesh;
if (mesh.isNull()) {
VertexDescription vertexDescription;
vertexDescription.appendPosition3D();
vertexDescription.appendNormalFloat();
const Geometry::Box unitBox(Geometry::Vec3(-0.5f, -0.5f, -0.5f), Geometry::Vec3(0.5f, 0.5f, 0.5f));
mesh = MeshUtils::MeshBuilder::createBox(vertexDescription, unitBox);
}
Geometry::Matrix4x4 matrix;
matrix.translate(box.getCenter());
matrix.scale(box.getExtentX(), box.getExtentY(), box.getExtentZ());
rc.pushMatrix_modelToCamera();
rc.multMatrix_modelToCamera(matrix);
rc.displayMesh(mesh.get());
rc.popMatrix_modelToCamera();
}
void drawRect(RenderingContext & rc, const Geometry::Rect & rect) {
static Util::Reference<Mesh> mesh;
if (mesh.isNull()) {
VertexDescription vertexDescription;
vertexDescription.appendPosition2D();
mesh = new Mesh(vertexDescription, 4, 6);
mesh->setDrawMode(Mesh::DRAW_TRIANGLES);
MeshVertexData & vd = mesh->openVertexData();
float * vertices = reinterpret_cast<float *> (vd.data());
*vertices++ = 0.0f; // Bottom left
*vertices++ = 0.0f;
*vertices++ = 1.0f; // Bottom right
*vertices++ = 0.0f;
*vertices++ = 1.0f; // Top right
*vertices++ = 1.0f;
*vertices++ = 0.0f; // Top left
*vertices++ = 1.0f;
vd.updateBoundingBox();
vd.markAsChanged();
MeshIndexData & id = mesh->openIndexData();
uint32_t * indices = id.data();
indices[0] = 0;
indices[1] = 2;
indices[2] = 1;
indices[3] = 0;
indices[4] = 3;
indices[5] = 2;
id.updateIndexRange();
id.markAsChanged();
}
Geometry::Matrix4x4 matrix;
matrix.translate(rect.getX(), rect.getY(), 0.0f);
matrix.scale(rect.getWidth(), rect.getHeight(), 1.0f);
rc.pushMatrix_modelToCamera();
rc.multMatrix_modelToCamera(matrix);
rc.displayMesh(mesh.get());
rc.popMatrix_modelToCamera();
}
void drawCamera(RenderingContext & rc, const Util::Color4f & color) {
static Util::Reference<Mesh> mesh;
if (mesh.isNull()) {
std::deque<Mesh *> meshes;
std::deque<Geometry::Matrix4x4f> transformations;
{
VertexDescription vertexDescription;
vertexDescription.appendPosition3D();
vertexDescription.appendNormalFloat();
Geometry::Box box(Geometry::Vec3f(0.0f, 0.0f, 0.1f), 0.2f, 0.5f, 0.8f);
meshes.push_back(MeshUtils::MeshBuilder::createBox(vertexDescription, box));
transformations.push_back(Geometry::Matrix4x4());
}
{
// Lens
meshes.push_back(MeshUtils::MeshBuilder::createConicalFrustum(0.1f, 0.25f, 0.2f, 16));
Geometry::Matrix4x4f mat;
mat.translate(0.0f, 0.0f, -0.3f);
mat.rotate_deg(90.0f, 0.0f, 1.0f, 0.0f);
transformations.push_back(mat);
}
{
// Lens cap
meshes.push_back(MeshUtils::MeshBuilder::createDiscSector(0.25f, 16));
Geometry::Matrix4x4f mat;
mat.translate(0.0f, 0.0f, -0.5f);
mat.rotate_deg(-90.0f, 0.0f, 1.0f, 0.0f);
transformations.push_back(mat);
}
{
// First film reel
meshes.push_back(MeshUtils::MeshBuilder::createConicalFrustum(0.2f, 0.2f, 0.1f, 16));
Geometry::Matrix4x4f mat;
mat.translate(-0.05f, 0.45f, -0.1f);
transformations.push_back(mat);
}
{
meshes.push_back(MeshUtils::MeshBuilder::createDiscSector(0.2f, 16));
Geometry::Matrix4x4f mat;
mat.translate(-0.05f, 0.45f, -0.1f);
transformations.push_back(mat);
}
{
meshes.push_back(MeshUtils::MeshBuilder::createDiscSector(0.2f, 16));
Geometry::Matrix4x4f mat;
mat.translate(0.05f, 0.45f, -0.1f);
mat.rotate_deg(180.0f, 0.0f, 1.0f, 0.0f);
transformations.push_back(mat);
}
{
// Second film reel
meshes.push_back(MeshUtils::MeshBuilder::createConicalFrustum(0.2f, 0.2f, 0.1f, 16));
Geometry::Matrix4x4f mat;
mat.translate(-0.05f, 0.45f, 0.3f);
transformations.push_back(mat);
}
{
meshes.push_back(MeshUtils::MeshBuilder::createDiscSector(0.2f, 16));
Geometry::Matrix4x4f mat;
mat.translate(-0.05f, 0.45f, 0.3f);
transformations.push_back(mat);
}
{
meshes.push_back(MeshUtils::MeshBuilder::createDiscSector(0.2f, 16));
Geometry::Matrix4x4f mat;
mat.translate(0.05f, 0.45f, 0.3f);
mat.rotate_deg(180.0f, 0.0f, 1.0f, 0.0f);
transformations.push_back(mat);
}
mesh = MeshUtils::combineMeshes(meshes, transformations);
}
rc.pushAndSetLighting(LightingParameters(false));
rc.pushAndSetColorMaterial(Util::Color4f(color));
rc.displayMesh(mesh.get());
rc.popMaterial();
rc.popLighting();
}
void drawCoordSys(RenderingContext & rc, float scale) {
static Util::Reference<Mesh> arrow;
static Util::Reference<Mesh> sphere;
static Util::Reference<Mesh> charX;
static Util::Reference<Mesh> charY;
static Util::Reference<Mesh> charZ;
const float radius = 0.025f;
if (arrow.isNull()) {
std::deque<Mesh *> meshes;
std::deque<Geometry::Matrix4x4> transformations;
Geometry::Matrix4x4 transform;
meshes.push_back(MeshUtils::MeshBuilder::createConicalFrustum(radius, radius, 0.7f, 16));
transformations.push_back(transform);
meshes.push_back(MeshUtils::MeshBuilder::createConicalFrustum(radius, 2.0f * radius, 0.01f, 16));
transform.translate(0.7f, 0.0f, 0.0f);
transformations.push_back(transform);
meshes.push_back(MeshUtils::MeshBuilder::createCone(2.0f * radius, 0.29f, 16));
transform.translate(0.01f, 0.0f, 0.0f);
transformations.push_back(transform);
arrow = MeshUtils::combineMeshes(meshes, transformations);
MeshUtils::optimizeIndices(arrow.get());
while (!meshes.empty()) {
delete meshes.back();
meshes.pop_back();
}
}
if (sphere.isNull()) {
Util::Reference<Mesh> icosahedron = MeshUtils::PlatonicSolids::createIcosahedron();
sphere = MeshUtils::PlatonicSolids::createEdgeSubdivisionSphere(icosahedron.get(), 2);
Geometry::Matrix4x4 transform;
transform.scale(1.1f * radius);
MeshUtils::transform(sphere.get()->openVertexData(), transform);
}
if(charX.isNull()) {
std::deque<Mesh *> meshes;
std::deque<Geometry::Matrix4x4> transformations;
VertexDescription vertexDescription;
vertexDescription.appendPosition3D();
vertexDescription.appendNormalFloat();
const Geometry::Box box(Geometry::Vec3f(0.0f, 0.0f, 0.0f), 0.02f, 0.2f, 0.05f);
{
meshes.push_back(MeshUtils::MeshBuilder::createBox(vertexDescription, box));
Geometry::Matrix4x4 transform;
transform.translate(1.2f, 0.0f, 0.0f);
transform.rotate_deg(30.0f, 0.0f, 0.0f, -1.0f);
transformations.push_back(transform);
}
{
meshes.push_back(MeshUtils::MeshBuilder::createBox(vertexDescription, box));
Geometry::Matrix4x4 transform;
transform.translate(1.2f, 0.0f, 0.0f);
transform.rotate_deg(-30.0f, 0.0f, 0.0f, -1.0f);
transformations.push_back(transform);
}
charX = MeshUtils::combineMeshes(meshes, transformations);
MeshUtils::optimizeIndices(charX.get());
while(!meshes.empty()) {
delete meshes.back();
meshes.pop_back();
}
}
if(charY.isNull()) {
std::deque<Mesh *> meshes;
std::deque<Geometry::Matrix4x4> transformations;
VertexDescription vertexDescription;
vertexDescription.appendPosition3D();
vertexDescription.appendNormalFloat();
const Geometry::Box box(Geometry::Vec3f(0.0f, 0.0f, 0.0f), 0.02f, 0.1f, 0.05f);
{
meshes.push_back(MeshUtils::MeshBuilder::createBox(vertexDescription, box));
Geometry::Matrix4x4 transform;
transform.translate(0.025f, 0.045f, 0.0f);
transform.rotate_deg(30.0f, 0.0f, 0.0f, -1.0f);
transformations.push_back(transform);
}
{
meshes.push_back(MeshUtils::MeshBuilder::createBox(vertexDescription, box));
Geometry::Matrix4x4 transform;
transform.translate(-0.025f, 0.045f, 0.0f);
transform.rotate_deg(-30.0f, 0.0f, 0.0f, -1.0f);
transformations.push_back(transform);
}
{
meshes.push_back(MeshUtils::MeshBuilder::createBox(vertexDescription, box));
Geometry::Matrix4x4 transform;
transform.translate(0.0f, -0.045f, 0.0f);
transformations.push_back(transform);
}
charY = MeshUtils::combineMeshes(meshes, transformations);
Geometry::Matrix4x4 transform;
transform.translate(1.2f, 0.0f, 0.0f);
transform.rotate_deg(90.0f, 0.0f, 0.0f, -1.0f);
MeshUtils::transform(charY->openVertexData(), transform);
MeshUtils::optimizeIndices(charY.get());
while(!meshes.empty()) {
delete meshes.back();
meshes.pop_back();
}
}
if(charZ.isNull()) {
std::deque<Mesh *> meshes;
std::deque<Geometry::Matrix4x4> transformations;
VertexDescription vertexDescription;
vertexDescription.appendPosition3D();
vertexDescription.appendNormalFloat();
const Geometry::Box box(Geometry::Vec3f(0.0f, 0.0f, 0.0f), 0.02f, 0.1f, 0.05f);
{
meshes.push_back(MeshUtils::MeshBuilder::createBox(vertexDescription, box));
Geometry::Matrix4x4 transform;
transform.translate(1.2f, 0.075f, 0.0f);
transform.rotate_deg(90.0f, 0.0f, 0.0f, -1.0f);
transformations.push_back(transform);
}
{
meshes.push_back(MeshUtils::MeshBuilder::createBox(vertexDescription, box));
Geometry::Matrix4x4 transform;
transform.translate(1.2f, 0.0f, 0.0f);
transform.rotate_deg(-30.0f, 0.0f, 0.0f, -1.0f);
transform.scale(1.0f, 1.6f, 1.0f);
transformations.push_back(transform);
}
{
meshes.push_back(MeshUtils::MeshBuilder::createBox(vertexDescription, box));
Geometry::Matrix4x4 transform;
transform.translate(1.2f, -0.075f, 0.0f);
transform.rotate_deg(-90.0f, 0.0f, 0.0f, -1.0f);
transformations.push_back(transform);
}
charZ = MeshUtils::combineMeshes(meshes, transformations);
MeshUtils::optimizeIndices(charZ.get());
while(!meshes.empty()) {
delete meshes.back();
meshes.pop_back();
}
}
// Origin
rc.pushAndSetColorMaterial(Util::ColorLibrary::WHITE);
rc.displayMesh(sphere.get());
rc.popMaterial();
// X axis
Geometry::Matrix4x4 transform;
transform.scale(scale, 1.0f, 1.0f);
rc.pushMatrix_modelToCamera();
rc.multMatrix_modelToCamera(transform);
rc.pushAndSetColorMaterial(Util::ColorLibrary::RED);
rc.displayMesh(arrow.get());
rc.displayMesh(charX.get());
rc.popMaterial();
rc.popMatrix_modelToCamera();
// Y axis
transform.setIdentity();
transform.scale(1.0f, scale, 1.0f);
transform.rotate_deg(90.0f, 0.0f, 0.0f, 1.0f);
rc.pushMatrix_modelToCamera();
rc.multMatrix_modelToCamera(transform);
rc.pushAndSetColorMaterial(Util::ColorLibrary::GREEN);
rc.displayMesh(arrow.get());
rc.displayMesh(charY.get());
rc.popMaterial();
rc.popMatrix_modelToCamera();
// Z axis
transform.setIdentity();
transform.scale(1.0f, 1.0f, scale);
transform.rotate_deg(90.0f, 0.0f, -1.0f, 0.0f);
rc.pushMatrix_modelToCamera();
rc.multMatrix_modelToCamera(transform);
rc.pushAndSetColorMaterial(Util::ColorLibrary::BLUE);
rc.displayMesh(arrow.get());
rc.displayMesh(charZ.get());
rc.popMaterial();
rc.popMatrix_modelToCamera();
}
State::stateResult_t VisibilitySubdivisionRenderer::doEnableState(
FrameContext & context,
Node *,
const RenderParam & rp) {
if (rp.getFlag(SKIP_RENDERER)) {
return State::STATE_SKIPPED;
}
if (viSu == nullptr) {
// Invalid information. => Fall back to standard rendering.
return State::STATE_SKIPPED;
}
// [AccumRendering]
if(accumRenderingEnabled){
// camera moved? -> start new frame
const Geometry::Matrix4x4 & newCamMat=context.getCamera()->getWorldTransformationMatrix();
if(newCamMat!=lastCamMatrix){
lastCamMatrix = newCamMat;
startRuntime=0;
}
}else{
startRuntime=0;
}
// ----
uint32_t renderedTriangles = 0;
if (hold) {
for (const auto & object : holdObjects) {
if (debugOutput) {
debugDisplay(renderedTriangles, object, context, rp);
} else {
context.displayNode(object, rp);
}
}
return State::STATE_SKIP_RENDERING;
}
Geometry::Vec3 pos = context.getCamera()->getWorldOrigin();
bool refreshCache = false;
// Check if cached cell can be used.
if (currentCell == nullptr || !currentCell->getBB().contains(pos)) {
currentCell = viSu->getNodeAtPosition(pos);
refreshCache = true;
}
if (currentCell == nullptr || !currentCell->isLeaf()) {
// Invalid information. => Fall back to standard rendering.
return State::STATE_SKIPPED;
}
if (refreshCache) {
try {
const auto & vv = getVV(currentCell);
const uint32_t maxIndex = vv.getIndexCount();
objects.clear();
objects.reserve(maxIndex);
for(uint_fast32_t index = 0; index < maxIndex; ++index) {
if(vv.getBenefits(index) == 0) {
continue;
}
const VisibilityVector::costs_t costs = vv.getCosts(index);
const VisibilityVector::benefits_t benefits = vv.getBenefits(index);
const float score = static_cast<float>(costs) / static_cast<float>(benefits);
objects.emplace_back(score, vv.getNode(index));
}
} catch(...) {
// Invalid information. => Fall back to standard rendering.
return State::STATE_SKIPPED;
}
if (displayTexturedDepthMeshes) {
#ifdef MINSG_EXT_OUTOFCORE
for (const auto & depthMesh : depthMeshes) {
OutOfCore::getCacheManager().setUserPriority(depthMesh.get(), 0);
}
#endif /* MINSG_EXT_OUTOFCORE */
depthMeshes.clear();
depthMeshes.reserve(6);
textures.clear();
textures.reserve(6);
const std::string dmDirectionStrings[6] = { "-dir_x1_y0_z0", "-dir_x-1_y0_z0",
"-dir_x0_y1_z0", "-dir_x0_y-1_z0",
"-dir_x0_y0_z1", "-dir_x0_y0_z-1" };
for (auto & dmDirectionString : dmDirectionStrings) {
Util::GenericAttribute * attrib = currentCell->getAttribute("DepthMesh" + dmDirectionString);
if (attrib == nullptr) {
continue;
}
Util::FileName dmMeshPath(attrib->toString());
Util::Reference<Rendering::Mesh> dmMesh;
#ifdef MINSG_EXT_OUTOFCORE
Util::GenericAttribute * bbAttrib = currentCell->getAttribute("DepthMesh" + dmDirectionString + "-bounds");
if (bbAttrib == nullptr) {
WARN("Found depth mesh with no bounding box.");
continue;
}
std::vector<float> bbValues = Util::StringUtils::toFloats(bbAttrib->toString());
FAIL_IF(bbValues.size() != 6);
const Geometry::Box meshBB(Geometry::Vec3(bbValues[0], bbValues[1], bbValues[2]), bbValues[3], bbValues[4], bbValues[5]);
dmMesh = OutOfCore::addMesh(dmMeshPath, meshBB);
#else /* MINSG_EXT_OUTOFCORE */
dmMesh = Rendering::Serialization::loadMesh(dmMeshPath);
#endif /* MINSG_EXT_OUTOFCORE */
depthMeshes.emplace_back(dmMesh);
// Count the depth mesh here already.
renderedTriangles += dmMesh->getPrimitiveCount();
Util::GenericAttribute * texAttrib = currentCell->getAttribute("Texture" + dmDirectionString);
if (texAttrib == nullptr) {
continue;
}
Util::FileName texturePath(texAttrib->toString());
Util::Reference<Rendering::Texture> texture = Rendering::Serialization::loadTexture(texturePath);
if (texture.isNull()) {
WARN("Loading texture for depth mesh failed.");
continue;
}
textures.emplace_back(texture);
}
}
}
const Geometry::Frustum & frustum = context.getCamera()->getFrustum();
holdObjects.clear();
holdObjects.reserve(objects.size());
std::sort(objects.begin(), objects.end());
for(const auto & ratioObjectPair : objects) {
object_ptr o = ratioObjectPair.second;
#ifdef MINSG_EXT_OUTOFCORE
OutOfCore::getCacheManager().setUserPriority(o->getMesh(), 5);
#endif /* MINSG_EXT_OUTOFCORE */
if (conditionalFrustumTest(frustum, o->getWorldBB(), rp)) {
// [AccumRendering]
// skip geometry rendered in the last frame
if(renderedTriangles<startRuntime){
renderedTriangles += o->getTriangleCount();
continue;
}
// ----
if (debugOutput) {
debugDisplay(renderedTriangles, o, context, rp);
} else {
context.displayNode(o, rp);
renderedTriangles += o->getTriangleCount();
}
holdObjects.push_back(o);
}
if (maxRuntime != 0 && renderedTriangles >= startRuntime+maxRuntime) {
break;
}
}
// Draw the textured depth meshes at the end.
if (displayTexturedDepthMeshes) {
context.getRenderingContext().pushAndSetPolygonOffset(Rendering::PolygonOffsetParameters(polygonOffsetFactor, polygonOffsetUnits));
auto texIt = textures.cbegin();
for (const auto & depthMesh : depthMeshes) {
context.getRenderingContext().pushAndSetShader(getTDMShader());
context.getRenderingContext().pushAndSetTexture(0,texIt->get());
if (conditionalFrustumTest(frustum, depthMesh->getBoundingBox(), rp)) {
context.displayMesh(depthMesh.get());
}
context.getRenderingContext().popTexture(0);
context.getRenderingContext().popShader();
#ifdef MINSG_EXT_OUTOFCORE
OutOfCore::getCacheManager().setUserPriority(depthMesh.get(), 2);
#endif /* MINSG_EXT_OUTOFCORE */
++texIt;
}
context.getRenderingContext().popPolygonOffset();
}
// [AccumRendering]
startRuntime=renderedTriangles;
// ----
return State::STATE_SKIP_RENDERING;
}
void drawQuad(RenderingContext & rc, const Geometry::Vec3 & lowerLeft, const Geometry::Vec3 & lowerRight, const Geometry::Vec3 & upperRight,
const Geometry::Vec3 & upperLeft) {
static Util::Reference<Mesh> mesh;
if (mesh.isNull()) {
VertexDescription vertexDescription;
vertexDescription.appendPosition3D();
vertexDescription.appendNormalFloat();
vertexDescription.appendTexCoord();
mesh = new Mesh(vertexDescription, 4, 6);
MeshIndexData & id = mesh->openIndexData();
uint32_t * indices = id.data();
indices[0] = 0;
indices[1] = 1;
indices[2] = 2;
indices[3] = 0;
indices[4] = 2;
indices[5] = 3;
id.updateIndexRange();
id.markAsChanged();
}
const Geometry::Vec3 edgeA = lowerRight - lowerLeft;
const Geometry::Vec3 edgeB = upperLeft - lowerLeft;
Geometry::Vec3 normal = edgeA.cross(edgeB);
normal.normalize();
MeshVertexData & vd = mesh->openVertexData();
float * vertices = reinterpret_cast<float *> (vd.data());
// Lower left
*vertices++ = lowerLeft.getX();
*vertices++ = lowerLeft.getY();
*vertices++ = lowerLeft.getZ();
*vertices++ = normal.getX();
*vertices++ = normal.getY();
*vertices++ = normal.getZ();
*vertices++ = 0.0f;
*vertices++ = 0.0f;
// Lower right
*vertices++ = lowerRight.getX();
*vertices++ = lowerRight.getY();
*vertices++ = lowerRight.getZ();
*vertices++ = normal.getX();
*vertices++ = normal.getY();
*vertices++ = normal.getZ();
*vertices++ = 1.0f;
*vertices++ = 0.0f;
// Upper right
*vertices++ = upperRight.getX();
*vertices++ = upperRight.getY();
*vertices++ = upperRight.getZ();
*vertices++ = normal.getX();
*vertices++ = normal.getY();
*vertices++ = normal.getZ();
*vertices++ = 1.0f;
*vertices++ = 1.0f;
// Upper left
*vertices++ = upperLeft.getX();
*vertices++ = upperLeft.getY();
*vertices++ = upperLeft.getZ();
*vertices++ = normal.getX();
*vertices++ = normal.getY();
*vertices++ = normal.getZ();
*vertices++ = 0.0f;
*vertices++ = 1.0f;
vd.updateBoundingBox();
vd.markAsChanged();
rc.displayMesh(mesh.get());
}