ConstObjectPtr SOP_SceneCacheSource::transformObject( const IECore::Object *object, const Imath::M44d &transform, bool &hasAnimatedTopology, bool &hasAnimatedPrimVars, std::vector<InternedString> &animatedPrimVars )
{
if ( const Primitive *primitive = IECore::runTimeCast<const Primitive>( object ) )
{
TransformOpPtr transformer = new TransformOp();
transformer->inputParameter()->setValue( const_cast<Primitive*>( primitive ) ); // safe because we set the copy parameter
transformer->copyParameter()->setTypedValue( true );
transformer->matrixParameter()->setValue( new M44dData( transform ) );
ObjectPtr result = transformer->operate();
std::vector<std::string> &primVars = transformer->primVarsParameter()->getTypedValue();
for ( std::vector<std::string>::iterator it = primVars.begin(); it != primVars.end(); ++it )
{
if ( std::find( animatedPrimVars.begin(), animatedPrimVars.end(), *it ) == animatedPrimVars.end() )
{
animatedPrimVars.push_back( *it );
hasAnimatedPrimVars = true;
}
}
return result;
}
else if ( const Group *group = IECore::runTimeCast<const Group>( object ) )
{
GroupPtr result = group->copy();
MatrixTransformPtr matTransform = matrixTransform( transform );
matTransform->matrix *= group->getTransform()->transform();
result->setTransform( matTransform );
return result;
}
else if ( const CoordinateSystem *coord = IECore::runTimeCast<const CoordinateSystem>( object ) )
{
CoordinateSystemPtr result = coord->copy();
MatrixTransformPtr matTransform = matrixTransform( transform );
matTransform->matrix *= coord->getTransform()->transform();
result->setTransform( matTransform );
return result;
}
return object;
}
ConstObjectPtr SOP_SceneCacheSource::transformObject( const IECore::Object *object, const Imath::M44d &transform, Parameters ¶ms )
{
if ( const Primitive *primitive = IECore::runTimeCast<const Primitive>( object ) )
{
TransformOpPtr transformer = new TransformOp();
transformer->inputParameter()->setValue( const_cast<Primitive*>( primitive ) ); // safe because we set the copy parameter
transformer->copyParameter()->setTypedValue( true );
transformer->matrixParameter()->setValue( new M44dData( transform ) );
// add all Point and Normal prim vars to the transformation list, except for rest/Pref
const PrimitiveVariableMap &variables = primitive->variables;
std::vector<std::string> &primVars = transformer->primVarsParameter()->getTypedValue();
primVars.clear();
for ( PrimitiveVariableMap::const_iterator it = variables.begin(); it != variables.end(); ++it )
{
if ( despatchTypedData<TransformGeometricData, IECore::TypeTraits::IsGeometricTypedData, DespatchTypedDataIgnoreError>( it->second.data.get() ) )
{
// we don't want to alter rest/Pref because Houdini excepts these to be non-transforming prim vars
if ( it->first == "rest" || it->first == "Pref" )
{
continue;
}
primVars.push_back( it->first );
// add the transforming prim vars to the animated list
if ( std::find( params.animatedPrimVars.begin(), params.animatedPrimVars.end(), it->first ) == params.animatedPrimVars.end() )
{
params.animatedPrimVars.push_back( it->first );
params.hasAnimatedPrimVars = true;
}
}
}
return transformer->operate();
}
else if ( const Group *group = IECore::runTimeCast<const Group>( object ) )
{
GroupPtr result = group->copy();
MatrixTransformPtr matTransform = matrixTransform( transform );
if ( const Transform *transform = group->getTransform() )
{
matTransform->matrix *= transform->transform();
}
result->setTransform( matTransform );
return result;
}
else if ( const CoordinateSystem *coord = IECore::runTimeCast<const CoordinateSystem>( object ) )
{
CoordinateSystemPtr result = coord->copy();
MatrixTransformPtr matTransform = matrixTransform( transform );
if ( const Transform *transform = coord->getTransform() )
{
matTransform->matrix *= transform->transform();
}
result->setTransform( matTransform );
return result;
}
return object;
}
IECoreGL::ConstRenderablePtr StandardLightVisualiser::visualise( const IECore::InternedString &attributeName, const IECore::ObjectVector *shaderVector, IECoreGL::ConstStatePtr &state ) const
{
if( !shaderVector || shaderVector->members().size() == 0 )
{
return NULL;
}
IECore::InternedString metadataTarget;
const IECore::CompoundData *shaderParameters = NULL;
if( const IECore::Shader *shader = IECore::runTimeCast<const IECore::Shader>( shaderVector->members().back().get() ) )
{
metadataTarget = attributeName.string() + ":" + shader->getName();
shaderParameters = shader->parametersData();
}
else if( const IECore::Light *light = IECore::runTimeCast<const IECore::Light>( shaderVector->members().back().get() ) )
{
/// \todo Remove once all Light node derived classes are
/// creating only shaders.
metadataTarget = attributeName.string() + ":" + light->getName();
shaderParameters = light->parametersData().get();
}
if( !shaderParameters )
{
return NULL;
}
ConstStringDataPtr type = Metadata::value<StringData>( metadataTarget, "type" );
ConstM44fDataPtr orientation = Metadata::value<M44fData>( metadataTarget, "visualiserOrientation" );
const Color3f color = parameter<Color3f>( metadataTarget, shaderParameters, "colorParameter", Color3f( 1.0f ) );
const float intensity = parameter<float>( metadataTarget, shaderParameters, "intensityParameter", 1 );
const float exposure = parameter<float>( metadataTarget, shaderParameters, "exposureParameter", 0 );
const Color3f finalColor = color * intensity * pow( 2.0f, exposure );
if( type && type->readable() == "area" )
{
const std::string textureName = parameter<std::string>( metadataTarget, shaderParameters, "textureNameParameter", "" );
const bool flipNormal = parameter<bool>( metadataTarget, shaderParameters, "flipNormalParameter", 0 );
const bool doubleSided = parameter<bool>( metadataTarget, shaderParameters, "doubleSidedParameter", 0 );
const bool sphericalProjection = parameter<bool>( metadataTarget, shaderParameters, "sphericalProjectionParameter", 0 );
M44f projectionTransform = parameter<M44f>( metadataTarget, shaderParameters, "projectionTransformParameter", M44f() );
const std::vector<float> projectionTransformVector = parameter<std::vector<float> >( metadataTarget, shaderParameters, "projectionTransformParameter", std::vector<float>() );
if( projectionTransformVector.size() == 16 )
{
projectionTransform = M44f( (float(*)[4])(&projectionTransformVector[0]) );
}
addAreaLightVisualiser( state, finalColor, textureName, flipNormal, doubleSided,
sphericalProjection, projectionTransform );
return NULL;
}
GroupPtr result = new Group;
const float locatorScale = parameter<float>( metadataTarget, shaderParameters, "locatorScaleParameter", 1 );
Imath::M44f topTrans;
if( orientation )
{
topTrans = orientation->readable();
}
topTrans.scale( V3f( locatorScale ) );
result->setTransform( topTrans );
if( type && type->readable() == "environment" )
{
const std::string textureName = parameter<std::string>( metadataTarget, shaderParameters, "textureNameParameter", "" );
addEnvLightVisualiser( result, finalColor, textureName );
}
else
{
float coneAngle = parameter<float>( metadataTarget, shaderParameters, "coneAngleParameter", 0.0f );
float penumbraAngle = parameter<float>( metadataTarget, shaderParameters, "penumbraAngleParameter", 0.0f );
if( ConstStringDataPtr angleUnit = Metadata::value<StringData>( metadataTarget, "angleUnit" ) )
{
if( angleUnit->readable() == "radians" )
{
coneAngle *= 180.0 / M_PI;
penumbraAngle *= 180 / M_PI;
}
}
const std::string *penumbraType = NULL;
ConstStringDataPtr penumbraTypeData = Metadata::value<StringData>( metadataTarget, "penumbraType" );
if( penumbraTypeData )
{
penumbraType = &penumbraTypeData->readable();
}
float lensRadius = 0.0f;
if( parameter<bool>( metadataTarget, shaderParameters, "lensRadiusEnableParameter", true ) )
{
lensRadius = parameter<float>( metadataTarget, shaderParameters, "lensRadiusParameter", 0.0f );
}
addBasicLightVisualiser( type, result, finalColor, coneAngle, penumbraAngle, penumbraType, lensRadius / locatorScale );
}
return result;
}
