IECore::ConstObjectPtr OSLObject::computeProcessedObject( const ScenePath &path, const Gaffer::Context *context, IECore::ConstObjectPtr inputObject ) const
{
const Primitive *inputPrimitive = runTimeCast<const Primitive>( inputObject.get() );
if( !inputPrimitive )
{
return inputObject;
}
if( !inputPrimitive->variableData<V3fVectorData>( "P", PrimitiveVariable::Vertex ) )
{
return inputObject;
}
ConstOSLShaderPtr shader = runTimeCast<const OSLShader>( shaderPlug()->source<Plug>()->node() );
ConstShadingEnginePtr shadingEngine = shader ? shader->shadingEngine() : NULL;
if( !shadingEngine )
{
return inputObject;
}
CompoundDataPtr shadingPoints = new CompoundData;
for( PrimitiveVariableMap::const_iterator it = inputPrimitive->variables.begin(), eIt = inputPrimitive->variables.end(); it != eIt; ++it )
{
if( it->second.interpolation == PrimitiveVariable::Vertex )
{
// cast is ok - we're only using it to be able to reference the data from the shadingPoints,
// but nothing will modify the data itself.
shadingPoints->writable()[it->first] = boost::const_pointer_cast<Data>( it->second.data );
}
}
PrimitivePtr outputPrimitive = inputPrimitive->copy();
ShadingEngine::Transforms transforms;
transforms[ g_world ] = ShadingEngine::Transform( inPlug()->fullTransform( path ));
CompoundDataPtr shadedPoints = shadingEngine->shade( shadingPoints.get(), transforms );
for( CompoundDataMap::const_iterator it = shadedPoints->readable().begin(), eIt = shadedPoints->readable().end(); it != eIt; ++it )
{
if( it->first != "Ci" )
{
outputPrimitive->variables[it->first] = PrimitiveVariable( PrimitiveVariable::Vertex, it->second );
}
}
return outputPrimitive;
}
IECore::ConstObjectPtr OSLObject::computeProcessedObject( const ScenePath &path, const Gaffer::Context *context, IECore::ConstObjectPtr inputObject ) const
{
const Primitive *inputPrimitive = runTimeCast<const Primitive>( inputObject.get() );
if( !inputPrimitive )
{
return inputObject;
}
const OSLShader *shader = runTimeCast<const OSLShader>( shaderPlug()->source()->node() );
ConstShadingEnginePtr shadingEngine = shader ? shader->shadingEngine() : nullptr;
if( !shadingEngine )
{
return inputObject;
}
PrimitiveVariable::Interpolation interpolation = static_cast<PrimitiveVariable::Interpolation>( interpolationPlug()->getValue() );
IECoreScene::ConstPrimitivePtr resampledObject = IECore::runTimeCast<const IECoreScene::Primitive>( resampledInPlug()->objectPlug()->getValue() );
CompoundDataPtr shadingPoints = prepareShadingPoints( resampledObject.get(), shadingEngine.get() );
PrimitivePtr outputPrimitive = inputPrimitive->copy();
ShadingEngine::Transforms transforms;
transforms[ g_world ] = ShadingEngine::Transform( inPlug()->fullTransform( path ));
CompoundDataPtr shadedPoints = shadingEngine->shade( shadingPoints.get(), transforms );
for( CompoundDataMap::const_iterator it = shadedPoints->readable().begin(), eIt = shadedPoints->readable().end(); it != eIt; ++it )
{
// Ignore the output color closure as the debug closures are used to define what is 'exported' from the shader
if( it->first != "Ci" )
{
outputPrimitive->variables[it->first] = PrimitiveVariable( interpolation, it->second );
}
}
return outputPrimitive;
}
IECore::ConstObjectPtr CameraTweaks::computeProcessedObject( const ScenePath &path, const Gaffer::Context *context, IECore::ConstObjectPtr inputObject ) const
{
IECoreScene::ConstCameraPtr inputCamera = IECore::runTimeCast<const IECoreScene::Camera>( inputObject );
if( !inputCamera )
{
return inputObject;
}
const Plug *tweaksPlug = this->tweaksPlug();
if( tweaksPlug->children().empty() )
{
return inputObject;
}
IECoreScene::CameraPtr result = inputCamera->copy();
for( TweakPlugIterator tIt( tweaksPlug ); !tIt.done(); ++tIt )
{
if( !(*tIt)->enabledPlug()->getValue() )
{
continue;
}
const std::string name = (*tIt)->namePlug()->getValue();
if( name.empty() )
{
continue;
}
if( name == "fieldOfView" )
{
InternedString internedName(name);
CompoundDataPtr dummyParameters = new CompoundData();
dummyParameters->writable()[internedName] = new FloatData( result->calculateFieldOfView()[0] );
(*tIt)->applyTweak( dummyParameters.get() );
FloatData *tweakedData = dummyParameters->member<FloatData>( internedName );
if( tweakedData )
{
float fieldOfView = std::max( 0.0f, std::min( 179.99f, tweakedData->readable() ) );
result->setFocalLengthFromFieldOfView( fieldOfView );
}
}
else if( name == "apertureAspectRatio" )
{
InternedString internedName(name);
Imath::V2f aperture = result->getAperture();
CompoundDataPtr dummyParameters = new CompoundData();
dummyParameters->writable()[internedName] = new FloatData( aperture[0] / aperture[1] );
(*tIt)->applyTweak( dummyParameters.get() );
FloatData *tweakedData = dummyParameters->member<FloatData>( internedName );
if( tweakedData )
{
aperture[1] = aperture[0] / max( 0.0000001f, tweakedData->readable() );
result->setAperture( aperture );
}
}
else
{
(*tIt)->applyTweak( result->parametersData() );
}
}
return result;
}
IECore::ConstCompoundDataPtr OSLImage::computeShading( const Gaffer::Context *context ) const
{
OSLRenderer::ConstShadingEnginePtr shadingEngine;
if( const OSLShader *shader = runTimeCast<const OSLShader>( shaderPlug()->source<Plug>()->node() ) )
{
shadingEngine = shader->shadingEngine();
}
if( !shadingEngine )
{
return static_cast<const CompoundData *>( shadingPlug()->defaultValue() );
}
const V2i tileOrigin = context->get<V2i>( ImagePlug::tileOriginContextName );
const Format format = inPlug()->formatPlug()->getValue();
CompoundDataPtr shadingPoints = new CompoundData();
V3fVectorDataPtr pData = new V3fVectorData;
FloatVectorDataPtr uData = new FloatVectorData;
FloatVectorDataPtr vData = new FloatVectorData;
vector<V3f> &pWritable = pData->writable();
vector<float> &uWritable = uData->writable();
vector<float> &vWritable = vData->writable();
const size_t tileSize = ImagePlug::tileSize();
pWritable.reserve( tileSize * tileSize );
uWritable.reserve( tileSize * tileSize );
vWritable.reserve( tileSize * tileSize );
/// \todo Non-zero display window origins - do we have those?
const float uStep = 1.0f / format.width();
const float uMin = 0.5f * uStep;
const float vStep = 1.0f / format.height();
const float vMin = 0.5f * vStep;
const size_t xMax = tileOrigin.x + tileSize;
const size_t yMax = tileOrigin.y + tileSize;
for( size_t y = tileOrigin.y; y < yMax; ++y )
{
const float v = vMin + y * vStep;
for( size_t x = tileOrigin.x; x < xMax; ++x )
{
uWritable.push_back( uMin + x * uStep );
vWritable.push_back( v );
pWritable.push_back( V3f( x, y, 0.0f ) );
}
}
shadingPoints->writable()["P"] = pData;
shadingPoints->writable()["u"] = uData;
shadingPoints->writable()["v"] = vData;
ConstStringVectorDataPtr channelNamesData = inPlug()->channelNamesPlug()->getValue();
const vector<string> &channelNames = channelNamesData->readable();
for( vector<string>::const_iterator it = channelNames.begin(), eIt = channelNames.end(); it != eIt; ++it )
{
shadingPoints->writable()[*it] = boost::const_pointer_cast<FloatVectorData>( inPlug()->channelData( *it, tileOrigin ) );
}
CompoundDataPtr result = shadingEngine->shade( shadingPoints.get() );
// remove results that aren't suitable to become channels
for( CompoundDataMap::iterator it = result->writable().begin(); it != result->writable().end(); )
{
CompoundDataMap::iterator nextIt = it; nextIt++;
if( !runTimeCast<FloatVectorData>( it->second ) )
{
result->writable().erase( it );
}
it = nextIt;
}
return result;
}
// \todo This function may be useful on other situations. Add as Converter?
void ImagePlug::compoundObjectToCompoundData( const CompoundObject *object, CompoundData *data )
{
CompoundDataMap &dataMap = data->writable();
const CompoundObject::ObjectMap &objectMap = object->members();
for ( CompoundObject::ObjectMap::const_iterator it = objectMap.begin(); it != objectMap.end(); ++it )
{
if ( it->second->typeId() == CompoundObjectTypeId )
{
CompoundDataPtr newData = new CompoundData();
dataMap[ it->first ] = newData;
compoundObjectToCompoundData( static_cast<const CompoundObject *>( it->second.get() ), newData.get() );
}
else if ( Data *value = IECore::runTimeCast<Data>( it->second.get() ) )
{
dataMap[ it->first ] = value;
}
}
}
void LinkedScene::writeLink( const SceneInterface *scene )
{
CompoundDataPtr d = linkAttributeData( scene );
writeAttribute( linkAttribute, d.get(), 0 );
}