228 lines
8 KiB
C++
228 lines
8 KiB
C++
// Copyright (C) 2008 Tim Moore
|
|
//
|
|
// Much of this file was copied directly from the osgdepthpartition
|
|
// example in the OpenSceneGraph distribution, so I feel it is right
|
|
// to preserve the license in that code:
|
|
/*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
#include <osg/CullSettings>
|
|
#include <osg/Depth>
|
|
#include <osg/StateSet>
|
|
#include <osgUtil/CullVisitor>
|
|
// For DotOsgWrapperProxy
|
|
#include <osgDB/Registry>
|
|
#include <osgDB/Input>
|
|
#include <osgDB/Output>
|
|
|
|
#include <simgear/scene/util/RenderConstants.hxx>
|
|
#include "ViewPartitionNode.hxx"
|
|
|
|
using namespace osg;
|
|
|
|
const double ViewPartitionNode::nearCameraFar = 100.0;
|
|
ViewPartitionNode::ViewPartitionNode():
|
|
cameras(2), visibility(40000.0)
|
|
{
|
|
const GLbitfield inheritanceMask = (CullSettings::ALL_VARIABLES
|
|
& ~CullSettings::COMPUTE_NEAR_FAR_MODE
|
|
& ~CullSettings::NEAR_FAR_RATIO
|
|
& ~CullSettings::CULLING_MODE);
|
|
int i = 1;
|
|
for (CameraList::iterator iter = cameras.begin();
|
|
iter != cameras.end();
|
|
++iter, ++i) {
|
|
Camera* camera = new Camera;
|
|
camera->setReferenceFrame(Transform::RELATIVE_RF);
|
|
camera->setInheritanceMask(inheritanceMask);
|
|
camera->setComputeNearFarMode(CullSettings::DO_NOT_COMPUTE_NEAR_FAR);
|
|
camera->setCullingMode(CullSettings::VIEW_FRUSTUM_CULLING);
|
|
camera->setRenderOrder(Camera::POST_RENDER, i);
|
|
// Slave camera "above" us clears the viewport. Perhaps the
|
|
// far camera doesn't need to clear the depth buffer; it
|
|
// probably doesn't make much difference.
|
|
camera->setClearMask(GL_DEPTH_BUFFER_BIT);
|
|
*iter = camera;
|
|
}
|
|
}
|
|
|
|
ViewPartitionNode::ViewPartitionNode(const ViewPartitionNode& rhs,
|
|
const CopyOp& copyop) :
|
|
cameras(2), visibility(rhs.visibility)
|
|
{
|
|
for (int i = 0; i < 2; i++)
|
|
cameras[i] = static_cast<Camera*>(copyop(rhs.cameras[i].get()));
|
|
}
|
|
|
|
void ViewPartitionNode::traverse(NodeVisitor& nv)
|
|
{
|
|
osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>(&nv);
|
|
if(!cv) {
|
|
Group::traverse(nv);
|
|
return;
|
|
}
|
|
RefMatrix& modelview = *(cv->getModelViewMatrix());
|
|
RefMatrix& projection = *(cv->getProjectionMatrix());
|
|
// Get the frustum of the enclosing camera. The ViewPartitionNode
|
|
// will divide up the frustum between that camera's near and far
|
|
// planes i.e., parentNear and ParentFar.
|
|
double left, right, bottom, top, parentNear, parentFar;
|
|
projection.getFrustum(left, right, bottom, top, parentNear, parentFar);
|
|
double nearPlanes[2], farPlanes[2];
|
|
nearPlanes[0] = nearCameraFar;
|
|
farPlanes[0] = parentFar;
|
|
nearPlanes[1] = parentNear;
|
|
farPlanes[1] = nearCameraFar;
|
|
for (int i = 0; i < 2; ++i) {
|
|
if (farPlanes[i] >0.0) {
|
|
ref_ptr<RefMatrix> newProj = new RefMatrix();
|
|
makeNewProjMat(projection, nearPlanes[i], farPlanes[i],
|
|
*newProj.get());
|
|
cv->pushProjectionMatrix(newProj.get());
|
|
if (i == NEAR_CAMERA) {
|
|
// The near camera shouldn't draw the background,
|
|
// which is hard to cull out.
|
|
unsigned int savedTraversalMask = cv->getTraversalMask();
|
|
cv->setTraversalMask(savedTraversalMask
|
|
& ~simgear::BACKGROUND_BIT);
|
|
cameras[i]->accept(nv);
|
|
cv->setTraversalMask(savedTraversalMask);
|
|
} else {
|
|
cameras[i]->accept(nv);
|
|
}
|
|
cv->popProjectionMatrix();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool ViewPartitionNode::addChild(osg::Node *child)
|
|
{
|
|
return insertChild(_children.size(), child);
|
|
}
|
|
|
|
bool ViewPartitionNode::insertChild(unsigned int index, osg::Node *child)
|
|
{
|
|
if(!Group::insertChild(index, child))
|
|
return false;
|
|
// Insert child into each Camera
|
|
|
|
for (CameraList::iterator iter = cameras.begin();
|
|
iter != cameras.end();
|
|
++iter) {
|
|
(*iter)->insertChild(index, child);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool ViewPartitionNode::removeChildren(unsigned int pos, unsigned int numRemove)
|
|
{
|
|
if (!Group::removeChildren(pos, numRemove))
|
|
return false;
|
|
|
|
// Remove child from each Camera
|
|
|
|
for (CameraList::iterator iter = cameras.begin();
|
|
iter != cameras.end();
|
|
++iter) {
|
|
(*iter)->removeChildren(pos, numRemove);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool ViewPartitionNode::setChild(unsigned int i, osg::Node *node)
|
|
{
|
|
if(!Group::setChild(i, node)) return false; // Set child
|
|
|
|
// Set child for each Camera
|
|
for (CameraList::iterator iter = cameras.begin();
|
|
iter != cameras.end();
|
|
++iter) {
|
|
(*iter)->setChild(i, node);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Given a projection matrix, return a new one with the same frustum
|
|
// sides and new near / far values.
|
|
|
|
void ViewPartitionNode::makeNewProjMat(Matrixd& oldProj, double znear,
|
|
double zfar, Matrixd& projection)
|
|
{
|
|
projection = oldProj;
|
|
// Slightly inflate the near & far planes to avoid objects at the
|
|
// extremes being clipped out.
|
|
znear *= 0.999;
|
|
zfar *= 1.001;
|
|
|
|
// Clamp the projection matrix z values to the range (near, far)
|
|
double epsilon = 1.0e-6;
|
|
if (fabs(projection(0,3)) < epsilon &&
|
|
fabs(projection(1,3)) < epsilon &&
|
|
fabs(projection(2,3)) < epsilon) {
|
|
// Projection is Orthographic
|
|
epsilon = -1.0/(zfar - znear); // Used as a temp variable
|
|
projection(2,2) = 2.0*epsilon;
|
|
projection(3,2) = (zfar + znear)*epsilon;
|
|
} else {
|
|
// Projection is Perspective
|
|
double trans_near = (-znear*projection(2,2) + projection(3,2)) /
|
|
(-znear*projection(2,3) + projection(3,3));
|
|
double trans_far = (-zfar*projection(2,2) + projection(3,2)) /
|
|
(-zfar*projection(2,3) + projection(3,3));
|
|
double ratio = fabs(2.0/(trans_near - trans_far));
|
|
double center = -0.5*(trans_near + trans_far);
|
|
|
|
projection.postMult(osg::Matrixd(1.0, 0.0, 0.0, 0.0,
|
|
0.0, 1.0, 0.0, 0.0,
|
|
0.0, 0.0, ratio, 0.0,
|
|
0.0, 0.0, center*ratio, 1.0));
|
|
}
|
|
}
|
|
|
|
namespace
|
|
{
|
|
bool ViewPartitionNode_readLocalData(osg::Object& obj, osgDB::Input& fr)
|
|
{
|
|
ViewPartitionNode& node = static_cast<ViewPartitionNode&>(obj);
|
|
if (fr[0].matchWord("visibility")) {
|
|
++fr;
|
|
double visibility;
|
|
if (fr[0].getFloat(visibility))
|
|
++fr;
|
|
else
|
|
return false;
|
|
node.setVisibility(visibility);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool ViewPartitionNode_writeLocalData(const Object& obj, osgDB::Output& fw)
|
|
{
|
|
const ViewPartitionNode& node = static_cast<const ViewPartitionNode&>(obj);
|
|
fw.indent() << "visibility " << node.getVisibility() << std::endl;
|
|
return true;
|
|
}
|
|
|
|
osgDB::RegisterDotOsgWrapperProxy viewPartitionNodeProxy
|
|
(
|
|
new ViewPartitionNode,
|
|
"ViewPartitionNode",
|
|
"Object Node ViewPartitionNode Group",
|
|
&ViewPartitionNode_readLocalData,
|
|
&ViewPartitionNode_writeLocalData
|
|
);
|
|
}
|