// we first define an assembly which contains the world assembly. This "uberMaster" contains the global transformation.
void defineMasterAssembly(renderer::Project* project)
{
MMatrix conversionMatrix;
conversionMatrix.setToIdentity();
World* world = getWorldPtr();
if (world != 0)
{
RenderGlobals* rg = world->mRenderGlobals.get();
if (rg != 0)
conversionMatrix = rg->globalConversionMatrix;
}
if (getSceneFromProject(project)->assemblies().get_by_name("world") == 0)
{
foundation::auto_release_ptr<renderer::Assembly> assembly(renderer::AssemblyFactory().create("world", renderer::ParamArray()));
getSceneFromProject(project)->assemblies().insert(assembly);
foundation::Matrix4d appMatrix;
MMatrix transformMatrix;
transformMatrix.setToIdentity();
transformMatrix *= conversionMatrix;
foundation::auto_release_ptr<renderer::AssemblyInstance> assemblyInstance = renderer::AssemblyInstanceFactory::create("world_Inst", renderer::ParamArray(), "world");
MMatrixToAMatrix(transformMatrix, appMatrix);
assemblyInstance->transform_sequence().set_transform(0.0, foundation::Transformd::from_local_to_parent(appMatrix));
getSceneFromProject(project)->assembly_instances().insert(assemblyInstance);
}
}
void fillMatrices(const MayaObject* obj, renderer::TransformSequence& transformSequence)
{
MMatrix conversionMatrix = getWorldPtr()->mRenderGlobals->globalConversionMatrix;
float scaleFactor = getWorldPtr()->mRenderGlobals->scaleFactor;
transformSequence.clear();
std::vector<MMatrix> transformMatrices;
// In IPR mode we have to update the matrix from the dagPath
if (getWorldPtr()->getRenderType() == World::IPRRENDER && !obj->isInstancerObject)
{
transformMatrices.push_back(obj->dagPath.inclusiveMatrix());
}
else
{
transformMatrices = obj->transformMatrices;
}
size_t numSteps = transformMatrices.size();
size_t divSteps = numSteps;
if (divSteps > 1)
divSteps -= 1;
float stepSize = 1.0f / (float)divSteps;
float start = 0.0f;
// cameras pos has to be scaled because it is not placed into the world assembly but directly in the scene.
// We only scale the transform because a scaled camera will result in different renderings (e.g. dof)
foundation::Matrix4d appMatrix;
MMatrix transformMatrix;
for (size_t matrixId = 0; matrixId < numSteps; matrixId++)
{
MMatrix colMatrix = transformMatrices[matrixId];
if (obj->mobject.hasFn(MFn::kCamera))
{
colMatrix.matrix[3][0] *= scaleFactor;
colMatrix.matrix[3][1] *= scaleFactor;
colMatrix.matrix[3][2] *= scaleFactor;
}
MMatrixToAMatrix(colMatrix, appMatrix);
transformSequence.set_transform(
start + stepSize * matrixId,
foundation::Transformd::from_local_to_parent(appMatrix));
}
}
void fillTransformMatrices(const MayaObject* obj, renderer::Light* light)
{
std::vector<MMatrix> transformMatrices;
// in ipr mode we have to update the matrix manually
if (getWorldPtr()->getRenderType() == World::IPRRENDER)
{
transformMatrices.push_back(obj->dagPath.inclusiveMatrix());
}
else
{
transformMatrices = obj->transformMatrices;
}
foundation::Matrix4d appMatrix;
MMatrix colMatrix = transformMatrices[0];
MMatrixToAMatrix(colMatrix, appMatrix);
light->set_transform(foundation::Transformd::from_local_to_parent(appMatrix));
}
MString defineTexture(MFnDependencyNode& shader, MString& attributeName)
{
boost::shared_ptr<AppleseedRenderer> appleRenderer = boost::static_pointer_cast<AppleseedRenderer>(getWorldPtr()->mRenderer);
assert(appleRenderer != 0);
renderer::Scene* scene = getSceneFromProject(appleRenderer->getProjectPtr());
foundation::SearchPaths &searchPaths = appleRenderer->getProjectPtr()->search_paths();
MStatus stat;
MString textureDefinition("");
MPlug plug = shader.findPlug(attributeName, &stat);
if (stat != MStatus::kSuccess)
return textureDefinition;
if (!plug.isConnected())
return textureDefinition;
MObject connectedNode = getConnectedInNode(plug);
if (!connectedNode.hasFn(MFn::kFileTexture))
return textureDefinition;
MFnDependencyNode fileTextureNode(connectedNode, &stat);
MString textureName = fileTextureNode.name() + "_texture";
MString fileTextureName = "";
getString(MString("fileTextureName"), fileTextureNode, fileTextureName);
if (!pystring::endswith(fileTextureName.asChar(), ".exr") || (fileTextureName.length() == 0))
{
if (fileTextureName.length() == 0)
Logging::warning(MString("FileTextureName has no content."));
else
Logging::warning(MString("FileTextureName does not have an .exr extension. Other filetypes are not yet supported, sorry."));
return textureDefinition;
}
removeTextureEntityIfItExists(textureName);
MString colorProfile = "srgb";
renderer::ParamArray params;
Logging::debug(MString("Now inserting file name: ") + fileTextureName);
params.insert("filename", fileTextureName.asChar()); // OpenEXR only for now. The param is called filename but it can be a path
params.insert("color_space", colorProfile.asChar());
foundation::auto_release_ptr<renderer::Texture> textureElement(
renderer::DiskTexture2dFactory().create(
textureName.asChar(),
params,
searchPaths)); // the project holds a set of search paths to find textures and other assets
scene->textures().insert(textureElement);
bool alphaIsLuminance = false;
getBool(MString("alphaIsLuminance"), fileTextureNode, alphaIsLuminance);
renderer::ParamArray tInstParams;
tInstParams.insert("addressing_mode", "clamp");
tInstParams.insert("filtering_mode", "bilinear");
if (alphaIsLuminance)
tInstParams.insert("alpha_mode", "luminance");
MString textureInstanceName = textureName + "_texInst";
foundation::auto_release_ptr<renderer::TextureInstance> tinst = renderer::TextureInstanceFactory().create(
textureInstanceName.asChar(),
tInstParams,
textureName.asChar());
scene->texture_instances().insert(tinst);
return textureInstanceName;
}
void removeTextureEntityIfItExists(MString& textureName)
{
boost::shared_ptr<AppleseedRenderer> appleRenderer = boost::static_pointer_cast<AppleseedRenderer>(getWorldPtr()->mRenderer);
assert(appleRenderer != 0);
renderer::Scene* scene = getSceneFromProject(appleRenderer->getProjectPtr());
const MString textureInstanceName = textureName + "_texInst";
renderer::Texture* texture = scene->textures().get_by_name(textureName.asChar());
if (texture != 0)
scene->textures().remove(texture);
renderer::TextureInstance* textureInstance = scene->texture_instances().get_by_name(textureInstanceName.asChar());
if (textureInstance != 0)
scene->texture_instances().remove(textureInstance);
}
renderer::AssemblyInstance* getAssemblyInstance(const MayaObject* obj)
{
boost::shared_ptr<AppleseedRenderer> appleRenderer = boost::static_pointer_cast<AppleseedRenderer>(getWorldPtr()->mRenderer);
MayaObject* assemblyObject = getAssemblyMayaObject(obj);
MString assemblyName = getAssemblyName(assemblyObject);
MString assemblyInstanceName = getAssemblyInstanceName(assemblyObject);
renderer::Assembly* masterAssembly = getMasterAssemblyFromProject(appleRenderer->getProjectPtr());
renderer::AssemblyInstance* masterAssemblyInstance = appleRenderer->getProjectPtr()->get_scene()->assembly_instances().get_by_name("world_Inst");
if (assemblyName == "world" || assemblyObject == 0 || (obj->mobject.hasFn(MFn::kLight) && !obj->mobject.hasFn(MFn::kAreaLight)))
return masterAssemblyInstance;
return masterAssembly->assembly_instances().get_by_name(assemblyInstanceName.asChar());
}
renderer::AssemblyInstance* createAssemblyInstance(const MayaObject* obj)
{
MayaObject* assemblyObject = getAssemblyMayaObject(obj);
boost::shared_ptr<AppleseedRenderer> appleRenderer = boost::static_pointer_cast<AppleseedRenderer>(getWorldPtr()->mRenderer);
renderer::Assembly* ass = getAssembly(obj);
renderer::Assembly* master = getMasterAssemblyFromProject(appleRenderer->getProjectPtr());
MString assemblyInstanceName = getAssemblyInstanceName(assemblyObject);
foundation::auto_release_ptr<renderer::AssemblyInstance> assemblyInstance = renderer::AssemblyInstanceFactory::create(assemblyInstanceName.asChar(), renderer::ParamArray(), ass->get_name());
fillMatrices(obj, assemblyInstance->transform_sequence());
renderer::AssemblyInstance* assInst = assemblyInstance.get();
master->assembly_instances().insert(assemblyInstance);
return assInst;
}
renderer::Assembly* createAssembly(const MayaObject* obj)
{
MayaObject* assemblyObject = getAssemblyMayaObject(obj);
boost::shared_ptr<AppleseedRenderer> appleRenderer = boost::static_pointer_cast<AppleseedRenderer>(getWorldPtr()->mRenderer);
renderer::Assembly* master = getMasterAssemblyFromProject(appleRenderer->getProjectPtr());
if (obj->mobject.hasFn(MFn::kLight) && !obj->mobject.hasFn(MFn::kAreaLight))
return master;
if (assemblyObject == 0)
return master;
MString assemblyName = getAssemblyName(assemblyObject);
if (assemblyName == "world")
return master;
foundation::auto_release_ptr<renderer::Assembly> assembly(
renderer::AssemblyFactory().create(assemblyName.asChar(), renderer::ParamArray()));
renderer::Assembly* ass = assembly.get();
master->assemblies().insert(assembly);
return ass;
}
void MayaRendererFactory::deleteRenderer()
{
getWorldPtr()->worldRendererPtr.reset();
}
void RenderGlobalsFactory::deleteRenderGlobals()
{
getWorldPtr()->worldRenderGlobalsPtr.reset();
}
std::shared_ptr<RenderGlobals> RenderGlobalsFactory::getRenderGlobals()
{
return getWorldPtr()->worldRenderGlobalsPtr;
}
mtco_MayaScene::~mtco_MayaScene()
{
logger.debug("mtco maya scene destructor.");
getWorldPtr()->worldRenderGlobals = NULL;
}
void mtco_MayaScene::getRenderGlobals()
{
this->renderGlobals = new mtco_RenderGlobals();
MayaScene::renderGlobals = renderGlobals;
getWorldPtr()->worldRenderGlobals = this->renderGlobals;
}
void MayaToWorld::callAfterNewCallback(void *)
{
getWorldPtr()->afterNewScene();
}
void MayaToWorld::callAfterOpenCallback(void *)
{
getWorldPtr()->afterOpenScene();
}
void MayaRendererFactory::createRenderer()
{
getWorldPtr()->worldRendererPtr = std::shared_ptr<Renderer>(new MtRender::MtRenderer());
}
void RenderGlobalsFactory::createRenderGlobals()
{
getWorldPtr()->worldRenderGlobalsPtr = std::shared_ptr<RenderGlobals> (new RenderGlobals());
}
std::shared_ptr<Renderer> MayaRendererFactory::getRenderer()
{
return getWorldPtr()->worldRendererPtr;
}