antc13
434 lines
16 KiB
C++
434 lines
16 KiB
C++
#include "Material.h"
|
|
|
|
void Material::grabLambertProperties(MaterialNode& material_node, MFnDependencyNode& node)
|
|
{
|
|
material_node.Name = node.name().asChar();
|
|
|
|
if (!findColorTexture(material_node, node)) {
|
|
node.findPlug("colorR").getValue(material_node.DiffuseColor[0]);
|
|
node.findPlug("colorG").getValue(material_node.DiffuseColor[1]);
|
|
node.findPlug("colorB").getValue(material_node.DiffuseColor[2]);
|
|
|
|
}
|
|
|
|
|
|
if (!findIncandescenceTexture(material_node, node)) {
|
|
node.findPlug("incandescenceR").getValue(material_node.IncandescenceColor[0]);
|
|
node.findPlug("incandescenceG").getValue(material_node.IncandescenceColor[1]);
|
|
node.findPlug("incandescenceB").getValue(material_node.IncandescenceColor[2]);
|
|
}
|
|
|
|
if (findNormalTexture(material_node, node)) {
|
|
MGlobal::displayWarning(MString() + "Material " + node.name() + " has no normal texture.");
|
|
}
|
|
}
|
|
|
|
void Material::grabBlinnProperties(MaterialNode& material_node, MFnDependencyNode& node)
|
|
{
|
|
if (!findSpecularTexture(material_node, node)) {
|
|
node.findPlug("specularColorR").getValue(material_node.SpecularColor[0]);
|
|
node.findPlug("specularColorG").getValue(material_node.SpecularColor[1]);
|
|
node.findPlug("specularColorB").getValue(material_node.SpecularColor[2]);
|
|
}
|
|
|
|
m_Plug = node.findPlug("reflectivity");
|
|
m_Plug.getValue(material_node.ReflectionFactor);
|
|
|
|
m_Plug = node.findPlug("eccentricity");
|
|
float TempEccent;
|
|
m_Plug.getValue(TempEccent);
|
|
|
|
// Blinn works differently from Phong which is used in-game.
|
|
// This is some magic numbers and math to make a conversion estimate between the two.
|
|
// There is no exact conversion between the two, so there are errors.
|
|
|
|
// Phong min/max is around Blinn 0.7/0.1
|
|
TempEccent = std::max(std::min(TempEccent, 0.7f), 0.1f);
|
|
|
|
material_node.SpecularExponent = std::max(std::min(((2.66f) + (427.0f) * exp((-14.8f) * TempEccent)), 100.0f), 2.0f);
|
|
}
|
|
|
|
void Material::grabPhongProperties(MaterialNode& material_node, MFnDependencyNode& node)
|
|
{
|
|
if (!findSpecularTexture(material_node, node)) {
|
|
node.findPlug("specularColorR").getValue(material_node.SpecularColor[0]);
|
|
node.findPlug("specularColorG").getValue(material_node.SpecularColor[1]);
|
|
node.findPlug("specularColorB").getValue(material_node.SpecularColor[2]);
|
|
}
|
|
|
|
m_Plug = node.findPlug("reflectivity");
|
|
m_Plug.getValue(material_node.ReflectionFactor);
|
|
|
|
m_Plug = node.findPlug("cosinePower ");
|
|
m_Plug.getValue(material_node.SpecularExponent);
|
|
}
|
|
|
|
bool Material::findColorTexture(MaterialNode& material_node, MFnDependencyNode& node)
|
|
{
|
|
MPlugArray AllConnections;
|
|
|
|
m_Plug = node.findPlug("color", true);
|
|
m_Plug.connectedTo(AllConnections, true, false);
|
|
|
|
for (int i = 0; i < AllConnections.length(); i++) {
|
|
if (AllConnections[i].node().hasFn(MFn::kFileTexture)) {
|
|
MFnDependencyNode TextureNode(AllConnections[i].node());
|
|
|
|
std::string FullPath = TextureNode.findPlug("fileTextureName").asString().asChar();
|
|
m_TexturePaths.push_back(FullPath);
|
|
|
|
MString workspace;
|
|
MStatus status = MGlobal::executeCommand(MString("workspace -q -rd;"),
|
|
workspace);
|
|
FullPath = FullPath.substr(workspace.length());
|
|
FullPath = FullPath.substr(FullPath.find_first_of("/") + 1);
|
|
|
|
MaterialNode::Texture newTexture;
|
|
|
|
newTexture.FileName = FullPath.erase(FullPath.find_last_of("."), FullPath.find_last_of(".") - FullPath.size());
|
|
newTexture.FileNameLength = newTexture.FileName.length() + 1;
|
|
|
|
MPlug uvRepeatFile = TextureNode.findPlug("repeatUV");
|
|
|
|
uvRepeatFile.connectedTo(AllConnections, true, false);
|
|
|
|
for (int i = 0; i < AllConnections.length(); i++) {
|
|
if (AllConnections[i].node().hasFn(MFn::kPlace2dTexture)) {
|
|
MFnDependencyNode place2DTexture(AllConnections[i].node());
|
|
MPlug uvRepeat = place2DTexture.findPlug("repeatUV");
|
|
|
|
newTexture.UVTiling[0] = uvRepeat.child(0).asFloat();
|
|
newTexture.UVTiling[1] = uvRepeat.child(1).asFloat();
|
|
}
|
|
}
|
|
|
|
material_node.ColorMaps.push_back(newTexture);
|
|
if(material_node.type == MaterialNode::MaterialType::Basic)
|
|
material_node.type = MaterialNode::MaterialType::SingleTextures;
|
|
return true;
|
|
|
|
} else if (AllConnections[i].node().hasFn(MFn::kLayeredTexture)) {
|
|
MGlobal::displayInfo(MString() + "found color splat map");
|
|
return findSplatTextures(material_node, material_node.ColorMaps, MFnDependencyNode(AllConnections[i].node()));
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Material::findNormalTexture(MaterialNode& material_node, MFnDependencyNode& node)
|
|
{
|
|
MPlugArray AllConnections;
|
|
MPlugArray AllBumpConnections;
|
|
|
|
m_Plug = node.findPlug("normalCamera", true);
|
|
m_Plug.connectedTo(AllConnections, true, false);
|
|
|
|
for (int i = 0; i < AllConnections.length(); i++) {
|
|
if (AllConnections[i].node().apiType() == MFn::kBump) {
|
|
MFnDependencyNode BumpNode(AllConnections[i].node());
|
|
|
|
BumpNode.findPlug("bumpValue").connectedTo(AllBumpConnections, true, false);
|
|
for (int j = 0; j < AllBumpConnections.length(); j++) {
|
|
if (AllBumpConnections[j].node().hasFn(MFn::kFileTexture)) {
|
|
MFnDependencyNode TextureNode(AllBumpConnections[j].node());
|
|
|
|
std::string FullPath = TextureNode.findPlug("ftn").asString().asChar();
|
|
m_TexturePaths.push_back(FullPath);
|
|
|
|
MString workspace;
|
|
MStatus status = MGlobal::executeCommand(MString("workspace -q -rd;"),
|
|
workspace);
|
|
FullPath = FullPath.substr(workspace.length());
|
|
FullPath = FullPath.substr(FullPath.find_first_of("/") + 1);
|
|
|
|
MaterialNode::Texture newTexture;
|
|
|
|
newTexture.FileName = FullPath.erase(FullPath.find_last_of("."), FullPath.find_last_of(".") - FullPath.size());
|
|
newTexture.FileNameLength = newTexture.FileName.length() + 1;
|
|
|
|
MPlug uvRepeatFile = TextureNode.findPlug("repeatUV");
|
|
|
|
uvRepeatFile.connectedTo(AllConnections, true, false);
|
|
|
|
for (int i = 0; i < AllConnections.length(); i++) {
|
|
if (AllConnections[i].node().hasFn(MFn::kPlace2dTexture)) {
|
|
MFnDependencyNode place2DTexture(AllConnections[i].node());
|
|
MPlug uvRepeat = place2DTexture.findPlug("repeatUV");
|
|
|
|
newTexture.UVTiling[0] = uvRepeat.child(0).asFloat();
|
|
newTexture.UVTiling[1] = uvRepeat.child(1).asFloat();
|
|
}
|
|
}
|
|
|
|
material_node.NormalMaps.push_back(newTexture);
|
|
return true;
|
|
} else if (AllBumpConnections[j].node().hasFn(MFn::kLayeredTexture)) {
|
|
MGlobal::displayInfo(MString() + "found normal splat map");
|
|
return findSplatTextures(material_node, material_node.NormalMaps, MFnDependencyNode(AllBumpConnections[j].node()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool Material::findSpecularTexture(MaterialNode& material_node, MFnDependencyNode& node)
|
|
{
|
|
MPlugArray AllConnections;
|
|
|
|
m_Plug = node.findPlug("specularColor", true);
|
|
m_Plug.connectedTo(AllConnections, true, false);
|
|
|
|
for (int i = 0; i < AllConnections.length(); i++) {
|
|
if (AllConnections[i].node().hasFn(MFn::kFileTexture)) {
|
|
MFnDependencyNode TextureNode(AllConnections[i].node());
|
|
|
|
std::string FullPath = TextureNode.findPlug("ftn").asString().asChar();
|
|
m_TexturePaths.push_back(FullPath);
|
|
|
|
MString workspace;
|
|
MStatus status = MGlobal::executeCommand(MString("workspace -q -rd;"),
|
|
workspace);
|
|
FullPath = FullPath.substr(workspace.length());
|
|
FullPath = FullPath.substr(FullPath.find_first_of("/") + 1);
|
|
|
|
MaterialNode::Texture newTexture;
|
|
|
|
newTexture.FileName = FullPath.erase(FullPath.find_last_of("."), FullPath.find_last_of(".") - FullPath.size());
|
|
newTexture.FileNameLength = newTexture.FileName.length() + 1;
|
|
|
|
MPlug uvRepeatFile = TextureNode.findPlug("repeatUV");
|
|
|
|
uvRepeatFile.connectedTo(AllConnections, true, false);
|
|
|
|
for (int i = 0; i < AllConnections.length(); i++) {
|
|
if (AllConnections[i].node().hasFn(MFn::kPlace2dTexture)) {
|
|
//C:\Users\kamisama\Desktop\TacticalZ\assets\test
|
|
MFnDependencyNode place2DTexture(AllConnections[i].node());
|
|
MPlug uvRepeat = place2DTexture.findPlug("repeatUV");
|
|
|
|
newTexture.UVTiling[0] = uvRepeat.child(0).asFloat();
|
|
newTexture.UVTiling[1] = uvRepeat.child(1).asFloat();
|
|
}
|
|
}
|
|
|
|
material_node.SpecularMaps.push_back(newTexture);
|
|
if (material_node.type == MaterialNode::MaterialType::Basic)
|
|
material_node.type = MaterialNode::MaterialType::SingleTextures;
|
|
return true;
|
|
} else if (AllConnections[i].node().hasFn(MFn::kLayeredTexture)) {
|
|
MGlobal::displayInfo(MString() + "found specular splat map");
|
|
return findSplatTextures(material_node, material_node.SpecularMaps, MFnDependencyNode(AllConnections[i].node()));
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Material::findIncandescenceTexture(MaterialNode& material_node, MFnDependencyNode& node)
|
|
{
|
|
MPlugArray AllConnections;
|
|
|
|
m_Plug = node.findPlug("incandescence", true);
|
|
m_Plug.connectedTo(AllConnections, true, false);
|
|
|
|
for (int i = 0; i < AllConnections.length(); i++) {
|
|
if (AllConnections[i].node().hasFn(MFn::kFileTexture)) {
|
|
MFnDependencyNode TextureNode(AllConnections[i].node());
|
|
|
|
std::string FullPath = TextureNode.findPlug("ftn").asString().asChar();
|
|
m_TexturePaths.push_back(FullPath);
|
|
|
|
MString workspace;
|
|
MStatus status = MGlobal::executeCommand(MString("workspace -q -rd;"),
|
|
workspace);
|
|
FullPath = FullPath.substr(workspace.length());
|
|
FullPath = FullPath.substr(FullPath.find_first_of("/") + 1);
|
|
|
|
MaterialNode::Texture newTexture;
|
|
|
|
newTexture.FileName = FullPath.erase(FullPath.find_last_of("."), FullPath.find_last_of(".") - FullPath.size());
|
|
newTexture.FileNameLength = newTexture.FileName.length() + 1;
|
|
|
|
MPlug uvRepeatFile = TextureNode.findPlug("repeatUV");
|
|
|
|
uvRepeatFile.connectedTo(AllConnections, true, false);
|
|
|
|
for (int i = 0; i < AllConnections.length(); i++) {
|
|
if (AllConnections[i].node().hasFn(MFn::kPlace2dTexture)) {
|
|
MFnDependencyNode place2DTexture(AllConnections[i].node());
|
|
MPlug uvRepeat = place2DTexture.findPlug("repeatUV");
|
|
|
|
newTexture.UVTiling[0] = uvRepeat.child(0).asFloat();
|
|
newTexture.UVTiling[1] = uvRepeat.child(1).asFloat();
|
|
}
|
|
}
|
|
|
|
material_node.IncandescenceMaps.push_back(newTexture);
|
|
if (material_node.type == MaterialNode::MaterialType::Basic)
|
|
material_node.type = MaterialNode::MaterialType::SingleTextures;
|
|
return true;
|
|
|
|
} else if (AllConnections[i].node().hasFn(MFn::kLayeredTexture)) {
|
|
MGlobal::displayInfo(MString() + "found incandescens splat map");
|
|
return findSplatTextures(material_node, material_node.IncandescenceMaps, MFnDependencyNode(AllConnections[i].node()));
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//C:\Users\kamisama\Desktop\TacticalZ\assets\test
|
|
|
|
bool Material::findSplatTextures(MaterialNode& material_node, std::vector<MaterialNode::Texture>& textureVector, MFnDependencyNode& node) {
|
|
//Get all Inputs in LayeredTexture
|
|
MPlug inputs = node.findPlug("inputs");
|
|
MGlobal::displayInfo(MString() + "inputs.numElements(): " + inputs.numElements());
|
|
|
|
MPlugArray AllConnections;
|
|
MStatus test;
|
|
//Try to find splat texture if using custom splatmap build up.
|
|
inputs[0].child(1).connectedTo(AllConnections, true, false);
|
|
for (int i = 0; i < AllConnections.length(); i++) {
|
|
if (AllConnections[i].node().hasFn(MFn::kMultiplyDivide)) {
|
|
MGlobal::displayInfo(MString() + "found kMultiplyDivide");
|
|
MFnDependencyNode multiplyDivide(AllConnections[i].node());
|
|
multiplyDivide.findPlug("input1", &test).child(0).connectedTo(AllConnections, true, false);;
|
|
for (int i = 0; i < AllConnections.length(); i++) {
|
|
if (AllConnections[i].node().hasFn(MFn::kFileTexture)) {
|
|
MFnDependencyNode TextureNode(AllConnections[i].node());
|
|
|
|
std::string FullPath = TextureNode.findPlug("ftn").asString().asChar();
|
|
m_TexturePaths.push_back(FullPath);
|
|
|
|
MString workspace;
|
|
MStatus status = MGlobal::executeCommand(MString("workspace -q -rd;"),
|
|
workspace);
|
|
FullPath = FullPath.substr(workspace.length());
|
|
FullPath = FullPath.substr(FullPath.find_first_of("/") + 1);
|
|
|
|
MaterialNode::Texture newTexture;
|
|
|
|
newTexture.FileName = FullPath.erase(FullPath.find_last_of("."), FullPath.find_last_of(".") - FullPath.size());
|
|
newTexture.FileNameLength = newTexture.FileName.length() + 1;
|
|
|
|
MPlug uvRepeatFile = TextureNode.findPlug("repeatUV");
|
|
|
|
uvRepeatFile.connectedTo(AllConnections, true, false);
|
|
|
|
for (int i = 0; i < AllConnections.length(); i++) {
|
|
if (AllConnections[i].node().hasFn(MFn::kPlace2dTexture)) {
|
|
MFnDependencyNode place2DTexture(AllConnections[i].node());
|
|
MPlug uvRepeat = place2DTexture.findPlug("repeatUV");
|
|
|
|
newTexture.UVTiling[0] = uvRepeat.child(0).asFloat();
|
|
newTexture.UVTiling[1] = uvRepeat.child(1).asFloat();
|
|
}
|
|
}
|
|
material_node.SplatMap = newTexture;
|
|
material_node.type = MaterialNode::MaterialType::SplatMapping;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (unsigned int i = 0; i < inputs.numElements(); i++) {
|
|
//Get connections to color in input[i]
|
|
inputs[i].child(0).connectedTo(AllConnections, true, false);
|
|
|
|
for (int i = 0; i < AllConnections.length(); i++) {
|
|
if (AllConnections[i].node().hasFn(MFn::kFileTexture)) {
|
|
MFnDependencyNode TextureNode(AllConnections[i].node());
|
|
|
|
std::string FullPath = TextureNode.findPlug("ftn").asString().asChar();
|
|
m_TexturePaths.push_back(FullPath);
|
|
|
|
MString workspace;
|
|
MStatus status = MGlobal::executeCommand(MString("workspace -q -rd;"),
|
|
workspace);
|
|
FullPath = FullPath.substr(workspace.length());
|
|
FullPath = FullPath.substr(FullPath.find_first_of("/") + 1);
|
|
|
|
MaterialNode::Texture newTexture;
|
|
|
|
newTexture.FileName = FullPath.erase(FullPath.find_last_of("."), FullPath.find_last_of(".") - FullPath.size());
|
|
newTexture.FileNameLength = newTexture.FileName.length() + 1;
|
|
|
|
MPlug uvRepeatFile = TextureNode.findPlug("repeatUV");
|
|
|
|
uvRepeatFile.connectedTo(AllConnections, true, false);
|
|
|
|
for (int i = 0; i < AllConnections.length(); i++) {
|
|
if (AllConnections[i].node().hasFn(MFn::kPlace2dTexture)) {
|
|
MFnDependencyNode place2DTexture(AllConnections[i].node());
|
|
MPlug uvRepeat = place2DTexture.findPlug("repeatUV");
|
|
|
|
newTexture.UVTiling[0] = uvRepeat.child(0).asFloat();
|
|
newTexture.UVTiling[1] = uvRepeat.child(1).asFloat();
|
|
}
|
|
}
|
|
textureVector.push_back(newTexture);
|
|
break;
|
|
}
|
|
}
|
|
if (AllConnections.length() == 0) {
|
|
MaterialNode::Texture newTexture;
|
|
newTexture.FileNameLength = 0;
|
|
textureVector.push_back(newTexture);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Returns the absolute path for all textures. Use for copying texture files.
|
|
std::vector<std::string>* Material::TexturePaths()
|
|
{
|
|
return &m_TexturePaths;
|
|
}
|
|
|
|
// Traverse the DAG and grab all the materials
|
|
std::vector<MaterialNode>* Material::DoIt(Mesh mesh)
|
|
{
|
|
// All materials we care about inherit from Lambert
|
|
MItDependencyNodes matIt(MFn::kLambert);
|
|
m_AllMaterials.clear();
|
|
while (!matIt.isDone()) {
|
|
MFnDependencyNode MaterialFnDN(matIt.thisNode());
|
|
MaterialNode MaterialStorage;
|
|
bool meshHasMaterial = false;
|
|
//Mesh Indices is a map with <string : MaterialName, vector<int> : indices>
|
|
int totalIndices = 0;
|
|
for (auto aMeshMaterial : mesh.Indices) {
|
|
MGlobal::displayInfo(MString() + "Material: " + aMeshMaterial.first.c_str() + " " + MaterialFnDN.name().asChar());
|
|
if (aMeshMaterial.first.compare(MaterialFnDN.name().asChar()) == 0) {
|
|
meshHasMaterial = true;
|
|
MaterialStorage.IndexStart = totalIndices;
|
|
MaterialStorage.IndexEnd = totalIndices + aMeshMaterial.second.size() - 1;
|
|
}
|
|
totalIndices += aMeshMaterial.second.size();
|
|
}
|
|
if (meshHasMaterial) {
|
|
grabLambertProperties(MaterialStorage, MaterialFnDN);
|
|
|
|
if (matIt.thisNode().hasFn(MFn::kPhong)) {
|
|
grabPhongProperties(MaterialStorage, MaterialFnDN);
|
|
|
|
} else if (matIt.thisNode().hasFn(MFn::kBlinn)) {
|
|
grabBlinnProperties(MaterialStorage, MaterialFnDN);
|
|
|
|
} else if (matIt.thisNode().hasFn(MFn::kLambert)) {
|
|
MaterialStorage.ReflectionFactor = 0.0f;
|
|
MaterialStorage.SpecularExponent = 0.0f;
|
|
}
|
|
MaterialStorage.NumColorMaps = MaterialStorage.ColorMaps.size();
|
|
MaterialStorage.NumNormalMaps = MaterialStorage.NormalMaps.size();
|
|
MaterialStorage.NumSpecularMaps = MaterialStorage.SpecularMaps.size();
|
|
MaterialStorage.NumIncandescenceMaps = MaterialStorage.IncandescenceMaps.size();
|
|
m_AllMaterials.push_back(MaterialStorage);
|
|
}
|
|
matIt.next();
|
|
}
|
|
|
|
return &m_AllMaterials;
|
|
}
|
|
|