luanti-org/irrlicht-archive
Archived
1
0
Fork 0
Code Activity

Add more transparent node sorting algorithms

Browse Source 
Adding 2 algorithms to sort by distance to camera plane instead of camera position.
This is better in quite a few situations and extra cost is just one vector subtraction per node and an additional function parameter per call, I think that's worth it. So made the camera-plane to object-center now the new default.

git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@6573 dfc29bdd-3216-0410-991c-e03cc46cb475
This commit is contained in:
cutealien
2023-11-22 16:34:55 +00:00
parent 3c4ac201ce
commit 3752bd9bd4
4 changed files with 63 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
changes.txt
View File

@@ -1,7 +1,7 @@
--------------------------
Changes in 1.9 (not yet released)
- Add options for transparency node sorting algorithm
- Add options for transparency node sorting algorithm.
- CImageWriterPNG now also supports the writeImageToFile param to allow setting compressing level. 0 stays default, 1-10 for range increasing compression level.
- Add io::IUserData which can be set in SMaterial to make it easer passing additional material values to shaders
- Add lens shift support for the camera and the perspective projection functions

12
include/ISceneManager.h
View File

@@ -111,18 +111,24 @@ namespace scene
//! Which can be used to do some custom sorting via scene-graph (mainly useful if you only have to that once)
ETNS_NONE,
//! Distance from node origin to camera
//! Distance from node origin to camera position
ETNS_ORIGIN,
//! Distance from node center to camera
//! Distance from node center to camera position
ETNS_CENTER,
//! Distance from the nearest of the 2 transformed bounding-box extend corners to camera
ETNS_BBOX_EXTENTS,
//! Distance from node origin to camera plane
ETNS_PLANE_ORIGIN,
//! Distance from node center to camera plane
ETNS_PLANE_CENTER,
//! Default sorting Irrlicht uses currently
//! This may change in the future
ETNS_DEFAULT = ETNS_CENTER
ETNS_DEFAULT = ETNS_PLANE_CENTER
};
class IAnimatedMesh;

65
source/Irrlicht/CSceneManager.cpp
View File

@@ -1364,14 +1364,14 @@ u32 CSceneManager::registerNodeForRendering(ISceneNode* node, E_SCENE_NODE_RENDE
case ESNRP_TRANSPARENT:
if (!isCulled(node))
{
TransparentNodeList.push_back(TransparentNodeEntry(node, funcTransparentNodeDistance(node, camWorldPos)));
TransparentNodeList.push_back(TransparentNodeEntry(node, funcTransparentNodeDistance(node, CamWorldPos, CamWorldViewNormalized)));
taken = 1;
}
break;
case ESNRP_TRANSPARENT_EFFECT:
if (!isCulled(node))
{
TransparentEffectNodeList.push_back(TransparentNodeEntry(node, funcTransparentNodeDistance(node, camWorldPos)));
TransparentEffectNodeList.push_back(TransparentNodeEntry(node, funcTransparentNodeDistance(node, CamWorldPos, CamWorldViewNormalized)));
taken = 1;
}
break;
@@ -1386,7 +1386,7 @@ u32 CSceneManager::registerNodeForRendering(ISceneNode* node, E_SCENE_NODE_RENDE
if (Driver->needsTransparentRenderPass(node->getMaterial(i)))
{
// register as transparent node
TransparentNodeEntry e(node, funcTransparentNodeDistance(node, camWorldPos));
TransparentNodeEntry e(node, funcTransparentNodeDistance(node, CamWorldPos, CamWorldViewNormalized));
TransparentNodeList.push_back(e);
taken = 1;
break;
@@ -1486,11 +1486,17 @@ void CSceneManager::drawAll()
consistent Camera is needed for culling
*/
IRR_PROFILE(getProfiler().start(EPID_SM_RENDER_CAMERAS));
camWorldPos.set(0,0,0);
if (ActiveCamera)
{
ActiveCamera->render();
camWorldPos = ActiveCamera->getAbsolutePosition();
CamWorldPos = ActiveCamera->getAbsolutePosition();
CamWorldViewNormalized = ActiveCamera->getTarget() - ActiveCamera->getAbsolutePosition();
CamWorldViewNormalized.normalize();
}
else
{
CamWorldPos.set(0,0,0);
CamWorldViewNormalized.set(0,0,1);
}
IRR_PROFILE(getProfiler().stop(EPID_SM_RENDER_CAMERAS));
@@ -2196,44 +2202,59 @@ E_SCENE_NODE_RENDER_PASS CSceneManager::getSceneNodeRenderPass() const
}
// Not sorting this later
static f32 transparentSortingNone(const ISceneNode* node, const core::vector3df& camera)
static f32 transparentSortingNone(const ISceneNode*, const core::vector3df&, const core::vector3df&)
{
return 0.f;
}
// Distance from node origin to camera
static f32 transparentSortingByOrigin(const ISceneNode* node, const core::vector3df& camera)
// Distance from node origin to camera pos
static f32 transparentSortingByOrigin(const ISceneNode* node, const core::vector3df& cameraPos, const core::vector3df&)
{
return node->getAbsolutePosition().getDistanceFromSQ(camera);
return node->getAbsolutePosition().getDistanceFromSQ(cameraPos);
}
// Distance from node center to camera
static f32 transparentSortingByCenter(const ISceneNode* node, const core::vector3df& camera)
// Distance from node center to camera pos
static f32 transparentSortingByCenter(const ISceneNode* node, const core::vector3df& cameraPos, const core::vector3df&)
{
core::vector3df center = node->getBoundingBox().getCenter();
const core::matrix4& absMat = node->getAbsoluteTransformation();
absMat.rotateVect(center);
return (absMat.getTranslation()+center).getDistanceFromSQ(camera);
return (absMat.getTranslation()+center).getDistanceFromSQ(cameraPos);
}
// Distance from node origin to camera plane
static f32 transparentSortingByPlaneOrigin(const ISceneNode* node, const core::vector3df& cameraPos, const core::vector3df& cameraViewN)
{
return cameraViewN.dotProduct(node->getAbsolutePosition()-cameraPos);
}
// Distance from node center to camera plane
static f32 transparentSortingByPlaneCenter(const ISceneNode* node, const core::vector3df& cameraPos, const core::vector3df& cameraViewN)
{
core::vector3df center = node->getBoundingBox().getCenter();
const core::matrix4& absMat = node->getAbsoluteTransformation();
absMat.rotateVect(center);
return cameraViewN.dotProduct(absMat.getTranslation()+center-cameraPos);
}
/*
const core::aabbox3d<f32> box = Node->getTransformedBoundingBox();
Distance = core::min_(camera.getDistanceFromSQ(box.MinEdge), camera.getDistanceFromSQ(box.MaxEdge));
*/
static f32 transparentSortingBBoxExtents(const ISceneNode* node, const core::vector3df& camera)
static f32 transparentSortingBBoxExtents(const ISceneNode* node, const core::vector3df& cameraPos, const core::vector3df&)
{
const core::aabbox3d<f32>& box = node->getBoundingBox();
const f32* m = node->getAbsoluteTransformation().pointer();
f32 p[4];
p[0] = camera.X - (box.MinEdge.X * m[0] + box.MinEdge.Y * m[4] + box.MinEdge.Z * m[8] + m[12]);
p[1] = camera.Y - (box.MinEdge.X * m[1] + box.MinEdge.Y * m[5] + box.MinEdge.Z * m[9] + m[13]);
p[2] = camera.Z - (box.MinEdge.X * m[2] + box.MinEdge.Y * m[6] + box.MinEdge.Z * m[10] + m[14]);
p[0] = cameraPos.X - (box.MinEdge.X * m[0] + box.MinEdge.Y * m[4] + box.MinEdge.Z * m[8] + m[12]);
p[1] = cameraPos.Y - (box.MinEdge.X * m[1] + box.MinEdge.Y * m[5] + box.MinEdge.Z * m[9] + m[13]);
p[2] = cameraPos.Z - (box.MinEdge.X * m[2] + box.MinEdge.Y * m[6] + box.MinEdge.Z * m[10] + m[14]);
f32 l0 = (p[0] * p[0]) + (p[1] * p[1]) + (p[2] * p[2]);
p[0] = camera.X - (box.MaxEdge.X * m[0] + box.MaxEdge.Y * m[4] + box.MaxEdge.Z * m[8] + m[12]);
p[1] = camera.Y - (box.MaxEdge.X * m[1] + box.MaxEdge.Y * m[5] + box.MaxEdge.Z * m[9] + m[13]);
p[2] = camera.Z - (box.MaxEdge.X * m[2] + box.MaxEdge.Y * m[6] + box.MaxEdge.Z * m[10] + m[14]);
p[0] = cameraPos.X - (box.MaxEdge.X * m[0] + box.MaxEdge.Y * m[4] + box.MaxEdge.Z * m[8] + m[12]);
p[1] = cameraPos.Y - (box.MaxEdge.X * m[1] + box.MaxEdge.Y * m[5] + box.MaxEdge.Z * m[9] + m[13]);
p[2] = cameraPos.Z - (box.MaxEdge.X * m[2] + box.MaxEdge.Y * m[6] + box.MaxEdge.Z * m[10] + m[14]);
f32 l1 = (p[0] * p[0]) + (p[1] * p[1]) + (p[2] * p[2]);
return core::min_(l0, l1);
}
@@ -2255,6 +2276,12 @@ void CSceneManager::setTransparentNodeSorting(E_TRANSPARENT_NODE_SORTING sorting
case ETNS_BBOX_EXTENTS:
funcTransparentNodeDistance = transparentSortingBBoxExtents;
break;
case ETNS_PLANE_ORIGIN:
funcTransparentNodeDistance = transparentSortingByPlaneOrigin;
break;
case ETNS_PLANE_CENTER:
funcTransparentNodeDistance = transparentSortingByPlaneCenter;
break;
default:
break;
}

6
source/Irrlicht/CSceneManager.h
View File

@@ -654,7 +654,8 @@ namespace scene
//! current active camera
ICameraSceneNode* ActiveCamera;
core::vector3df camWorldPos; // Position of camera for transparent nodes.
core::vector3df CamWorldPos; // Position of camera for transparent nodes.
core::vector3df CamWorldViewNormalized; // Normalized view direction of camera for transparent nodes.
video::SColor ShadowColor;
video::SColorf AmbientLight;
@@ -671,8 +672,7 @@ namespace scene
//! Algorithm used to sort transparent nodes
E_TRANSPARENT_NODE_SORTING TransparentNodeSorting;
//! Pointer to the actual algorithm to get the distance
// (Could be we have to pass more parameters for better results, like view normal)
f32 (*funcTransparentNodeDistance)(const ISceneNode* node, const core::vector3df& camera);
f32 (*funcTransparentNodeDistance)(const ISceneNode* node, const core::vector3df& cameraPos, const core::vector3df& cameraViewNormalized);
//! An optional callbacks manager to allow the user app finer control
//! over the scene lighting and rendering.