RenderItem::~RenderItem() = default;
-ClippingBox RenderItem::CalculateViewportSpaceAABB(const Vector3& size, const int viewportWidth, const int viewportHeight) const
+ClippingBox RenderItem::CalculateViewportSpaceAABB(const Matrix& modelViewMatrix, const Vector3& size, const int viewportWidth, const int viewportHeight)
{
// Calculate extent vector of the AABB:
const float halfActorX = size.x * 0.5f;
// We place the coords into the array in clockwise order, so we know opposite corners are always i + 2 from corner i.
// We skip the 4th corner here as we can calculate that from the other 3, bypassing matrix multiplication.
// Note: The below transform methods use a fast (2D) matrix multiply (only 4 multiplications are done).
- Vector2 corners[4]{Transform2D(mModelViewMatrix, -halfActorX, -halfActorY),
- Transform2D(mModelViewMatrix, halfActorX, -halfActorY),
- Transform2D(mModelViewMatrix, halfActorX, halfActorY)};
+ Vector2 corners[4]{Transform2D(modelViewMatrix, -halfActorX, -halfActorY),
+ Transform2D(modelViewMatrix, halfActorX, -halfActorY),
+ Transform2D(modelViewMatrix, halfActorX, halfActorY)};
// As we are dealing with a rectangle, we can do a fast calculation to get the 4th corner from knowing the other 3 (even if rotated).
corners[3] = Vector2(corners[0] + (corners[2] - corners[1]));
}
/**
+ * Set the update size of the node
+ * @param[in] node The node of the renderer
+ * @param[in] isLayer3d Whether we are processing a 3D layer or not
+ * @param[in,out] nodeWorldMatrix The world matrix of the node
+ * @param[in,out] nodeSize The size of the node
+ * @param[in,out] nodeUpdateSize The update size of the node
+ */
+inline void SetNodeUpdateSize(Node* node, bool isLayer3d, Matrix& nodeWorldMatrix, Vector3& nodeSize, Vector3& nodeUpdateSize)
+{
+ node->GetWorldMatrixAndSize(nodeWorldMatrix, nodeSize);
+
+ if(node->GetUpdateSizeHint() == Vector3::ZERO)
+ {
+ // RenderItem::CalculateViewportSpaceAABB cannot cope with z transform
+ // I don't use item.mModelMatrix.GetTransformComponents() for z transform, would be too slow
+ if(!isLayer3d && nodeWorldMatrix.GetZAxis() == Vector3(0.0f, 0.0f, 1.0f))
+ {
+ nodeUpdateSize = nodeSize;
+ }
+ }
+ else
+ {
+ nodeUpdateSize = node->GetUpdateSizeHint();
+ }
+}
+
+/**
* Add a renderer to the list
* @param updateBufferIndex to read the model matrix from
* @param renderList to add the item to
* @param viewMatrix used to calculate modelview matrix for the item
* @param camera The camera used to render
* @param isLayer3d Whether we are processing a 3D layer or not
+ * @param viewportSet Whether the viewport is set or not
+ * @param viewport The viewport
* @param cull Whether frustum culling is enabled or not
*/
inline void AddRendererToRenderList(BufferIndex updateBufferIndex,
const Matrix& viewMatrix,
SceneGraph::Camera& camera,
bool isLayer3d,
+ bool viewportSet,
+ const Viewport& viewport,
bool cull)
{
- bool inside(true);
- Node* node = renderable.mNode;
+ bool inside(true);
+ Node* node = renderable.mNode;
+ Matrix nodeWorldMatrix(false);
+ Vector3 nodeSize;
+ Vector3 nodeUpdateSize;
+ bool nodeUpdateSizeSet(false);
+ Matrix nodeModelViewMatrix(false);
+ bool nodeModelViewMatrixSet(false);
if(cull && renderable.mRenderer && !renderable.mRenderer->GetShader().HintEnabled(Dali::Shader::Hint::MODIFIES_GEOMETRY))
{
const Vector4& boundingSphere = node->GetBoundingSphere();
inside = (boundingSphere.w > Math::MACHINE_EPSILON_1000) &&
(camera.CheckSphereInFrustum(updateBufferIndex, Vector3(boundingSphere), boundingSphere.w));
+
+ if(inside && !isLayer3d && viewportSet)
+ {
+ SetNodeUpdateSize(node, isLayer3d, nodeWorldMatrix, nodeSize, nodeUpdateSize);
+ nodeUpdateSizeSet = true;
+
+ const Vector3& scale = node->GetWorldScale(updateBufferIndex);
+ const Vector3& halfSize = nodeUpdateSize * scale * 0.5f;
+ float radius(halfSize.Length());
+
+ if(radius > Math::MACHINE_EPSILON_1000)
+ {
+ Matrix::Multiply(nodeModelViewMatrix, nodeWorldMatrix, viewMatrix);
+ nodeModelViewMatrixSet = true;
+
+ ClippingBox clippingBox = RenderItem::CalculateViewportSpaceAABB(nodeModelViewMatrix, nodeUpdateSize, viewport.width, viewport.height);
+ inside = clippingBox.Intersects(viewport);
+ }
+ }
}
if(inside)
{
- Renderer::OpacityType opacityType = renderable.mRenderer ? renderable.mRenderer->GetOpacityType(updateBufferIndex, *renderable.mNode) : Renderer::OPAQUE;
+ Renderer::OpacityType opacityType = renderable.mRenderer ? renderable.mRenderer->GetOpacityType(updateBufferIndex, *node) : Renderer::OPAQUE;
// We can skip render when node is not clipping and transparent
const bool skipRender(opacityType == Renderer::TRANSPARENT && node->GetClippingMode() == ClippingMode::DISABLED);
partialRenderingCacheInfo.node = node;
partialRenderingCacheInfo.isOpaque = (opacityType == Renderer::OPAQUE);
partialRenderingCacheInfo.renderer = renderable.mRenderer;
- partialRenderingCacheInfo.color = renderable.mNode->GetColor(updateBufferIndex);
- partialRenderingCacheInfo.depthIndex = renderable.mNode->GetDepthIndex();
+ partialRenderingCacheInfo.color = node->GetColor(updateBufferIndex);
+ partialRenderingCacheInfo.depthIndex = node->GetDepthIndex();
if(renderable.mRenderer)
{
partialRenderingCacheInfo.textureSet = renderable.mRenderer->GetTextureSet();
}
- item.mNode = renderable.mNode;
+ item.mNode = node;
item.mIsOpaque = (opacityType == Renderer::OPAQUE);
- item.mColor = renderable.mNode->GetColor(updateBufferIndex);
+ item.mColor = node->GetColor(updateBufferIndex);
item.mDepthIndex = 0;
if(!isLayer3d)
{
- item.mDepthIndex = renderable.mNode->GetDepthIndex();
+ item.mDepthIndex = node->GetDepthIndex();
}
if(DALI_LIKELY(renderable.mRenderer))
item.mIsUpdated |= isLayer3d;
- // Save ModelView matrix onto the item.
- node->GetWorldMatrixAndSize(item.mModelMatrix, item.mSize);
- Matrix::Multiply(item.mModelViewMatrix, item.mModelMatrix, viewMatrix);
-
- partialRenderingCacheInfo.matrix = item.mModelViewMatrix;
- partialRenderingCacheInfo.size = item.mSize;
-
- if(renderable.mNode->GetUpdateSizeHint() == Vector3::ZERO)
+ if(!nodeUpdateSizeSet)
{
- // RenderItem::CalculateViewportSpaceAABB cannot cope with z transform
- // I don't use item.mModelMatrix.GetTransformComponents() for z transform, would be to slow
- if(!isLayer3d && item.mModelMatrix.GetZAxis() == Vector3(0.0f, 0.0f, 1.0f))
- {
- item.mUpdateSize = item.mSize;
- }
+ SetNodeUpdateSize(node, isLayer3d, nodeWorldMatrix, nodeSize, nodeUpdateSize);
}
- else
+
+ item.mSize = nodeSize;
+ item.mUpdateSize = nodeUpdateSize;
+ item.mModelMatrix = nodeWorldMatrix;
+
+ if(!nodeModelViewMatrixSet)
{
- item.mUpdateSize = renderable.mNode->GetUpdateSizeHint();
+ Matrix::Multiply(nodeModelViewMatrix, nodeWorldMatrix, viewMatrix);
}
+ item.mModelViewMatrix = nodeModelViewMatrix;
+ partialRenderingCacheInfo.matrix = item.mModelViewMatrix;
+ partialRenderingCacheInfo.size = item.mSize;
partialRenderingCacheInfo.updatedSize = item.mUpdateSize;
item.mIsUpdated = partialRenderingData.IsUpdated() || item.mIsUpdated;
const Matrix& viewMatrix,
SceneGraph::Camera& camera,
bool isLayer3d,
+ bool viewportSet,
+ const Viewport& viewport,
bool cull)
{
DALI_LOG_INFO(gRenderListLogFilter, Debug::Verbose, "AddRenderersToRenderList()\n");
viewMatrix,
camera,
isLayer3d,
+ viewportSet,
+ viewport,
cull);
}
}
const Matrix& viewMatrix = renderTask.GetViewMatrix(updateBufferIndex);
SceneGraph::Camera& camera = renderTask.GetCamera();
+ Viewport viewport;
+ bool viewportSet = renderTask.QueryViewport(updateBufferIndex, viewport);
+
const SortedLayersIter endIter = sortedLayers.end();
for(SortedLayersIter iter = sortedLayers.begin(); iter != endIter; ++iter)
{
viewMatrix,
camera,
isLayer3D,
+ viewportSet,
+ viewport,
cull);
// We only use the clipping version of the sort comparitor if any clipping nodes exist within the RenderList.
viewMatrix,
camera,
isLayer3D,
+ viewportSet,
+ viewport,
cull);
// Clipping hierarchy is irrelevant when sorting overlay items, so we specify using the non-clipping version of the sort comparitor.
projects / platform / core / uifw / dali-core.git / commitdiff