bool
avtSILMatrix::GetMaterialList(int index, MaterialList &matlist,
const vector<unsigned char> &useSet) const
{
int set1size = static_cast<int>(set1.size());
int set2size = static_cast<int>(set2.size());
int usedOne = 0;
int didntUseOne = 0;
if (index < set1size)
{
if (role2 != SIL_MATERIAL)
{
return false;
}
int row = index;
for (int i = 0 ; i < set2size ; i++)
{
int set = setsStartAt + row*set2size + i;
if (useSet[set] != NoneUsed)
{
usedOne++;
avtSILSet_p s2 = sil->GetSILSet(set2[i]);
matlist.push_back(s2->GetName());
}
else
{
didntUseOne++;
}
}
}
else
{
if (role1 != SIL_MATERIAL)
{
return false;
}
int column = index - set1size;
for (int i = 0 ; i < set1size ; i++)
{
int set = setsStartAt + i*set2size + column;
if (useSet[set] != NoneUsed)
{
usedOne++;
avtSILSet_p s1 = sil->GetSILSet(set1[i]);
matlist.push_back(s1->GetName());
}
else
{
didntUseOne++;
}
}
}
return (usedOne != 0 && didntUseOne != 0 ? true : false);
}
MaterialList *VectorNodeRenderData::AddVectorMaterial(MaterialEffect *NewMat, GeneralEffect *NewEffect, Joe *NewJoe, float NewCoverage)
{
MaterialList *TestMatList;
if (TestMatList = TestAddMaterial(NewMat, NewEffect, NewJoe, NewCoverage))
{
if (! TestMatList->VectorProp)
{
if (! TestMatList->AddVectorProperties())
return (NULL);
} // if
} // if
return (TestMatList);
} // VectorNodeRenderData::AddVectorMaterial
int addDecal(int materialIndex, Type type, const VC3 &position, int &id, bool forceSpawn)
{
assert(materialIndex >= 0 && materialIndex < int(materials.size()));
Material &material = materials[materialIndex];
return material.addDecal(type, position, id, forceSpawn);
}
int addMaterial(IStorm3D_Material *stormMaterial)
{
assert(stormMaterial);
Material material = createMaterial(static_cast<Storm3D_Material *> (stormMaterial), tree.get());
for(unsigned int i = 0; i < materials.size(); ++i)
{
if(equals(materials[i], material))
return i;
}
int index = materials.size();
material.materialIndex = index;
materials.push_back(material);
return index;
}
// material(name)
static PyObject *graphics_material(PyObject *self, PyObject *args) {
int id;
char *name;
if (!PyArg_ParseTuple(args, (char *)"is:graphics.material", &id, &name))
return NULL;
MoleculeGraphics *mol = mol_from_id(id);
if (!mol)
return NULL;
MaterialList *mlist = get_vmdapp()->materialList;
int matindex = mlist->material_index(name);
if (matindex < 0) {
PyErr_SetString(PyExc_ValueError, (char *)"Invalid material name");
return NULL;
}
int result = mol->use_material(mlist->material(matindex));
return PyInt_FromLong(result);
}
void LoadMaterial(TiXmlElement *element)
{
Material *mtl = NULL;
// name
const char* name = element->Attribute("name");
printf("Material [");
if ( name ) printf("%s",name);
printf("]");
// type
const char* type = element->Attribute("type");
if ( type ) {
if ( COMPARE(type,"blinn") ) {
printf(" - Blinn\n");
MtlBlinn *m = new MtlBlinn();
mtl = m;
for ( TiXmlElement *child = element->FirstChildElement(); child!=NULL; child = child->NextSiblingElement() ) {
Color c(1,1,1);
float f=1;
if ( COMPARE( child->Value(), "diffuse" ) ) {
ReadColor( child, c );
m->SetDiffuse(c);
printf(" diffuse %f %f %f\n",c.r,c.g,c.b);
} else if ( COMPARE( child->Value(), "specular" ) ) {
ReadColor( child, c );
m->SetSpecular(c);
printf(" specular %f %f %f\n",c.r,c.g,c.b);
} else if ( COMPARE( child->Value(), "glossiness" ) ) {
ReadFloat( child, f );
m->SetGlossiness(f);
printf(" glossiness %f\n",f);
}
}
} else {
printf(" - UNKNOWN\n");
}
}
if ( mtl ) {
mtl->SetName(name);
materials.push_back(mtl);
}
}
int LoadScene(const char *filename)
{
cout<<"Load.......";
TiXmlDocument doc(filename);
if ( ! doc.LoadFile() ) {
printf("Failed to load the file \"%s\"\n", filename);
return 0;
}
TiXmlElement *xml = doc.FirstChildElement("xml");
if ( ! xml ) {
printf("No \"xml\" tag found.\n");
return 0;
}
TiXmlElement *scene = xml->FirstChildElement("scene");
if ( ! scene ) {
printf("No \"scene\" tag found.\n");
return 0;
}
TiXmlElement *cam = xml->FirstChildElement("camera");
if ( ! cam ) {
printf("No \"camera\" tag found.\n");
return 0;
}
nodeMtlList.clear();
rootNode.Init();
materials.DeleteAll();
lights.DeleteAll();
LoadScene( scene );
// Assign materials
int numNodes = nodeMtlList.size();
for ( int i=0; i<numNodes; i++ ) {
Material *mtl = materials.Find( nodeMtlList[i].mtlName );
if ( mtl ) nodeMtlList[i].node->SetMaterial(mtl);
}
nodeMtlList.clear();
// Load Camera
camera.Init();
camera.dir += camera.pos;
TiXmlElement *camChild = cam->FirstChildElement();
while ( camChild ) {
if ( COMPARE( camChild->Value(), "position" ) ) ReadVector(camChild,camera.pos);
else if ( COMPARE( camChild->Value(), "target" ) ) ReadVector(camChild,camera.dir);
else if ( COMPARE( camChild->Value(), "up" ) ) ReadVector(camChild,camera.up);
else if ( COMPARE( camChild->Value(), "fov" ) ) ReadFloat (camChild,camera.fov);
else if ( COMPARE( camChild->Value(), "width" ) ) camChild->QueryIntAttribute("value", &camera.imgWidth);
else if ( COMPARE( camChild->Value(), "height" ) ) camChild->QueryIntAttribute("value", &camera.imgHeight);
camChild = camChild->NextSiblingElement();
}
camera.dir -= camera.pos;
camera.dir.Normalize();
Point3 x = camera.dir ^ camera.up;
camera.up = (x ^ camera.dir).GetNormalized();
renderImage.Init( camera.imgWidth, camera.imgHeight );
return 1;
}
void
avtSILRestrictionTraverser::PrepareForMaterialSearches(void)
{
int timingsHandle = visitTimer->StartTimer();
if (silr->GetNumCollections() < 10)
{
bool haveMaterialCollection = false;
for (int c = 0 ; c < silr->GetNumCollections() ; c++)
{
avtSILCollection_p coll = silr->GetSILCollection(c);
if (coll->GetRole() == SIL_MATERIAL)
haveMaterialCollection = true;
}
if (!haveMaterialCollection)
{
noMaterials = true;
preparedForMaterialSearches = true;
visitTimer->StopTimer(timingsHandle,
"Prep for material searches (early return)");
return;
}
}
//TODO: See if this increased size is a problem. -DJB
vector<bool> setIsInProcessList(silr->GetNumSets(), false);
vector<int> setsToProcess;
setsToProcess.push_back(silr->topSet);
setIsInProcessList[silr->topSet] = true;
const vector<unsigned char> &useSet = silr->useSet;
for (int i = 0 ; i < setsToProcess.size() ; i++)
{
if (useSet[setsToProcess[i]] == NoneUsed)
{
continue;
}
if (!silr->SILSetHasMapsOut(setsToProcess[i]))
{
continue;
}
avtSILSet_p currentSet = silr->GetSILSet(setsToProcess[i]);
int chunk = currentSet->GetIdentifier();
const vector<int> &mapsOut = currentSet->GetMapsOut();
for (int j = 0 ; j < mapsOut.size() ; j++)
{
avtSILArray_p pArray = NULL;
avtSILMatrix_p pMat = NULL;
int newCollIndex = 0;
avtSIL::EntryType t = silr->GetCollectionSource(mapsOut[j], pArray,
pMat, newCollIndex);
if (t == avtSIL::COLLECTION || t == avtSIL::ARRAY)
{
avtSILCollection_p coll = silr->GetSILCollection(mapsOut[j]);
if (coll->GetRole() == SIL_MATERIAL)
{
if (chunk == -1)
{
continue;
}
else
{
const avtSILNamespace *ns = coll->GetSubsets();
int numElems = ns->GetNumberOfElements();
int usedOne = 0;
int didntUseOne = 0;
MaterialList l;
for (int k = 0 ; k < numElems ; k++)
{
int setId = ns->GetElement(k);
if (useSet[setId])
{
usedOne++;
l.push_back(
silr->GetSILSet(setId)->GetName());
}
else
{
didntUseOne++;
}
}
bool shouldMatSel = (usedOne != 0 && didntUseOne != 0
? true : false);
AddMaterialList(chunk, l, shouldMatSel);
}
}
else
{
const avtSILNamespace *ns = coll->GetSubsets();
int numElems = ns->GetNumberOfElements();
for (int k = 0 ; k < numElems ; k++)
{
int setId = ns->GetElement(k);
if (!setIsInProcessList[setId])
{
setsToProcess.push_back(setId);
setIsInProcessList[setId] = true;
}
}
}
}
else
{
if (pMat->GetRoleForCollection(newCollIndex) == SIL_MATERIAL)
{
MaterialList l;
bool shouldMatSel = pMat->GetMaterialList(newCollIndex, l,
useSet);
AddMaterialList(chunk, l, shouldMatSel);
}
}
}
}
preparedForMaterialSearches = true;
visitTimer->StopTimer(timingsHandle, "Getting the material list");
visitTimer->DumpTimings();
}
void setSceneSize(const VC3 &size)
{
assert(materials.empty());
tree.reset(new Tree(VC2(-size.x, -size.z), VC2(size.x, size.z)));
}
