void CameraController::frame( const Imath::Box3f &box, const Imath::V3f &viewDirection, const Imath::V3f &upVector )
{
// make a matrix to centre the camera on the box, with the appropriate view direction
M44f cameraMatrix = rotationMatrixWithUpDir( V3f( 0, 0, -1 ), viewDirection, upVector );
M44f translationMatrix;
translationMatrix.translate( box.center() );
cameraMatrix *= translationMatrix;
// translate the camera back until the box is completely visible
M44f inverseCameraMatrix = cameraMatrix.inverse();
Box3f cBox = transform( box, inverseCameraMatrix );
Box2f screenWindow = m_data->screenWindow->readable();
if( m_data->projection->readable()=="perspective" )
{
// perspective. leave the field of view and screen window as is and translate
// back till the box is wholly visible. this currently assumes the screen window
// is centred about the camera axis.
float z0 = cBox.size().x / screenWindow.size().x;
float z1 = cBox.size().y / screenWindow.size().y;
m_data->centreOfInterest = std::max( z0, z1 ) / tan( M_PI * m_data->fov->readable() / 360.0 ) + cBox.max.z +
m_data->clippingPlanes->readable()[0];
cameraMatrix.translate( V3f( 0.0f, 0.0f, m_data->centreOfInterest ) );
}
else
{
// orthographic. translate to front of box and set screen window
// to frame the box, maintaining the aspect ratio of the screen window.
m_data->centreOfInterest = cBox.max.z + m_data->clippingPlanes->readable()[0] + 0.1; // 0.1 is a fudge factor
cameraMatrix.translate( V3f( 0.0f, 0.0f, m_data->centreOfInterest ) );
float xScale = cBox.size().x / screenWindow.size().x;
float yScale = cBox.size().y / screenWindow.size().y;
float scale = std::max( xScale, yScale );
V2f newSize = screenWindow.size() * scale;
screenWindow.min.x = cBox.center().x - newSize.x / 2.0f;
screenWindow.min.y = cBox.center().y - newSize.y / 2.0f;
screenWindow.max.x = cBox.center().x + newSize.x / 2.0f;
screenWindow.max.y = cBox.center().y + newSize.y / 2.0f;
}
m_data->transform->matrix = cameraMatrix;
m_data->screenWindow->writable() = screenWindow;
}
IECore::ConstObjectPtr MapProjection::computeProcessedObject( const ScenePath &path, const Gaffer::Context *context, IECore::ConstObjectPtr inputObject ) const
{
// early out if it's not a primitive with a "P" variable
const Primitive *inputPrimitive = runTimeCast<const Primitive>( inputObject.get() );
if( !inputPrimitive )
{
return inputObject;
}
const V3fVectorData *pData = inputPrimitive->variableData<V3fVectorData>( "P" );
if( !pData )
{
return inputObject;
}
// early out if the uv set name hasn't been provided
const string uvSet = uvSetPlug()->getValue();
if( uvSet == "" )
{
return inputObject;
}
// get the camera and early out if we can't find one
ScenePath cameraPath;
ScenePlug::stringToPath( cameraPlug()->getValue(), cameraPath );
ConstCameraPtr constCamera = runTimeCast<const Camera>( inPlug()->object( cameraPath ) );
if( !constCamera )
{
return inputObject;
}
M44f cameraMatrix = inPlug()->fullTransform( cameraPath );
M44f objectMatrix = inPlug()->fullTransform( path );
M44f objectToCamera = objectMatrix * cameraMatrix.inverse();
bool perspective = constCamera->getProjection() == "perspective";
Box2f normalizedScreenWindow;
if( constCamera->hasResolution() )
{
normalizedScreenWindow = constCamera->frustum();
}
else
{
// We don't know what resolution the camera is meant to render with, so take the whole aperture
// as the screen window
normalizedScreenWindow = constCamera->frustum( Camera::Distort );
}
// do the work
PrimitivePtr result = inputPrimitive->copy();
V2fVectorDataPtr uvData = new V2fVectorData();
uvData->setInterpretation( GeometricData::UV );
result->variables[uvSet] = PrimitiveVariable( PrimitiveVariable::Vertex, uvData );
const vector<V3f> &p = pData->readable();
vector<V2f> &uv = uvData->writable();
uv.reserve( p.size() );
for( size_t i = 0, e = p.size(); i < e; ++i )
{
V3f pCamera = p[i] * objectToCamera;
V2f pScreen = V2f( pCamera.x, pCamera.y );
if( perspective )
{
pScreen /= -pCamera.z;
}
uv.push_back(
V2f(
lerpfactor( pScreen.x, normalizedScreenWindow.min.x, normalizedScreenWindow.max.x ),
lerpfactor( pScreen.y, normalizedScreenWindow.min.y, normalizedScreenWindow.max.y )
)
);
}
return result;
}
void CameraTool::viewportCameraChanged()
{
const TransformTool::Selection &selection = cameraSelection();
if( !selection.transformPlug )
{
return;
}
if( !view()->viewportGadget()->getCameraEditable() )
{
return;
}
// Figure out the offset from where the camera is in the scene
// to where the user has just moved the viewport camera.
const M44f viewportCameraTransform = view()->viewportGadget()->getCameraTransform();
M44f cameraTransform;
{
Context::Scope scopedContext( selection.context.get() );
cameraTransform = selection.scene->fullTransform( selection.path );
}
if( cameraTransform == viewportCameraTransform )
{
return;
}
const M44f offset = cameraTransform.inverse() * viewportCameraTransform;
// This offset is measured in the downstream world space.
// Transform it into the space the transform is applied in.
// This requires a "change of basis" because it is a transformation
// matrix.
const M44f sceneToTransformSpace = selection.sceneToTransformSpace();
const M44f transformSpaceOffset = sceneToTransformSpace.inverse() * offset * sceneToTransformSpace;
// Now apply this offset to the current value on the transform plug.
M44f plugTransform;
{
Context::Scope scopedContext( selection.upstreamContext.get() );
plugTransform = selection.transformPlug->matrix();
}
plugTransform = plugTransform * transformSpaceOffset;
const V3f t = plugTransform.translation();
Eulerf e; e.extract( plugTransform );
e.makeNear( degreesToRadians( selection.transformPlug->rotatePlug()->getValue() ) );
const V3f r = radiansToDegrees( V3f( e ) );
UndoScope undoScope( selection.transformPlug->ancestor<ScriptNode>(), UndoScope::Enabled, m_undoGroup );
for( int i = 0; i < 3; ++i )
{
setValueOrAddKey( selection.transformPlug->rotatePlug()->getChild( i ), selection.context->getTime(), r[i] );
setValueOrAddKey( selection.transformPlug->translatePlug()->getChild( i ), selection.context->getTime(), t[i] );
}
// Create an action to save/restore the current center of interest, so that
// when the user undos a framing action, they get back to the old center of
// interest as well as the old transform.
Action::enact(
selection.transformPlug,
// Do
boost::bind(
&CameraTool::setCameraCenterOfInterest,
CameraToolPtr( this ), selection.path,
view()->viewportGadget()->getCenterOfInterest()
),
// Undo
boost::bind(
&CameraTool::setCameraCenterOfInterest,
CameraToolPtr( this ), selection.path,
getCameraCenterOfInterest( selection.path )
)
);
}
