NodeRendererResult SurfelRenderer::displayNode(FrameContext & context, Node * node, const RenderParam & /*rp*/){
static const Util::StringIdentifier SURFEL_ATTRIBUTE("surfels");
auto surfelAttribute = dynamic_cast<Util::ReferenceAttribute<Rendering::Mesh>*>(node->findAttribute( SURFEL_ATTRIBUTE ));
if( !surfelAttribute || !surfelAttribute->get())
return NodeRendererResult::PASS_ON;
Rendering::Mesh& surfelMesh = *surfelAttribute->get();
const Geometry::Rect projection = context.getProjectedRect(node);
const float approxProjectedSideLength = std::sqrt(projection.getHeight() * projection.getWidth());
// const auto& worldBB = node->getWorldBB();
// const float approxProjectedSideLength = projectionScale * worldBB.getDiameter() / (worldBB.getCenter()-cameraOrigin).length();
if(approxProjectedSideLength > maxSideLength)
return NodeRendererResult::PASS_ON;
static const Util::StringIdentifier REL_COVERING_ATTRIBUTE("surfelRelCovering");
auto surfelCoverageAttr = node->findAttribute(REL_COVERING_ATTRIBUTE);
const float relCovering = surfelCoverageAttr ? surfelCoverageAttr->toFloat() : 0.5;
const float approxProjectedArea = approxProjectedSideLength * approxProjectedSideLength * relCovering;
uint32_t surfelCount = std::min( surfelMesh.isUsingIndexData() ? surfelMesh.getIndexCount() : surfelMesh.getVertexCount(),
static_cast<uint32_t>(approxProjectedArea * countFactor) + 1);
float surfelSize = std::min(sizeFactor * approxProjectedArea / surfelCount,maxSurfelSize);
bool handled = true;
if(approxProjectedSideLength > minSideLength && minSideLength<maxSideLength){
const float f = 1.0f -(approxProjectedSideLength-minSideLength) / (maxSideLength-minSideLength);
surfelCount = std::min( surfelMesh.isUsingIndexData() ? surfelMesh.getIndexCount() : surfelMesh.getVertexCount(),
static_cast<uint32_t>(f * surfelCount) + 1);
surfelSize *= f;
handled = false;
// std::cout << approxProjectedSideLength<<"\t"<<f<<"\n";
}
// std::cout << surfelSize<<"\t"<<"\n";
// if( node->getRenderingLayers()&0x02 )
// std::cout << "pSize"<<approxProjectedSideLength << "\t#:"<<surfelCount<<"\ts:"<<surfelSize<<"\n";
auto& renderingContext = context.getRenderingContext();
static Rendering::Uniform enableSurfels("renderSurfels", true);
static Rendering::Uniform disableSurfels("renderSurfels", false);
renderingContext.setGlobalUniform(enableSurfels);
renderingContext.pushAndSetPointParameters( Rendering::PointParameters(std::min(surfelSize,32.0f) ));
renderingContext.pushAndSetMatrix_modelToCamera( renderingContext.getMatrix_worldToCamera() );
renderingContext.multMatrix_modelToCamera(node->getWorldTransformationMatrix());
context.displayMesh(&surfelMesh, 0, surfelCount );
renderingContext.popMatrix_modelToCamera();
renderingContext.popPointParameters();
renderingContext.setGlobalUniform(disableSurfels);
return handled ? NodeRendererResult::NODE_HANDLED : NodeRendererResult::PASS_ON;
}
//! ---|> Component
void Connector::doLayout(){
Geometry::Vec2 parentsAbsPos=hasParent()?getParent()->getAbsPosition():Geometry::Vec2();
Geometry::Rect r;
r.invalidate();
// std::cout << r.getX();
if( getFirstComponent() )
r.include( getFirstComponent()->getAbsRect().getCenter()-parentsAbsPos );
// std::cout << (getFirstComponent()->getAbsRect().getCenter()-parentsAbsPos).getX();
if( getSecondComponent() )
r.include( getSecondComponent()->getAbsRect().getCenter()-parentsAbsPos );
if(getContentsCount()>2){
// TODO!!!!!
}
setPosition(Geometry::Vec2(r.getX(),r.getY()));
setSize(r.getWidth(),r.getHeight());
Geometry::Vec2 myAbsPos=getAbsPosition();
if(getFirstChild() && getFirstComponent()){
getFirstChild()->setPosition( getFirstComponent()->getAbsRect().getCenter()-myAbsPos );
}
if(getLastChild() && getSecondComponent()){
getLastChild()->setPosition( getSecondComponent()->getAbsRect().getCenter()-myAbsPos );
// getLastChild()->setPosition(Vec2(r.getWidth(),r.getHeight()));
}
if(getContentsCount()>2){
// TODO!!!!!
}
}
void Container::displayChildren(const Geometry::Rect & region,bool useScissor/*=false*/) {
const Geometry::Rect myRegion=region.isValid() ? getAbsRect().clipBy(region) : getAbsRect();
if(myRegion.isInvalid())
return;
if(useScissor){
Geometry::Rect_i scissorRect = Geometry::Rect_i(getAbsRect());
scissorRect.changeSize(-2,-2);
scissorRect.moveRel(1,1);
getGUI().pushScissor(scissorRect);
}
for(Component * c=getFirstChild();c!=nullptr;c=c->getNext()){
if (c->isEnabled() && myRegion.intersects(c->getAbsRect()))
c->display(region);
}
if(useScissor)
getGUI().popScissor();
}
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 ColorVisibilityEvaluator::measure(FrameContext & context, Node & node, const Geometry::Rect & rect) {
Rendering::RenderingContext & rCtxt = context.getRenderingContext();
// ### Set up textures for the framebuffer object. ###
const uint32_t width = static_cast<uint32_t> (rect.getWidth());
const uint32_t height = static_cast<uint32_t> (rect.getHeight());
if (colorTexture == nullptr || width != static_cast<uint32_t> (colorTexture->getWidth()) || height != static_cast<uint32_t> (colorTexture->getHeight())) {
// (Re-)Create textures with correct dimension.
rCtxt.pushAndSetFBO(fbo.get());
fbo->detachColorTexture(context.getRenderingContext());
fbo->detachDepthTexture(context.getRenderingContext());
rCtxt.popFBO();
colorTexture = Rendering::TextureUtils::createStdTexture(width, height, true);
depthTexture = Rendering::TextureUtils::createDepthTexture(width, height);
// Bind textures to FBO.
rCtxt.pushAndSetFBO(fbo.get());
fbo->attachColorTexture(context.getRenderingContext(),colorTexture.get());
fbo->attachDepthTexture(context.getRenderingContext(),depthTexture.get());
rCtxt.popFBO();
}
// ### Render the scene into a framebuffer object. ###
rCtxt.pushAndSetFBO(fbo.get());
rCtxt.pushAndSetShader(getShader());
rCtxt.clearScreen(Util::Color4f(0.0f, 0.0f, 0.0f, 0.0f));
// Color counter for assignment of unique colors to triangles.
// Background is black (color 0).
int32_t currentColor = 1;
// Collect potentially visible geometry nodes.
const auto geoNodes = collectNodesInFrustum<GeometryNode>(&node, context.getCamera()->getFrustum());
for(const auto & geoNode : geoNodes) {
getShader()->setUniform(rCtxt, Rendering::Uniform("colorOffset", currentColor));
context.displayNode(geoNode, USE_WORLD_MATRIX | NO_STATES);
currentColor += geoNode->getTriangleCount();
}
rCtxt.popShader();
rCtxt.popFBO();
// ### Read texture and analyze colors. ###
// Map from colors to number of occurrences.
std::map<uint32_t, uint32_t> colorUsage;
// Current color is compared with the previous color. If they match, the local count variable is used as cache before insertion into map is performed.
uint32_t lastColor = 0;
uint32_t lastCount = 0;
colorTexture->downloadGLTexture(rCtxt);
const uint32_t * texData = reinterpret_cast<const uint32_t *> (colorTexture->openLocalData(rCtxt));
const uint32_t numPixels = width * height;
for (uint_fast32_t p = 0; p < numPixels; ++p) {
const uint32_t & color = texData[p];
if (color == 0) {
// Ignore background.
continue;
}
if (color == lastColor) {
++lastCount;
continue;
} else {
// Insert previous color.
if (lastColor != 0) {
increaseColorUsage(lastColor, lastCount, colorUsage);
}
lastColor = color;
lastCount = 1;
}
}
if (lastColor != 0) {
increaseColorUsage(lastColor, lastCount, colorUsage);
}
if (mode == SINGLE_VALUE) {
numTrianglesVisible += colorUsage.size();
} else {
values->push_back(Util::GenericAttribute::createNumber(colorUsage.size()));
}
}
const rectf getNormalisedTextureCoords(const geometry::Rect<T>& r) {
float w = static_cast<float>(width());
float h = static_cast<float>(height());
return rectf(static_cast<float>(r.x())/w, static_cast<float>(r.y())/h, static_cast<float>(r.x2())/w, static_cast<float>(r.y2())/h);
}
const rectf getNormalisedTextureCoords(const std::vector<TexturePtr>::const_iterator& it, const geometry::Rect<T>& r) {
float w = static_cast<float>((*it)->width());
float h = static_cast<float>((*it)->height());
return rectf(static_cast<float>(r.x())/w, static_cast<float>(r.y())/h, static_cast<float>(r.x2())/w, static_cast<float>(r.y2())/h);
}
const geometry::Rect<N> getNormalisedTextureCoords(const geometry::Rect<T>& r) {
float w = static_cast<float>(surface_width_);
float h = static_cast<float>(surface_height_);
return geometry::Rect<N>(static_cast<N>(r.x())/w, static_cast<N>(r.y())/h, static_cast<N>(r.x2())/w, static_cast<N>(r.y2())/h);
}
void OverdrawFactorEvaluator::measure(FrameContext & frameContext, Node & node, const Geometry::Rect & rect) {
Rendering::RenderingContext & renderingContext = frameContext.getRenderingContext();
// Set up FBO and texture
Util::Reference<Rendering::FBO> fbo = new Rendering::FBO;
renderingContext.pushAndSetFBO(fbo.get());
Util::Reference<Rendering::Texture> depthStencilTexture = Rendering::TextureUtils::createDepthStencilTexture(rect.getWidth(), rect.getHeight());
fbo->attachDepthStencilTexture(renderingContext, depthStencilTexture.get());
// Disable color and depth writes
renderingContext.pushAndSetColorBuffer(Rendering::ColorBufferParameters(false, false, false, false));
renderingContext.pushAndSetDepthBuffer(Rendering::DepthBufferParameters(false, false, Rendering::Comparison::LESS));
// Increase the stencil value for every rendered pixel
Rendering::StencilParameters stencilParams;
stencilParams.enable();
stencilParams.setFunction(Rendering::Comparison::ALWAYS);
stencilParams.setReferenceValue(0);
stencilParams.setBitMask(0);
stencilParams.setFailAction(Rendering::StencilParameters::INCR);
stencilParams.setDepthTestFailAction(Rendering::StencilParameters::INCR);
stencilParams.setDepthTestPassAction(Rendering::StencilParameters::INCR);
renderingContext.pushAndSetStencil(stencilParams);
// Render the node
renderingContext.clearStencil(0);
frameContext.displayNode(&node, 0);
// Reset GL state
renderingContext.popStencil();
renderingContext.popDepthBuffer();
renderingContext.popColorBuffer();
// Fetch the texture.
depthStencilTexture->downloadGLTexture(renderingContext);
renderingContext.popFBO();
Util::Reference<Util::PixelAccessor> stencilAccessor = Rendering::TextureUtils::createStencilPixelAccessor(renderingContext, *depthStencilTexture.get());
std::vector<uint8_t> stencilValues;
stencilValues.reserve(rect.getWidth() * rect.getHeight());
for(uint_fast32_t y = 0; y < rect.getHeight(); ++y) {
for(uint_fast32_t x = 0; x < rect.getWidth(); ++x) {
const uint8_t stencilValue = stencilAccessor->readSingleValueByte(x, y);
stencilValues.push_back(stencilValue);
}
}
// // Create and write debug image
// {
// Util::Reference<Rendering::Texture> colorTexture = Rendering::TextureUtils::createStdTexture(rect.getWidth(), rect.getHeight(), true);
// Util::Reference<Util::PixelAccessor> colorAccessor = Rendering::TextureUtils::createColorPixelAccessor(renderingContext, colorTexture.get());
// const auto stencilMinMax = std::minmax_element(stencilValues.cbegin(), stencilValues.cend());
// const auto stencilMin = *stencilMinMax.first;
// const auto stencilMax = *stencilMinMax.second;
// const double stencilRange = stencilMax - stencilMin;
// const double factor = 1.0 / stencilRange;
// // Color scheme RdYlBu with 5 of 8 colors from www.colorbrewer2.org
// const std::array<Util::Color4f, 5> gradient = {
// Util::Color4ub(44, 123, 182, 255),
// Util::Color4ub(171, 217, 233, 255),
// Util::Color4ub(255, 255, 191, 255),
// Util::Color4ub(253, 174, 97, 255),
// Util::Color4ub(215, 25, 28, 255)
// };
// for(uint_fast32_t y = 0; y < rect.getHeight(); ++y) {
// for(uint_fast32_t x = 0; x < rect.getWidth(); ++x) {
// const uint8_t stencilValue = stencilValues[y * rect.getWidth() + x];
// if(stencilValue == 0) {
// colorAccessor->writeColor(x, y, Util::Color4f(1.0, 1.0, 1.0, 0.0));
// } else {
// const double normalizedValue = static_cast<double>(stencilValue - stencilMin) * factor;
// const double gradientPos = normalizedValue * (gradient.size() - 1);
// const size_t gradientIndex = std::floor(gradientPos);
// colorAccessor->writeColor(x, y, Util::Color4f(gradient[gradientIndex], gradient[gradientIndex + 1], gradientPos - gradientIndex));
// }
// }
// }
// Rendering::Serialization::saveTexture(renderingContext, colorTexture.get(), Util::FileName("stencil.png"));
// }
if(resultRemoveZeroValues) {
stencilValues.erase(std::remove(stencilValues.begin(), stencilValues.end(), 0),
stencilValues.end());
}
uint8_t result = 0;
if(!stencilValues.empty()) {
if(resultQuantile >= 1.0) {
result = *std::max_element(stencilValues.cbegin(), stencilValues.cend());
} else if(resultQuantile <= 0.0) {
result = *std::min_element(stencilValues.cbegin(), stencilValues.cend());
} else {
const std::size_t quantilePos = resultQuantile * stencilValues.size();
std::nth_element(stencilValues.begin(),
std::next(stencilValues.begin(), static_cast<std::ptrdiff_t>(quantilePos)),
stencilValues.end());
result = stencilValues[quantilePos];
}
}
values->push_back(Util::GenericAttribute::createNumber(result));
setMaxValue_i(result);
}