material_map material_type::load_materials()
{
material_map allMaterials;
catajson materialsRaw("data/raw/materials.json");
unsigned int id = 0;
for (materialsRaw.set_begin(); materialsRaw.has_curr(); materialsRaw.next())
{
++id;
catajson currMaterial = materialsRaw.curr();
std::string ident = currMaterial.get("ident").as_string();
std::string name = currMaterial.get("name").as_string();
int bash_resist = currMaterial.get("bash_resist").as_int();
int cut_resist = currMaterial.get("cut_resist").as_int();
int acid_resist = currMaterial.get("acid_resist").as_int();
int elec_resist = currMaterial.get("elec_resist").as_int();
int fire_resist = currMaterial.get("fire_resist").as_int();
material_type newMaterial(id, ident, name, bash_resist, cut_resist, acid_resist, elec_resist, fire_resist);
allMaterials[ident] = newMaterial;
}
return allMaterials;
}
OSPMaterial ISPCDevice::newMaterial(OSPRenderer _renderer,
const char *material_type)
{
auto *renderer = reinterpret_cast<Renderer*>(_renderer);
auto name = renderer->getParamString("externalNameFromAPI");
return newMaterial(name.c_str(), material_type);
}
material_map material_type::load_materials()
{
material_map allMaterials;
catajson materialsRaw("data/raw/materials.json", true);
unsigned int id = 0;
for (materialsRaw.set_begin(); materialsRaw.has_curr() && json_good(); materialsRaw.next())
{
++id;
catajson currMaterial = materialsRaw.curr();
std::string ident = currMaterial.get("ident").as_string();
std::string name = currMaterial.get("name").as_string();
int bash_resist = currMaterial.get("bash_resist").as_int();
int cut_resist = currMaterial.get("cut_resist").as_int();
std::string bash_dmg_verb = currMaterial.get("bash_dmg_verb").as_string();
std::string cut_dmg_verb = currMaterial.get("cut_dmg_verb").as_string();
int acid_resist = currMaterial.get("acid_resist").as_int();
int elec_resist = currMaterial.get("elec_resist").as_int();
int fire_resist = currMaterial.get("fire_resist").as_int();
int density = currMaterial.get("density").as_int();
catajson adjList = currMaterial.get("dmg_adj");
std::string dmg_adj[4];
dmg_adj[0] = adjList.get(0).as_string();
dmg_adj[1] = adjList.get(1).as_string();
dmg_adj[2] = adjList.get(2).as_string();
dmg_adj[3] = adjList.get(3).as_string();
name = _(name.c_str());
bash_dmg_verb = _(bash_dmg_verb.c_str());
cut_dmg_verb = _(cut_dmg_verb.c_str());
dmg_adj[0] = _(dmg_adj[0].c_str());
dmg_adj[1] = _(dmg_adj[1].c_str());
dmg_adj[2] = _(dmg_adj[2].c_str());
dmg_adj[3] = _(dmg_adj[3].c_str());
material_type newMaterial(id, ident, name, bash_resist, cut_resist, bash_dmg_verb,
cut_dmg_verb, dmg_adj, acid_resist, elec_resist, fire_resist, density);
allMaterials[ident] = newMaterial;
}
if(!json_good())
exit(1);
return allMaterials;
}
AS3_Val initializeMaterial( void* self, AS3_Val args )
{
Material * material;
AS3_Val ambient, diffuse, specular, emissive;
double a_a, a_r, a_g, a_b, d_a, d_r, d_g, d_b, s_a, s_r, s_g, s_b, e_a, e_r, e_g, e_b, power;
AS3_ArrayValue( args, "AS3ValType, AS3ValType, AS3ValType, AS3ValType, DoubleType", &ambient, &diffuse, &specular, &emissive, &power );
a_r = AS3_NumberValue( AS3_GetS( ambient, "redMultiplier" ) );
a_g = AS3_NumberValue( AS3_GetS( ambient, "greenMultiplier" ) );
a_b = AS3_NumberValue( AS3_GetS( ambient, "blueMultiplier" ) );
a_a = AS3_NumberValue( AS3_GetS( ambient, "alphaMultiplier" ) );
d_r = AS3_NumberValue( AS3_GetS( diffuse, "redMultiplier" ) );
d_g = AS3_NumberValue( AS3_GetS( diffuse, "greenMultiplier" ) );
d_b = AS3_NumberValue( AS3_GetS( diffuse, "blueMultiplier" ) );
d_a = AS3_NumberValue( AS3_GetS( diffuse, "alphaMultiplier" ) );
s_r = AS3_NumberValue( AS3_GetS( specular, "redMultiplier" ) );
s_g = AS3_NumberValue( AS3_GetS( specular, "greenMultiplier" ) );
s_b = AS3_NumberValue( AS3_GetS( specular, "blueMultiplier" ) );
s_a = AS3_NumberValue( AS3_GetS( specular, "alphaMultiplier" ) );
e_r = AS3_NumberValue( AS3_GetS( emissive, "redMultiplier" ) );
e_g = AS3_NumberValue( AS3_GetS( emissive, "greenMultiplier" ) );
e_b = AS3_NumberValue( AS3_GetS( emissive, "blueMultiplier" ) );
e_a = AS3_NumberValue( AS3_GetS( emissive, "alphaMultiplier" ) );
material = newMaterial( newColor888( (BYTE)(a_r * 255), (BYTE)(a_g * 255), (BYTE)(a_b * 255), (BYTE)(a_a * 255) ),
newColor888( (BYTE)(d_r * 255), (BYTE)(d_g * 255), (BYTE)(d_b * 255), (BYTE)(d_a * 255) ),
newColor888( (BYTE)(s_r * 255), (BYTE)(s_g * 255), (BYTE)(s_b * 255), (BYTE)(s_a * 255) ),
newColor888( (BYTE)(e_r * 255), (BYTE)(e_g * 255), (BYTE)(e_b * 255), (BYTE)(e_a * 255) ),
power );
AS3_Release( ambient );
AS3_Release( diffuse );
AS3_Release( specular );
AS3_Release( emissive );
return AS3_Array( "PtrType, PtrType, PtrType, PtrType, PtrType, PtrType, PtrType", material, material->ambient, material->diffuse, material->specular, material->emissive, &material->power, &material->doubleSide );
}
const LLMaterialPtr LLMaterialMgr::setMaterial(const LLUUID& region_id, const LLMaterialID& material_id, const LLSD& material_data)
{
LL_DEBUGS("Materials") << "region " << region_id << " material id " << material_id << LL_ENDL;
material_map_t::const_iterator itMaterial = mMaterials.find(material_id);
if (mMaterials.end() == itMaterial)
{
LL_DEBUGS("Materials") << "new material" << LL_ENDL;
LLMaterialPtr newMaterial(new LLMaterial(material_data));
std::pair<material_map_t::const_iterator, bool> ret = mMaterials.insert(std::pair<LLMaterialID, LLMaterialPtr>(material_id, newMaterial));
itMaterial = ret.first;
}
TEMaterialPair te_mat_pair;
te_mat_pair.materialID = material_id;
U32 i = 0;
while (i < LLTEContents::MAX_TES)
{
te_mat_pair.te = i++;
get_callback_te_map_t::iterator itCallbackTE = mGetTECallbacks.find(te_mat_pair);
if (itCallbackTE != mGetTECallbacks.end())
{
(*itCallbackTE->second)(material_id, itMaterial->second, te_mat_pair.te);
delete itCallbackTE->second;
mGetTECallbacks.erase(itCallbackTE);
}
}
get_callback_map_t::iterator itCallback = mGetCallbacks.find(material_id);
if (itCallback != mGetCallbacks.end())
{
(*itCallback->second)(material_id, itMaterial->second);
delete itCallback->second;
mGetCallbacks.erase(itCallback);
}
mGetPending.erase(pending_material_t(region_id, material_id));
return itMaterial->second;
}
void GeometryGather::changeMaterial(const String& material, const ParameterArray& materialOverrideParameters)
{
currentQueue_ = nullptr;
if (materialOverrideParameters.empty())
{
// Try and find an existing queue that uses the specified material, the current priority, and has no custom
// parameters
for (auto& q : materialQueueInfos_)
{
if (q.queue->getPriority() == currentPriority_ && q.material == material && !q.queue->hasCustomParams() &&
!q.queue->getInternalParams().size())
{
currentQueue_ = &q;
currentQueue_->isTransformCurrent = false;
return;
}
}
}
// No existing material queue can be used, so create a new one
newMaterial(&materials().getMaterial(material), materialOverrideParameters);
}
// Convert a 3DS file into an OBJ file
bool C3dsObjConverter::Convert(CFile* pOtherFile, CFile* pObjFile)
{
// Initialize 3DS -> OBJ
m_p3dsFile = InitConversion<C3dsFile>(pOtherFile, pObjFile);
OBJ_ASSERT(m_p3dsFile && m_pOptions);
if(!m_p3dsFile || !m_pOptions)
return false;
MSG_INFO("Converting 3DS file format into OBJ file format...");
// Get the OBJ group vector
CObjFile::GroupVector& groups = m_pObjFile->GetGroupVector();
// Get the 3DS object vector
C3dsFile::ObjectVector& objects = m_p3dsFile->GetObjectVector();
C3dsFile::ObjectVector::iterator objectIt;
C3dsFile::ObjectVector::const_iterator objectEnd = objects.end();
for(objectIt = objects.begin(); objectIt != objectEnd; ++objectIt) // for each 3DS object
{
std::string objectName(objectIt->GetObjectName());
CObjFile::CGroup group(objectName);
// Get the 3DS mesh vector
C3dsFile::CObject::MeshVector& meshes = objectIt->GetMeshVector();
C3dsFile::CObject::MeshVector::iterator meshIt;
C3dsFile::CObject::MeshVector::const_iterator meshEnd = meshes.end();
for(meshIt = meshes.begin(); meshIt != meshEnd; ++meshIt) // for each 3DS mesh
{
// "Append" Vertex positions
{
Vector3DVector& maxVertices = meshIt->GetVertexPositionVector();
Vector3DVector& objVertices = m_pObjFile->GetVertexPositionVector();
objVertices.reserve(maxVertices.size());
objVertices.insert(objVertices.end(), maxVertices.begin(), maxVertices.end()); // Insert vertices
}
// "Append" Texture coordinates
{
Vector3DVector& maxTexCoords = meshIt->GetMapCoordVector();
Vector3DVector& objTexCoords = m_pObjFile->GetTextureCoordVector();
objTexCoords.reserve(maxTexCoords.size());
objTexCoords.insert(objTexCoords.end(), maxTexCoords.begin(), maxTexCoords.end()); // Insert UVs
}
bool bHasUVs = false;
if(meshIt->MapCoordCount() > 0)
{
bHasUVs = true;
}
// Generate Normals here ????
// Faces
{
C3dsFile::CObject::CMesh::FaceVector& faces = meshIt->GetFaceVector();
C3dsFile::CObject::CMesh::FaceVector::iterator faceIt;
C3dsFile::CObject::CMesh::FaceVector::const_iterator faceEnd = faces.end();
group.GetFaceVector().reserve(faces.size());
for(faceIt = faces.begin(); faceIt != faceEnd; ++faceIt) // for each 3DS face (triangle)
{
CObjFile::CFace objFace;
C3dsFile::SmoothingGroupPair sgPair = faceIt->m_smoothingGroup;
objFace.SetSmoothingGroup(std::make_pair(sgPair.first, sgPair.second));
objFace.SetMaterialID(faceIt->m_materialID);
for( uint v=0; v < faceIt->VertexCount(); ++v ) // for each vertex in the face
{
uint vertexIndex = faceIt->m_vertexIndices[v];
uint uvIndex = 0;
if(bHasUVs);
{
uvIndex = vertexIndex;
}
objFace.AddVertex( CObjFile::CVertex( vertexIndex + 1, // 3DS is 0-based index -> OBJ is 1-based index
std::make_pair(bHasUVs, uvIndex + 1),
std::make_pair(false, 0) )); // no normals in 3DS
} // End for each 3DS vertex
group.AddFace(objFace); // add face in OBJ group
} // End for each 3DS face
}
}
m_pObjFile->AddGroup(group);
}
// Materials
{
CMtlFile* pMtlFile = m_pObjFile->GetMaterialFile();
OBJ_ASSERT(pMtlFile);
if(!pMtlFile)
return false;
C3dsFile::MaterialMap& materials = m_p3dsFile->GetMaterialMap();
C3dsFile::MaterialMap::iterator materialIt;
C3dsFile::MaterialMap::const_iterator materialEnd = materials.end();
for(materialIt = materials.begin(); materialIt != materialEnd; ++materialIt) // for each 3DS material
{
uint materialID(materialIt->first);
C3dsFile::CMaterial* pMaterial = &materialIt->second;
if(!pMaterial)
continue;
std::string materialName(pMaterial->GetMaterialName());
CMtlFile::CMaterial newMaterial(materialName);
// TODO : parse other parameter : diffuse, ambient, spec, etc
if(pMaterial->HasTexMap()) // if there is a texture
{
std::string texMapFileName = pMaterial->GetTexMap();
newMaterial.SetTexMap(texMapFileName);
}
materialID = m_pObjFile->AddMaterial(newMaterial); // should be done together
}
}
return true;
}
