Material* XMLReader::LoadMaterial(QXmlStreamReader &xml_reader, const QStringRef &local_path, QMap<QString, QList<Material *> > &map)
{
Material* result;
bool weighted_material = false;
//First check what type of material we're supposed to load
QXmlStreamAttributes attribs(xml_reader.attributes());
QStringRef type = attribs.value(QString(), QString("type"));
if(QStringRef::compare(type, QString("default")) == 0)
{
result = new Material();
}
else if(QStringRef::compare(type, QString("light")) == 0)
{
result = new LightMaterial();
result->is_light_source = true;
QStringRef intensity = attribs.value(QString(), QString("intensity"));
if(QStringRef::compare(intensity, QString("")) != 0)
{
result->intensity = intensity.toFloat();
}
}
else if(QStringRef::compare(type, QString("weighted")) == 0)
{
result = new WeightedMaterial();
weighted_material = true;
//weights are handled below
}
else
{
std::cout << "Could not parse the material!" << std::endl;
return NULL;
}
result->name = attribs.value(QString(), QString("name")).toString();
while(!xml_reader.isEndElement() || QStringRef::compare(xml_reader.name(), QString("material")) != 0)
{
xml_reader.readNext();
QString tag(xml_reader.name().toString());
if(QString::compare(tag, QString("baseColor")) == 0)
{
xml_reader.readNext();
if(xml_reader.isCharacters())
{
result->base_color = ToVec3(xml_reader.text());
}
xml_reader.readNext();
}
else if(QString::compare(tag, QString("bxdf")) == 0)
{
//Add the Material to the map of BxDF names to Materials so that we can assign it a BxDF later
xml_reader.readNext();
if(xml_reader.isCharacters())
{
QString bxdf_name = xml_reader.text().toString();
QList<Material*> list = map.value(bxdf_name);
list.append(result);
map.insert(bxdf_name, list);
xml_reader.readNext();
}
}
else if(QString::compare(tag, QString("texture")) == 0)
{
result->texture = LoadTextureFile(xml_reader, local_path);
}
else if(QString::compare(tag, QString("normalMap")) == 0)
{
result->normal_map = LoadTextureFile(xml_reader, local_path);
}
else if(QString::compare(tag, QString("weight")) == 0 && weighted_material)
{
xml_reader.readNext();
float weight;
if(xml_reader.isCharacters())
{
weight = xml_reader.text().toFloat();
}
((WeightedMaterial*)result)->bxdf_weights.append(weight);
xml_reader.readNext(); // add this line
}
}
return result;
}
/*****************************************************
Reads and loads data from assets.dat file into one of
the vectors below.
std::vector<GRAPHIC_FILE_DATA> m_assetFileData;
std::vector<SPRITE_DATA> m_assetSpriteData;
std::vector<MESH_DATA> m_assetMeshData;
std::vector<SOUND_FILE_DATA> m_assetSoundData;
Parameters in cfr begin with 1 not 0
*****************************************************/
bool CGraphics::LoadAssetFile(std::string filename){
CLog *pLog = CLog::Instance();
//validate asset data and add to appropriate vectors
std::string parameter;
std::string assetType;
GRAPHIC_FILE_DATA tempGraphic;
SPRITE_DATA tempSprite;
CCSVReader csv;
csv.LoadFile(filename);
//new stuff
for(int i = 0; i < csv.GetTableSize(); ++i){
if(csv.GetNumberParameters(i) > 1){
assetType = csv.GetTerm(i, 0);
if(assetType == "texture" && csv.GetNumberParameters(i) == 4){
parameter = csv.GetTerm(i, 1);//fileID
tempGraphic.fileID = atoi(parameter.c_str());
parameter = csv.GetTerm(i, 2);//filename
tempGraphic.filename = parameter;
parameter = csv.GetTerm(i, 3);//description
tempGraphic.description = parameter;
m_assetFileData.push_back(tempGraphic);
}
else if(assetType == "sprite" && csv.GetNumberParameters(i) == 14 ){// && csv.GetNumberParameters(i) == 14){
parameter = csv.GetTerm(i, 1);//spriteID
tempSprite.spriteID = atoi(parameter.c_str());
parameter = csv.GetTerm(i, 2);//fileID
tempSprite.fileID = atoi(parameter.c_str());
parameter = csv.GetTerm(i, 3);//left
tempSprite.x = static_cast<float>(atof(parameter.c_str()));
parameter = csv.GetTerm(i, 4);//right
tempSprite.y = static_cast<float>(atof(parameter.c_str()));
parameter = csv.GetTerm(i, 5);//width
tempSprite.width = static_cast<float>(atof(parameter.c_str()));
parameter = csv.GetTerm(i, 6);//height
tempSprite.height = static_cast<float>(atof(parameter.c_str()));
parameter = csv.GetTerm(i, 7);//scale
tempSprite.scale = static_cast<float>(atof(parameter.c_str()));
parameter = csv.GetTerm(i, 8);//angle
tempSprite.angle = static_cast<float>(atof(parameter.c_str()));
parameter = csv.GetTerm(i, 9);//alpha
tempSprite.alpha = atoi(parameter.c_str());
parameter = csv.GetTerm(i, 10);//total number of frames
tempSprite.numberFrames = atoi(parameter.c_str());
parameter = csv.GetTerm(i, 11);//framecount, starting frame
tempSprite.frameCount = atoi(parameter.c_str());
parameter = csv.GetTerm(i, 12);//time between frames
tempSprite.timeBetweenFrames = atof(parameter.c_str());// static_cast<float>(atof(parameter.c_str()));
parameter = csv.GetTerm(i, 13);//description
tempSprite.description = parameter;
m_assetSpriteData.push_back(tempSprite);
}
}
}
//load graphics files
for(unsigned int i = 0; i < m_assetFileData.size(); ++i){
LoadTextureFile(m_assetFileData[i].fileID, "assets//graphics//" + m_assetFileData[i].filename);
}
pLog->Log("Exit loading of files");
//load sprite information
GRAPHIC_IMAGE gi;
for(unsigned int i = 0; i < m_assetSpriteData.size(); ++i){
gi.spriteID = m_assetSpriteData[i].spriteID;
gi.fileID = m_assetSpriteData[i].fileID;
gi.sourceX = static_cast<int>(m_assetSpriteData[i].x);
gi.sourceY = static_cast<int>(m_assetSpriteData[i].y);
gi.width = static_cast<int>(m_assetSpriteData[i].width);
gi.height = static_cast<int>(m_assetSpriteData[i].height);
gi.scale = m_assetSpriteData[i].scale;
gi.alpha = m_assetSpriteData[i].alpha;
gi.angle = m_assetSpriteData[i].angle;
gi.frameMax = m_assetSpriteData[i].numberFrames;
gi.updateInterval = m_assetSpriteData[i].timeBetweenFrames;
gi.frameCount = 0;
gi.screenScale = 1.0; //added 4.8.09 by CB used in passing screen scale to render function
//ensure the fileID really exists
gi.bValid = false; //assume file is invalid
for(unsigned int j = 0; j < m_assetFileData.size(); ++j){
if(gi.fileID == m_assetFileData[j].fileID){
gi.bValid = true;
m_sprites.push_back(gi);
break;
}
}
}
return true;
}
IMAGEFILE *iV_LoadImageFile(const char *fileName)
{
char *pFileData, *ptr, *dot;
unsigned int pFileSize, numImages = 0, i, tPages = 0;
IMAGEFILE *ImageFile;
char texFileName[PATH_MAX];
if (!loadFile(fileName, &pFileData, &pFileSize))
{
debug(LOG_ERROR, "iV_LoadImageFile: failed to open %s", fileName);
return NULL;
}
ptr = pFileData;
// count lines, which is identical to number of images
while (ptr < pFileData + pFileSize && *ptr != '\0')
{
numImages += (*ptr == '\n') ? 1 : 0;
ptr++;
}
ImageFile = (IMAGEFILE *)malloc(sizeof(IMAGEFILE) + sizeof(IMAGEDEF) * numImages);
ImageFile->ImageDefs = (IMAGEDEF*)(ImageFile + 1); // we allocated extra space for it
ptr = pFileData;
numImages = 0;
while (ptr < pFileData + pFileSize)
{
int temp, retval;
IMAGEDEF *ImageDef = &ImageFile->ImageDefs[numImages];
retval = sscanf(ptr, "%u,%u,%u,%u,%u,%d,%d%n", &ImageDef->TPageID, &ImageDef->Tu, &ImageDef->Tv, &ImageDef->Width,
&ImageDef->Height, &ImageDef->XOffset, &ImageDef->YOffset, &temp);
if (retval != 7)
{
break;
}
ptr += temp;
numImages++;
// Find number of texture pages to load (no gaps allowed in number series, eg use intfac0, intfac1, etc.!)
if (ImageDef->TPageID > tPages)
{
tPages = ImageDef->TPageID;
}
while (ptr < pFileData + pFileSize && *ptr++ != '\n') {} // skip rest of line
}
dot = (char *)strrchr(fileName, '/'); // go to last path character
dot++; // skip it
strcpy(texFileName, dot); // make a copy
dot = strchr(texFileName, '.'); // find extension
*dot = '\0'; // then discard it
// Load the texture pages.
for (i = 0; i <= tPages; i++)
{
char path[PATH_MAX];
snprintf(path, PATH_MAX, "%s%u.png", texFileName, i);
ImageFile->TPageIDs[i] = LoadTextureFile(path);
}
ImageFile->NumImages = numImages;
free(pFileData);
return ImageFile;
}