/// converting <mtable> ... </mtable>
void CMathMLToTeX::mtableNode(QString &text)
{
int sumCols = 0;
if (text.contains("<mtr>"))
{
int posA = text.indexOf("<mtr>");
int posB = text.indexOf("</mtr>");
QString mtrText = text.mid(posA, posB - posA + 6);
sumCols = mtrText.count("<mtd");
}
CStructureParser xmlParser(sumCols);
QXmlSimpleReader xmlReader;
xmlReader.setContentHandler(&xmlParser);
QXmlInputSource xmlSource;
xmlSource.setData(text);
xmlReader.parse(xmlSource);
text = xmlParser.getTeX();
}
HRESULT CDataConnector::RequestXML(VARIANT Val, IXMLElementHandler* ElementHandler)
{
HRESULT hr = E_OUTOFMEMORY;
CXMLParser xmlParser(ElementHandler);
hr = xmlParser.Parse(Val);
return hr;
}
/// normal equation node
void CMathMLToTeX::mNode(QString &text)
{
CStructureParser xmlParser(0);
QXmlSimpleReader xmlReader;
xmlReader.setContentHandler(&xmlParser);
QXmlInputSource xmlSource;
xmlSource.setData(text);
xmlReader.parse(xmlSource);
text = xmlParser.getTeX();
}
//
// _readXML:
//
void Parser::_readXML(std::string data)
{
// xmlNode *currentNode = NULL;
XMLTableParser xmlParser( &_xmlTagManager ); // initialize the XML parser
xmlDoc *document; // XML document
xmlNode *rootElement;
//
// VALGRIND ERROR --------- UNABLE TO FIX IT //
//
document = xmlReadMemory(data.c_str(), data.size(),NULL, NULL, 0);
rootElement = xmlDocGetRootElement(document);
//
// Store pointers to all of the table nodes:
//
_countTables(rootElement);
//
// Message for user:
//
unsigned tableCount = _xmlTableTagPointers.size();
std::cout << "There " << (tableCount==1?"is ":"are ") << tableCount ;
std::cout << " table" << (tableCount==1?"":"s") << std::endl;
//
// Read each table in the XML file into a DataTable:
//
for(unsigned int i=0; i < tableCount; i++){
if( xmlParser.readString(data,_xmlTableTagPointers[i]) ){
DataTable *xmlTable = new DataTable(xmlParser);
_tables.push_back( xmlTable );
}
}
free(document);
free(rootElement);
_xmlTableTagPointers.clear();
std::cout << "End of Parser::_readXML() method." << std::endl;
}
//==================================================================================================================================
bool ZShadeXMLLoader::LoadWorldXML(string worldname, SPlatformerWorld*& sworld)
{
if (sworld == NULL)
sworld = new SPlatformerWorld();
XMLParser xmlParser(worldname);
const char* name_str = xmlParser.ReadElement("name");
sworld->sWorldName = string(name_str);
ArrayElementXMLParser worldMapParser(xmlParser.Element());
worldMapParser.ReadArrayElement("Maps", "Map");
do
{
string eName = worldMapParser.ReadArrayElementValue();
string eIDAtt = worldMapParser.ReadArrayElementAttribute("id");
const char* map_name_str = worldMapParser.ReadArrayChildElement("map_name");
sworld->m_mapNames.push_back(map_name_str);
} while (worldMapParser.ArrayElementNotNull("Map"));
return true;
}
bool KXSConfigDialog::create()
{
TQVBoxLayout *topLayout = new TQVBoxLayout(plainPage(), spacingHint());
TQHBoxLayout *tqlayout = new TQHBoxLayout(topLayout, spacingHint());
TQVBox *controlLayout = new TQVBox(plainPage());
controlLayout->setSpacing(spacingHint());
tqlayout->addWidget(controlLayout);
((TQBoxLayout*)controlLayout->tqlayout())->addStrut(120);
KConfig config(mConfigFile);
TQString xmlFile = "/doesntexist";
#ifdef XSCREENSAVER_CONFIG_DIR
xmlFile = XSCREENSAVER_CONFIG_DIR;
#endif
xmlFile += "/" + mExeName + ".xml";
if ( TQFile::exists( xmlFile ) ) {
// We can use the xscreensaver xml config files.
KXSXml xmlParser(controlLayout);
xmlParser.parse( xmlFile );
mConfigItemList = *xmlParser.items();
TQWidget *spacer = new TQWidget(controlLayout);
controlLayout->setStretchFactor(spacer, 1 );
TQString descr = xmlParser.description();
if ( !descr.isEmpty() ) {
descr.replace('\n',' ');
descr = descr.simplifyWhiteSpace();
TQLabel *l = new TQLabel( i18n( descr.utf8() ), plainPage() );
l->tqsetAlignment ( WordBreak );
topLayout->addWidget( l );
}
} else {
// fall back to KDE's old config files.
int idx = 0;
while (true) {
TQString group = TQString("Arg%1").tqarg(idx);
if (config.hasGroup(group)) {
config.setGroup(group);
TQString type = config.readEntry("Type");
if (type == "Range") {
KXSRangeControl *rc = new KXSRangeControl(controlLayout, group, config);
mConfigItemList.append(rc);
} else if (type == "DoubleRange") {
KXSDoubleRangeControl *rc =
new KXSDoubleRangeControl(controlLayout, group, config);
mConfigItemList.append(rc);
} else if (type == "Check") {
KXSCheckBoxControl *cc = new KXSCheckBoxControl(controlLayout, group,
config);
mConfigItemList.append(cc);
} else if (type == "DropList") {
KXSDropListControl *dl = new KXSDropListControl(controlLayout, group,
config);
mConfigItemList.append(dl);
}
} else {
break;
}
idx++;
}
if ( idx == 0 )
return false;
}
TQPtrListIterator<KXSConfigItem> it( mConfigItemList );
KXSConfigItem *item;
while ( (item = it.current()) != 0 ) {
++it;
item->read( config );
TQWidget *i = dynamic_cast<TQWidget*>(item);
if (i) {
connect( i, TQT_SIGNAL(changed()), TQT_SLOT(slotChanged()) );
}
}
mPreviewProc = new KProcess;
connect(mPreviewProc, TQT_SIGNAL(processExited(KProcess *)),
TQT_SLOT(slotPreviewExited(KProcess *)));
mPreviewTimer = new TQTimer(this);
connect(mPreviewTimer, TQT_SIGNAL(timeout()), TQT_SLOT(slotNewPreview()));
mPreview = new TQWidget(plainPage());
mPreview->setFixedSize(250, 200);
// mPreview->setBackgroundMode(TQWidget::NoBackground);
mPreview->setBackgroundColor(TQt::black);
tqlayout->add(mPreview);
show();
// So that hacks can XSelectInput ButtonPressMask
XSelectInput(qt_xdisplay(), mPreview->winId(), widgetEventMask );
slotPreviewExited(0);
return true;
}
std::shared_ptr<SPICE::BIG::IXMLParser> ResourceProvider::getNewXMLParserInstance()
{
std::shared_ptr<SPICE::XML::POCO::XMLParserPoco> xmlParser(new SPICE::XML::POCO::XMLParserPoco());
return xmlParser;
}
//================================================================================================================
bool ZShadeXMLLoader::LoadMapXML(string& mapname, string filename, GameDirectory2D* gd, D3D* d3d, PlatformerMap*& map, bool inEditor)
{
XMLParser xmlParser(filename);
const char* map_name_str = xmlParser.ReadElement("map_name");
const char* xml_sprite_str = xmlParser.ReadElement("xml_sprite");
const char* xml_music_str = xmlParser.ReadElement("music");
const char* width_str = xmlParser.ReadElement("width");
const char* height_str = xmlParser.ReadElement("height");
int map_width = atoi(width_str);
int map_height = atoi(height_str);
d3d->GetEngineOptions()->SECTION_ROW_SIZE = map_width;
d3d->GetEngineOptions()->SECTION_COL_SIZE = map_height;
d3d->GetEngineOptions()->SetTileMax();
PlatformerMapLoadData pmld;
ArrayElementXMLParser tilesParser(xmlParser.Element());
tilesParser.ReadArrayElement("Tiles", "Tile");
do
{
string eName = tilesParser.ReadArrayElementValue();
string eIDAtt = tilesParser.ReadArrayElementAttribute("id");
string eImageNameAtt = tilesParser.ReadArrayElementAttribute("image");
const char* x_str = tilesParser.ReadArrayChildElement("x");
const char* y_str = tilesParser.ReadArrayChildElement("y");
const char* animation_str = tilesParser.ReadArrayChildElement("animation");
const char* anim_speed_str = tilesParser.ReadArrayChildElement("anim_speed");
const char* hard_str = tilesParser.ReadArrayChildElement("hard");
const char* invisible_str = tilesParser.ReadArrayChildElement("invisible");
const char* physics_type_str = tilesParser.ReadArrayChildElement("physics_type");
const char* surface_type_str = tilesParser.ReadArrayChildElement("surface_type");
int x = atoi(x_str);
int y = atoi(y_str);
int anim_speed = atoi(anim_speed_str);
int hard = atoi(hard_str);
int invisible = atoi(invisible_str);
pmld.imageNames.push_back(eImageNameAtt);
pmld.animProfileNames.push_back(string(animation_str));
pmld.animSpeeds.push_back(anim_speed);
pmld.hards.push_back(hard);
pmld.invisibles.push_back(invisible);
pmld.physicsTypes.push_back(string(physics_type_str));
pmld.surfaceTypes.push_back(string(surface_type_str));
} while (tilesParser.ArrayElementNotNull("Tile"));
map = new PlatformerMap(d3d, gd);
if (!map) return false;
map->MapName() = mapname;
map->MusicName() = string(xml_music_str);
map->Initialize(map_width, map_height, pmld);
//BetterString str(gd->m_xml_sprites_path);
//str += "\\";
//str += xml_sprite_str;
//Load the sprites onto the map
LoadSpritesXML(xml_sprite_str, gd, d3d, map);
return true;
}
//===============================================================================================================================
bool ZShadeXMLLoader::LoadHUDXML(string filename, GameDirectory2D* gd, EngineOptions* eo, D3D* d3d, HUD*& hs)
{
XMLParser xmlParser(filename);
const char* hud_size_str = xmlParser.ReadElement("hud_size");
BetterString hud_splite_str(hud_size_str);
vector<string> split_str = hud_splite_str.split('x');
int width = atoi(split_str[0].c_str());
int height = atoi(split_str[1].c_str());
if (hs == 0)
{
hs = new HUD(d3d);
}
hs->Width() = width;
hs->Height() = height;
ArrayElementXMLParser imagesParser(xmlParser.Element());
imagesParser.ReadArrayElement("Images", "Image");
do
{
string eName = imagesParser.ReadArrayElementValue();
string eIDAtt = imagesParser.ReadArrayElementAttribute("id");
const char* x_str = imagesParser.ReadArrayChildElement("image_x");
const char* y_str = imagesParser.ReadArrayChildElement("image_y");
const char* image_width_str = imagesParser.ReadArrayChildElement("image_width");
const char* image_height_str = imagesParser.ReadArrayChildElement("image_height");
const char* image_name_str = imagesParser.ReadArrayChildElement("image_name");
ZShadeSandboxGraphics::Image* im = new ZShadeSandboxGraphics::Image(
d3d,
string(image_name_str),
gd->m_hud_path,
atof(x_str),
atof(y_str),
atoi(image_width_str),
atoi(image_height_str)
);
hs->AddImage(im);
} while (imagesParser.ArrayElementNotNull("Image"));
ArrayElementXMLParser textsParser(xmlParser.Element());
textsParser.ReadArrayElement("Texts", "Text");
do
{
string eName = textsParser.ReadArrayElementValue();
string eIDAtt = textsParser.ReadArrayElementAttribute("id");
const char* x_str = textsParser.ReadArrayChildElement("text_x");
const char* y_str = textsParser.ReadArrayChildElement("text_y");
const char* text_str = textsParser.ReadArrayChildElement("text");
const char* text_font_str = textsParser.ReadArrayChildElement("text_font");
const char* text_color_str = textsParser.ReadArrayChildElement("text_color");
const char* shadow_str = textsParser.ReadArrayChildElement("shadow");
const char* optional_background_str = textsParser.ReadArrayChildElement("optional_background");
XMFLOAT3 color = ZShadeSandboxGlobal::Convert::ConvertToFloat3(string(text_color_str));
bool shadow = (string(shadow_str) == "1") ? true : false;
ZShadeSandboxGraphics::Text* t = new ZShadeSandboxGraphics::Text();
t->SetD3D(d3d);
t->Initialize();
t->TextName() = BetterString(text_str);
if (shadow)
{
t->CreateShadow();
}
t->ChangeFont(L"Times New Roman", atoi(text_font_str), FontStyle::BoldItalic, true);
t->TextTransform() = XMMatrixTranslation(atof(x_str), atof(y_str), 0);
t->TextColor() = XMFLOAT4(color.x, color.y, color.z, 1);
hs->AddText(t);
} while (textsParser.ArrayElementNotNull("Text"));
return true;
}
//===============================================================================================================================
bool ZShadeXMLLoader::LoadMaterialXML(string basePath, string filename, D3D* d3d)
{
XMLParser xmlParser(filename);
const char* material_name_str = xmlParser.ReadElement("Name");
const char* enable_shadowmap_str = xmlParser.ReadElement("EnableShadowMap");
const char* enable_ssao_str = xmlParser.ReadElement("EnableSSAO");
const char* enable_transparency_str = xmlParser.ReadElement("EnableTransparency");
const char* enable_lighting_str = xmlParser.ReadElement("EnableLighting");
const char* detail_brightness_str = xmlParser.ReadElement("DetailBrightness");
const char* alpha_to_coverage_str = xmlParser.ReadElement("AlphaToCoverage");
const char* ambient_color_str = xmlParser.ReadElement("AmbientColor");
const char* diffuse_color_str = xmlParser.ReadElement("DiffuseColor");
const char* specular_color_str = xmlParser.ReadElement("SpecularColor");
const char* emissive_color_str = xmlParser.ReadElement("EmissiveColor");
const char* specular_power_str = xmlParser.ReadElement("SpecularPower");
const char* specular_intensity_str = xmlParser.ReadElement("SpecularIntensity");
const char* emissive_str = xmlParser.ReadElement("Emissivity");
const char* reflectivity_str = xmlParser.ReadElement("Reflectivity");
const char* transmissivity_str = xmlParser.ReadElement("Transmissivity");
const char* transmission_filter_str = xmlParser.ReadElement("TransmissionFilter");
const char* alpha_str = xmlParser.ReadElement("Alpha");
const char* refraction_index_str = xmlParser.ReadElement("RefractionIndex");
const char* no_dist_tess_factor_str = xmlParser.ReadElement("NoDistTessFactor");
const char* min_tess_dist_str = xmlParser.ReadElement("MinTessDist");
const char* max_tess_dist_str = xmlParser.ReadElement("MaxTessDist");
const char* min_tess_factor_str = xmlParser.ReadElement("MinTessFactor");
const char* max_tess_factor_str = xmlParser.ReadElement("MaxTessFactor");
const char* enable_dist_tess_str = xmlParser.ReadElement("EnableDistTess");
const char* illumination_model_str = xmlParser.ReadElement("IlluminationModel");
vector<string> diffuseArrayTextureNames;
ArrayElementXMLParser diffuseArrayParser(xmlParser.Element());
diffuseArrayParser.ReadArrayElement("DiffuseArray", "Texture");
do
{
string eName = diffuseArrayParser.ReadArrayElementValue();
string eIDAtt = diffuseArrayParser.ReadArrayElementAttribute("id");
const char* tex_name_str = diffuseArrayParser.ReadArrayChildElement("TexName");
diffuseArrayTextureNames.push_back(string(tex_name_str));
} while (diffuseArrayParser.ArrayElementNotNull("Texture"));
const char* diffuse_texture_str = xmlParser.ReadElement("DiffuseTexture");
const char* ambient_texture_str = xmlParser.ReadElement("AmbientTexture");
const char* specular_texture_str = xmlParser.ReadElement("SpecularTexture");
const char* emissive_texture_str = xmlParser.ReadElement("EmissiveTexture");
const char* detail_texture_str = xmlParser.ReadElement("DetailTexture");
const char* normal_texture_str = xmlParser.ReadElement("NormalTexture");
const char* blend_texture_str = xmlParser.ReadElement("BlendTexture");
const char* alpha_texture_str = xmlParser.ReadElement("AlphaTexture");
string name(material_name_str);
bool enableShadowMap = (BetterString(enable_shadowmap_str) == "true") ? true : false;
bool enableSSAO = (BetterString(enable_ssao_str) == "true") ? true : false;
bool enableTransparency = (BetterString(enable_transparency_str) == "true") ? true : false;
bool enableLighting = (BetterString(enable_lighting_str) == "true") ? true : false;
float detailBrightness = atof(detail_brightness_str);
XMFLOAT3 alphaToCoverage = ZShadeSandboxGlobal::Convert::ConvertToFloat3(alpha_to_coverage_str);
XMFLOAT4 ambientColor = ZShadeSandboxGlobal::Convert::ConvertToFloat4(ambient_color_str);
XMFLOAT4 diffuseColor = ZShadeSandboxGlobal::Convert::ConvertToFloat4(diffuse_color_str);
XMFLOAT4 specularColor = ZShadeSandboxGlobal::Convert::ConvertToFloat4(specular_color_str);
XMFLOAT4 emissiveColor = ZShadeSandboxGlobal::Convert::ConvertToFloat4(emissive_color_str);
float specularPower = atof(specular_power_str);
float specularIntensity = atof(specular_intensity_str);
float emissive = atof(emissive_str);
float reflectivity = atof(reflectivity_str);
float transmissivity = atof(transmissivity_str);
float alpha = atof(alpha_str);
XMFLOAT3 transmissionFilter = ZShadeSandboxGlobal::Convert::ConvertToFloat3(transmission_filter_str);
float refractionIndex = atof(refraction_index_str);
float noDistTessFactor = atof(no_dist_tess_factor_str);
float minTessDist = atof(min_tess_dist_str);
float maxTessDist = atof(max_tess_dist_str);
float minTessFactor = atof(min_tess_factor_str);
float maxTessFactor = atof(max_tess_factor_str);
bool enableDistTess = (BetterString(enable_dist_tess_str) == "true") ? true : false;
int illuminationModel = atoi(illumination_model_str);
string diffuseTextureName(diffuse_texture_str);
string ambientTextureName(ambient_texture_str);
string specularTextureName(specular_texture_str);
string emissiveTextureName(emissive_texture_str);
string detailTextureName(detail_texture_str);
string normalTextureName(normal_texture_str);
string blendTextureName(blend_texture_str);
string alphaTextureName(alpha_texture_str);
//
// Load the material into the material manager
//
ZShadeSandboxLighting::ShaderMaterial* material = new ZShadeSandboxLighting::ShaderMaterial(d3d, name);
material->bHasShadowMap = enableShadowMap;
material->bHasSSAOMap = enableSSAO;
material->bHasTransparency = enableTransparency;
material->bEnableLighting = enableLighting;
material->fDetailBrightness = detailBrightness;
material->vAlphaToCoverageValue = alphaToCoverage;
material->vAmbientColor = ambientColor;
material->vDiffuseColor = diffuseColor;
material->vSpecularColor = specularColor;
material->vEmissiveColor = emissiveColor;
bool hasDiffuseArrayTexture;
(BetterString(diffuseArrayTextureNames[0]) == "NONE") ? hasDiffuseArrayTexture = false : hasDiffuseArrayTexture = true;
if (hasDiffuseArrayTexture)
material->CreateTexture2DArray(diffuseArrayTextureNames);
material->fSpecularPower = specularPower;
material->fSpecularIntensity = specularIntensity;
material->fEmissivity = emissive;
material->fReflectivity = reflectivity;
material->fTransmissivity = transmissivity;
material->fAlpha = alpha;
material->vTransmissionFilter = transmissionFilter;
material->fRefractionIndex = refractionIndex;
material->fNoDistTessFactor = noDistTessFactor;
material->fMinTessDist = minTessDist;
material->fMaxTessDist = maxTessDist;
material->fMinTessFactor = minTessFactor;
material->fMaxTessFactor = maxTessFactor;
material->bEnableDistTess = enableDistTess;
material->iIlluminationModel = illuminationModel;
bool hasDiffuseTexture;
(BetterString(diffuseTextureName) == "NONE") ? hasDiffuseTexture = false : hasDiffuseTexture = true;
if (hasDiffuseTexture)
material->AddDiffuseTexture(basePath, diffuseTextureName);
bool hasAmbientTexture;
(BetterString(ambientTextureName) == "NONE") ? hasAmbientTexture = false : hasAmbientTexture = true;
if (hasAmbientTexture)
material->AddAmbientTexture(basePath, ambientTextureName);
bool hasSpecularTexture;
(BetterString(specularTextureName) == "NONE") ? hasSpecularTexture = false : hasSpecularTexture = true;
if (hasSpecularTexture)
material->AddSpecularTexture(basePath, specularTextureName);
bool hasEmissiveTexture;
(BetterString(emissiveTextureName) == "NONE") ? hasEmissiveTexture = false : hasEmissiveTexture = true;
if (hasEmissiveTexture)
material->AddEmissiveTexture(basePath, emissiveTextureName);
bool hasDetailTexture;
(BetterString(detailTextureName) == "NONE") ? hasDetailTexture = false : hasDetailTexture = true;
if (hasDetailTexture)
material->AddDetailMapTexture(basePath, detailTextureName);
bool hasNormalMapTexture;
(BetterString(normalTextureName) == "NONE") ? hasNormalMapTexture = false : hasNormalMapTexture = true;
if (hasNormalMapTexture)
material->AddNormalMapTexture(basePath, normalTextureName);
bool hasBlendMapTexture;
(BetterString(blendTextureName) == "NONE") ? hasBlendMapTexture = false : hasBlendMapTexture = true;
if (hasBlendMapTexture)
material->AddBlendMapTexture(basePath, blendTextureName);
bool hasAlphaMapTexture;
(BetterString(alphaTextureName) == "NONE") ? hasAlphaMapTexture = false : hasAlphaMapTexture = true;
if (hasAlphaMapTexture)
material->AddAlphaMapTexture(basePath, alphaTextureName);
material->bHasDiffuseArrayTexture = hasDiffuseArrayTexture;
material->bHasDiffuseTexture = hasDiffuseTexture;
material->bHasAmbientTexture = hasAmbientTexture;
material->bHasSpecularTexture = hasSpecularTexture;
material->bHasEmissiveTexture = hasEmissiveTexture;
material->bHasDetailMapTexture = hasDetailTexture;
material->bHasNormalMapTexture = hasNormalMapTexture;
material->bHasBlendMapTexture = hasBlendMapTexture;
material->bHasAlphaMapTexture = hasAlphaMapTexture;
MaterialManager::Instance()->Add(material);
return true;
}
//================================================================================================================
bool ZShadeXMLLoader::LoadSpritesXML(string spriteMapfilename, GameDirectory2D* gd, D3D* d3d, PlatformerMap*& map)
{
XMLParser xmlParser(spriteMapfilename);
AISprite *spr;
ArrayElementXMLParser spritesParser(xmlParser.Element());
spritesParser.ReadArrayElement("Sprite");
do
{
string eName = spritesParser.ReadArrayElementValue();
string eIDAtt = spritesParser.ReadArrayElementAttribute("id");
const char* player_str = spritesParser.ReadArrayChildElement("player");
const char* x_str = spritesParser.ReadArrayChildElement("x");
const char* y_str = spritesParser.ReadArrayChildElement("y");
const char* width_str = spritesParser.ReadArrayChildElement("width");
const char* height_str = spritesParser.ReadArrayChildElement("height");
const char* hbox_x_str = spritesParser.ReadArrayChildElement("hbox_x");
const char* hbox_y_str = spritesParser.ReadArrayChildElement("hbox_y");
const char* hbox_width_str = spritesParser.ReadArrayChildElement("hbox_width");
const char* hbox_height_str = spritesParser.ReadArrayChildElement("hbox_height");
const char* baseimage_str = spritesParser.ReadArrayChildElement("baseimage");
const char* hard_str = spritesParser.ReadArrayChildElement("hard");
const char* nohit_str = spritesParser.ReadArrayChildElement("nohit");
const char* animation_name_str = spritesParser.ReadArrayChildElement("animation");
const char* default_seq_str = spritesParser.ReadArrayChildElement("default_seq");
const char* anim_speed_str = spritesParser.ReadArrayChildElement("anim_speed");
const char* hp_str = spritesParser.ReadArrayChildElement("hp");
const char* hp_max_str = spritesParser.ReadArrayChildElement("hp_max");
const char* mana_str = spritesParser.ReadArrayChildElement("mana");
const char* gold_str = spritesParser.ReadArrayChildElement("gold");
const char* strength_str = spritesParser.ReadArrayChildElement("strength");
const char* speed_str = spritesParser.ReadArrayChildElement("speed");
const char* defense_str = spritesParser.ReadArrayChildElement("defense");
const char* experience_str = spritesParser.ReadArrayChildElement("experience");
const char* level_str = spritesParser.ReadArrayChildElement("level");
const char* script_str = spritesParser.ReadArrayChildElement("script");
const char* touch_str = spritesParser.ReadArrayChildElement("touch");
const char* background_str = spritesParser.ReadArrayChildElement("background");
const char* entity_str = spritesParser.ReadArrayChildElement("entity");
const char* invisible_str = spritesParser.ReadArrayChildElement("invisible");
const char* static_str = spritesParser.ReadArrayChildElement("static");
const char* name_str = spritesParser.ReadArrayChildElement("name");
const char* collide_msg_str = spritesParser.ReadArrayChildElement("collide_msg");
const char* inventory_msg_str = spritesParser.ReadArrayChildElement("inventory_msg");
const char* seen_by_player_str = spritesParser.ReadArrayChildElement("always_seen_by_player");
const char* teleport_str = spritesParser.ReadArrayChildElement("teleport");
const char* teleport_map_str = spritesParser.ReadArrayChildElement("teleport_map");
const char* teleport_map_x_str = spritesParser.ReadArrayChildElement("teleport_map_x");
const char* teleport_map_y_str = spritesParser.ReadArrayChildElement("teleport_map_y");
bool is_player = (string(player_str) == "true") ? true : false;
float x = atof(x_str);
float y = atof(y_str);
int width = atoi(width_str);
int height = atoi(height_str);
float hbox_x = atof(hbox_x_str);
float hbox_y = atof(hbox_y_str);
int hbox_width = atoi(hbox_width_str);
int hbox_height = atoi(hbox_height_str);
int hard = atoi(hard_str);
int nohit = atoi(nohit_str);
int default_seq = atoi(default_seq_str);
int anim_speed = atoi(anim_speed_str);
int hp = atoi(hp_str);
int hp_max = atoi(hp_max_str);
int mana = atoi(mana_str);
int gold = atoi(gold_str);
int strength = atoi(strength_str);
//int speed = atoi(speed_str);
int defense = atoi(defense_str);
int experience = atoi(experience_str);
int level = atoi(level_str);
bool touch = (string(touch_str) == "true") ? true : false;
bool background = (string(background_str) == "true") ? true : false;
bool entity = (string(entity_str) == "true") ? true : false;
bool invisible = (string(invisible_str) == "true") ? true : false;
bool is_static = (string(static_str) == "true") ? true : false;
bool teleport = (string(teleport_str) == "true") ? true : false;
int teleport_map_x = atoi(teleport_map_x_str);
int teleport_map_y = atoi(teleport_map_y_str);
bool seen_by_player = (string(seen_by_player_str) == "true") ? true : false;
XMFLOAT3 speed = ZShadeSandboxGlobal::Convert::ConvertToFloat3(speed_str);
string path;
if (strcmp(baseimage_str, "player_cover.png") == 0)
{
path = gd->m_required_textures;
}
else
{
path = gd->m_sprites_path;
}
PhysicsType pt;
if (is_static)
pt = STATIC;
else
pt = DYNAMIC;
spr = new AISprite(d3d);
spr->Initialize(path, string(baseimage_str), XMFLOAT3(x, y, 0), width, height, pt);
spr->ScriptName() = string(script_str);
spr->PlatformerSprite() = true; // This is a sprite on a Platformer map
spr->ID() = atoi(eIDAtt.c_str());
spr->IsHard() = hard;
spr->IsNoHit() = nohit;
spr->AnimationProfileName() = string(animation_name_str);
spr->DefaultSequence() = default_seq;
spr->AnimationSpeed() = anim_speed;
spr->HP() = hp;
spr->Mana() = mana;
spr->Gold() = gold;
spr->Strength() = strength;
spr->SpeedX() = speed.x;
spr->SpeedY() = speed.y;
spr->Defense() = defense;
spr->Experience() = experience;
spr->Level() = level;
spr->IsTouch() = touch;
spr->IsBackgroundSprite() = background;
spr->IsEntitySprite() = entity;
spr->IsInvisibleSprite() = invisible;
spr->CanTeleport() = teleport;
spr->TeleportMapName() = string(teleport_map_str);
spr->TeleportX() = teleport_map_x;
spr->TeleportY() = teleport_map_y;
spr->Name() = string(name_str);
spr->HPMax() = hp_max;
//spr->IsStatic() = is_static;
spr->EPhysicsType() = (is_static) ? STATIC : DYNAMIC;
spr->CollideMsg() = string(collide_msg_str);
spr->InventoryMessage() = string(inventory_msg_str);
spr->AlwaysSeenByPlayer() = seen_by_player;
//Set the sprites hardbox
//spr->SetHardbox(
// hbox_x, hbox_y, hbox_width, hbox_height
//);
//path = gd->m_required_textures;
//Create the new hard box
//spr->CreateHardBoxSpr(path);
//if (is_player)
//{
// //Add the sprite to the map
// map->AddPlayer(spr);
//}
//else
//{
// //Add the sprite to the map
// map->AddSprite(spr);
//}
////Add the animation
//if (strcmp(animation_name_str, "NONE") != 0)
// map->AddSpriteAnimations(string(animation_name_str), gd->GAME_FOLDER, gd->m_sprites_path, spr->ID());
} while (spritesParser.ArrayElementNotNull("Sprite"));
return true;
}
//===============================================================================================================================
bool ZShadeXMLLoader::LoadMenuXML(string menufilename, GameDirectory2D* gd, EngineOptions* eo, D3D* d3d, MenuSystem*& ms)
{
XMLParser xmlParser(menufilename);
const char* menu_name_str = xmlParser.ReadElement("menu_name");
const char* menu_size_str = xmlParser.ReadElement("menu_size");
const char* menu_type_str = xmlParser.ReadElement("menu_type");
const char* background_name_str = xmlParser.ReadElement("menu_background");
string background_name(background_name_str);
BetterString split_b_str(menu_size_str);
vector<string> split_str = split_b_str.split('x');
int menu_width = atoi(split_str[0].c_str());
int menu_height = atoi(split_str[1].c_str());
ZShadeSandboxEnvironment::EMenuType::Type menuType;
if (strcmp(menu_type_str, "MainMenu") == 0)
menuType = ZShadeSandboxEnvironment::EMenuType::eMainMenu;
else if (strcmp(menu_type_str, "InGameMenu") == 0)
menuType = ZShadeSandboxEnvironment::EMenuType::eInGameMenu;
ZShadeSandboxEnvironment::Menu* m = new ZShadeSandboxEnvironment::Menu(d3d);
m->MenuName() = string(menu_name_str);
m->Width() = menu_width;
m->Height() = menu_height;
m->GetMenuType() = menuType;
if (background_name != "")
{
ZShadeSandboxGraphics::Image* im = new ZShadeSandboxGraphics::Image(d3d, background_name, gd->m_sprites_path, 0, 0, menu_width, menu_height);
m->AddBackground( im );
}
ms->AddMenu(m);
int st = ZShadeSandboxGraphics::EScriptType::eNone;
ArrayElementXMLParser buttonsParser(xmlParser.Element());
buttonsParser.ReadArrayElement("Buttons", "Button");
do
{
string eName = buttonsParser.ReadArrayElementValue();
string eIDAtt = buttonsParser.ReadArrayElementAttribute("id");
const char* x_str = buttonsParser.ReadArrayChildElement("button_x");
const char* y_str = buttonsParser.ReadArrayChildElement("button_y");
const char* width_str = buttonsParser.ReadArrayChildElement("button_width");
const char* height_str = buttonsParser.ReadArrayChildElement("button_height");
const char* text_str = buttonsParser.ReadArrayChildElement("button_text");
const char* normal_image_str = buttonsParser.ReadArrayChildElement("normal_image");
const char* pushed_image_str = buttonsParser.ReadArrayChildElement("pushed_image");
const char* highlighted_image_str = buttonsParser.ReadArrayChildElement("highlighted_image");
const char* disabled_image_str = buttonsParser.ReadArrayChildElement("disabled_image");
const char* script_type_str = buttonsParser.ReadArrayChildElement("script_type");
const char* tag_str = buttonsParser.ReadArrayChildElement("tag");
if (strcmp(script_type_str, "start") == 0) st = ZShadeSandboxGraphics::EScriptType::eStart;
if (strcmp(script_type_str, "resume") == 0) st = ZShadeSandboxGraphics::EScriptType::eResume;
if (strcmp(script_type_str, "continue") == 0) st = ZShadeSandboxGraphics::EScriptType::eContinue;
if (strcmp(script_type_str, "options") == 0) st = ZShadeSandboxGraphics::EScriptType::eOptions;
if (strcmp(script_type_str, "exit") == 0) st = ZShadeSandboxGraphics::EScriptType::eExit;
if (strcmp(script_type_str, "none") == 0) st = ZShadeSandboxGraphics::EScriptType::eNone;
ZShadeSandboxGraphics::Button* b = new ZShadeSandboxGraphics::Button(
d3d,
ZShadeSandboxGlobal::Convert::ConvertStringToCharPointer(string(text_str)),
false,
atof(x_str), atof(y_str),
atoi(width_str), atoi(height_str),
gd->m_menu_sprites_path,
string(normal_image_str),
string(pushed_image_str),
string(highlighted_image_str),
string(disabled_image_str),
"white.png",
"blue.png",
"yellow.png",
"black.png"
);
b->ScriptType() = st;
b->Tag() = string(tag_str);
switch (st)
{
case ZShadeSandboxGraphics::EScriptType::eStart: b->GetScript() = Scripting::GetScript("start"); break;
case ZShadeSandboxGraphics::EScriptType::eResume: b->GetScript() = Scripting::GetScript("resume"); break;
case ZShadeSandboxGraphics::EScriptType::eContinue: b->GetScript() = Scripting::GetScript("continue"); break;
case ZShadeSandboxGraphics::EScriptType::eOptions: b->GetScript() = Scripting::GetScript("options"); break;
case ZShadeSandboxGraphics::EScriptType::eExit: b->GetScript() = Scripting::GetScript("exit"); break;
}
m->AddButton(b);
} while (buttonsParser.ArrayElementNotNull("Button"));
ArrayElementXMLParser textsParser(xmlParser.Element());
textsParser.ReadArrayElement("Texts", "Text");
do
{
string eName = textsParser.ReadArrayElementValue();
string eIDAtt = textsParser.ReadArrayElementAttribute("id");
const char* x_str = textsParser.ReadArrayChildElement("text_x");
const char* y_str = textsParser.ReadArrayChildElement("text_y");
const char* text_str = textsParser.ReadArrayChildElement("text");
const char* text_font_str = textsParser.ReadArrayChildElement("text_font");
const char* text_color_str = textsParser.ReadArrayChildElement("text_color");
const char* shadow_str = textsParser.ReadArrayChildElement("shadow");
const char* optional_background_str = textsParser.ReadArrayChildElement("optional_background");
XMFLOAT3 color = ZShadeSandboxGlobal::Convert::ConvertToFloat3(string(text_color_str));
bool shadow = (string(shadow_str) == "1") ? true : false;
ZShadeSandboxGraphics::Text* t = new ZShadeSandboxGraphics::Text();
t->SetD3D(d3d);
t->Initialize();
t->TextName() = BetterString(text_str);
if (shadow)
{
t->CreateShadow();
}
t->ChangeFont(L"Times New Roman", atoi(text_font_str), FontStyle::BoldItalic, true);
t->TextTransform() = XMMatrixTranslation(atof(x_str), atof(y_str), 0);
t->TextColor() = XMFLOAT4(color.x, color.y, color.z, 1);
m->AddText(t);
} while (textsParser.ArrayElementNotNull("Text"));
return true;
}
//===============================================================================================================================
bool ZShadeXMLLoader::LoadInventoryXML(string filename, GameDirectory2D* gd, EngineOptions* eo, PlayerInventory2D*& inventory)
{
XMLParser xmlParser(filename);
const char* background_image_name_str = xmlParser.ReadElement("BackgroundImageName");
const char* item_size_str = xmlParser.ReadElement("ItemSize");
const char* item_row_size_regular_str = xmlParser.ReadElement("ItemRowSizeRegular");
const char* item_col_size_regular_str = xmlParser.ReadElement("ItemColSizeRegular");
const char* item_row_size_magic_str = xmlParser.ReadElement("ItemRowSizeMagic");
const char* item_col_size_magic_str = xmlParser.ReadElement("ItemColSizeMagic");
const char* item_row_padding_regular_str = xmlParser.ReadElement("ItemRowPaddingRegular");
const char* item_col_padding_regular_str = xmlParser.ReadElement("ItemColPaddingRegular");
const char* item_row_padding_magic_str = xmlParser.ReadElement("ItemRowPaddingMagic");
const char* item_col_padding_magic_str = xmlParser.ReadElement("ItemColPaddingMagic");
const char* start_location_regular_str = xmlParser.ReadElement("StartLocationRegular");
const char* start_location_magic_str = xmlParser.ReadElement("StartLocationMagic");
int item_size = atoi(item_size_str);
int item_row_size_regular = atoi(item_row_size_regular_str);
int item_col_size_regular = atoi(item_col_size_regular_str);
int item_row_size_magic = atoi(item_row_size_magic_str);
int item_col_size_magic = atoi(item_col_size_magic_str);
int item_row_padding_regular = atoi(item_row_padding_regular_str);
int item_col_padding_regular = atoi(item_col_padding_regular_str);
int item_row_padding_magic = atoi(item_row_padding_magic_str);
int item_col_padding_magic = atoi(item_col_padding_magic_str);
XMFLOAT2 start_location_regular = ZShadeSandboxGlobal::Convert::ConvertToFloat2(start_location_regular_str);
XMFLOAT2 start_location_magic = ZShadeSandboxGlobal::Convert::ConvertToFloat2(start_location_magic_str);
inventory->Init(
gd->m_required_textures,
gd->m_sprites_path,
string(background_image_name_str),
eo->m_screenWidth,
eo->m_screenHeight,
item_size,
item_size,
item_size,
item_row_size_regular, item_col_size_regular,
item_row_size_magic, item_col_size_magic,
item_row_padding_regular, item_col_padding_regular,
item_row_padding_magic, item_col_padding_magic,
start_location_regular,
start_location_magic
);
ArrayElementXMLParser regularItemsParser(xmlParser.Element());
regularItemsParser.ReadArrayElement("RegularItems", "Item");
do
{
string eName = regularItemsParser.ReadArrayElementValue();
string eIDAtt = regularItemsParser.ReadArrayElementAttribute("id");
string eImageNameAtt = regularItemsParser.ReadArrayElementAttribute("image");
const char* inventory_message_str = regularItemsParser.ReadArrayChildElement("Message");
inventory->AddItemRegular(gd->m_sprites_path, eImageNameAtt, string(inventory_message_str));
} while (regularItemsParser.ArrayElementNotNull("Item"));
ArrayElementXMLParser magicItemsParser(xmlParser.Element());
magicItemsParser.ReadArrayElement("MagicItems", "Item");
do
{
string eName = magicItemsParser.ReadArrayElementValue();
string eIDAtt = magicItemsParser.ReadArrayElementAttribute("id");
string eImageNameAtt = magicItemsParser.ReadArrayElementAttribute("image");
const char* inventory_message_str = magicItemsParser.ReadArrayChildElement("Message");
inventory->AddItemMagic(gd->m_sprites_path, eImageNameAtt, string(inventory_message_str));
} while (magicItemsParser.ArrayElementNotNull("Item"));
inventory->PositionItemsOnGrid();
return true;
}
int main (int argc, char** argv)
{
int returnCode = 0;
try
{
const char* epocRoot = getenv("EPOCROOT");
if(NULL == epocRoot)
{
throw CException("EPOCROOT environment variable not specified.", ExceptionCodes::EEnvNotSpecified);
}
std::string epocRootStr(epocRoot);
COptions options(argc, argv);
std::string logFileName(options.GetLogFileName());
std::auto_ptr<CLogger> logger(new CLogger(logFileName, options.GetLogLevel()));
#ifdef __LINUX__
std::string dllPath = "sqlite-3.6.1.so";
#else
std::string dllPath = "sqlite3.dll";
#endif
std::auto_ptr<CDbLayer> db( new CDbLayer(dllPath, options.GetDbFileName()));
std::auto_ptr<CScrXmlParser> xmlParser( new CScrXmlParser());
if(options.IsDbAbsent())
{
#ifdef __LINUX__
std::string dbFileName = epocRootStr + "epoc32/tools/create_db.xml";
#else
std::string dbFileName = epocRootStr + "epoc32\\tools\\create_db.xml";
#endif
std::auto_ptr<SchemaDetails> schema(xmlParser->ParseDbSchema(dbFileName));
db->CreateScrDatabase(*schema);
}
std::vector<std::string> xmlFileNames = options.GetEnvFileNames();
for(StringIterator xmlIter=xmlFileNames.begin(); xmlIter != xmlFileNames.end(); ++xmlIter)
{
std::auto_ptr<EnvDetails> envDetails(xmlParser->GetEnvironmentDetails(*xmlIter));
db->PopulateScrDatabase(*envDetails);
}
if(options.IsPreProvisionInfoAvailable())
{
std::string preProvFileName = options.GetPrePovisionFileName();
XmlDetails::TScrPreProvisionDetail preProvisionDetailList = xmlParser->GetPreProvisionDetails(preProvFileName);
db->PopulatePreProvisionDetails(preProvisionDetailList);
}
}
catch(CException& aException)
{
const std::string& exc = aException.GetMessageA();
returnCode = aException.GetCode();
std::cout << "Exception caught::" << exc << std::endl;
std::cout << "Error Code::" << returnCode << std::endl;
}
return returnCode;
}
//===============================================================================================================================
bool ZShadeXMLLoader::LoadMapXML(string& mapname, string filename, GameDirectory2D* gd, D3D* d3d, TopdownMap*& map, bool inEditor)
{
XMLParser xmlParser(filename);
const char* map_name_str = xmlParser.ReadElement("map_name");
const char* xml_sprite_str = xmlParser.ReadElement("xml_sprite");
const char* map_type_str = xmlParser.ReadElement("map_type");
const char* row_size_str = xmlParser.ReadElement("row_size");
const char* col_size_str = xmlParser.ReadElement("col_size");
const char* vision_str = xmlParser.ReadElement("vision");
const char* music_str = xmlParser.ReadElement("music");
int row_size = atoi(row_size_str);
int col_size = atoi(col_size_str);
d3d->GetEngineOptions()->SECTION_ROW_SIZE = row_size;
d3d->GetEngineOptions()->SECTION_COL_SIZE = col_size;
d3d->GetEngineOptions()->SetTileMax();
bool fow_enabled;
int fow_radius;
bool fow_flashlight;
xmlParser.ReadAttribute("Fow", "enabled", fow_enabled);
xmlParser.ReadAttribute("Fow", "radius", fow_radius);
xmlParser.ReadAttribute("Fow", "flashlight", fow_flashlight);
MapLoadData mld;
mld.mapVision = atoi(vision_str);
mld.mapMusicName = string(music_str);
ArrayElementXMLParser tilesParser(xmlParser.Element());
tilesParser.ReadArrayElement("Tiles", "Tile");
do
{
string eName = tilesParser.ReadArrayElementValue();
string eIDAtt = tilesParser.ReadArrayElementAttribute("id");
string eImageNameAtt = tilesParser.ReadArrayElementAttribute("image");
const char* x_str = tilesParser.ReadArrayChildElement("x");
const char* y_str = tilesParser.ReadArrayChildElement("y");
const char* animation_str = tilesParser.ReadArrayChildElement("animation");
const char* anim_speed_str = tilesParser.ReadArrayChildElement("anim_speed");
const char* hard_str = tilesParser.ReadArrayChildElement("hard");
int x = atoi(x_str);
int y = atoi(y_str);
int anim_speed = atoi(anim_speed_str);
int hard = atoi(hard_str);
mld.imageNames.push_back(eImageNameAtt);
mld.animProfileNames.push_back(string(animation_str));
mld.animSpeeds.push_back(anim_speed);
mld.hards.push_back(hard);
} while (tilesParser.ArrayElementNotNull("Tile"));
Map2DType mt;
if (BetterString(map_type_str) == "Regular")
mt = Map2DType::REGULAR;
else if (BetterString(map_type_str) == "Isometric")
mt = Map2DType::ISOMETRIC;
map = new TopdownMap(d3d, mt, gd);
if (!map) return false;
map->InEditor() = inEditor;
map->Initialize(row_size, mld);
// Set the FOW data
map->FOW() = fow_enabled;
map->FOWRadius() = fow_radius;
map->FOWFlashlight() = fow_flashlight;
//BetterString str(gd->m_xml_sprites_path);
//str += "\\";
//str += xml_sprite_str;
//Load the sprites onto the map
LoadSpritesXML(xml_sprite_str, gd, d3d, map);
return true;
}
int main(int argc, char* argv[])
{
// init random number generator for distribution rendering
std::srand(int(time(nullptr)));
if (argc <= 1) {
std::cerr << "No Scene XML specified. If more than one XML spceified, scenes and settings will be combined into one." << std::endl;
std::cerr << " Usage:" << std::endl;
std::cerr << " ./raytracer <path to xml> ..." << std::endl;
return 0;
}
// Create the 3 main objects that handle all functionality
Scene scene;
Raytracer raytracer;
raytracer.setScene(&scene);
CameraContainer cameras;
// parse all scene info
SceneXmlParser xmlParser(raytracer, scene, cameras);
for (int i = 1; i < argc; ++i) {
std::string sceneFilename(argv[i]);
if(!xmlParser.parseSceneDefinition(sceneFilename) ) {
std::cerr << "Parsing failed... Exiting." << std::endl;
return 1;
}
}
// preprocess the scene before rendering
scene.preprocess();
std::string bmpSuffix(".bmp");
std::string rawSuffix(".rsd");
// Render for each camera.
for (auto& cam : cameras) {
std::cout << "Rendering camera \"" << cam->name << "\"" << std::endl;
// if previous raw sensor data exists,
// use it as starting point
std::string rawFileName = cam->name + rawSuffix;
std::ifstream rawFile(rawFileName.c_str());
if (rawFile.good()) {
Image<SensorPixel> accummulatedSensor = readImageFromFile<Image<SensorPixel> >(rawFile);
if (accummulatedSensor) {
std::cout << "Reusing previously rendered data for iterative raytacing." << std::endl;
cam->mergeSensor(accummulatedSensor);
}
rawFile.close();
}
// render and dump to file
raytracer.render(*cam.get());
cam->dumpToBMP(cam->name + bmpSuffix);
// if raytracer flag says to also dump raw, do so
if (raytracer.dumpRaw) {
cam->dumpRawData(rawFileName);
}
}
return 0;
}
//===============================================================================================================================
//===============================================================================================================================
bool ZShadeXMLLoader::LoadTemplatePolyXML(string filename, ZShadeSandboxMath::Polygon*& poly)
{
XMLParser xmlParser(filename);
const char* name_str = xmlParser.ReadElement("Name");
const char* vertex_count_str = xmlParser.ReadElement("VertexCount");
int vertex_count = ZShadeSandboxGlobal::Convert::ConvertStringToT<int>(vertex_count_str);
vector<ZShadeSandboxMesh::VertexTex> vertices(vertex_count);
ArrayElementXMLParser vertexParser(xmlParser.Element());
vertexParser.ReadArrayElement("Vertices", "Vertex");
do
{
string eName = vertexParser.ReadArrayElementValue();
string eIDAtt = vertexParser.ReadArrayElementAttribute("id");
int id = ZShadeSandboxGlobal::Convert::ConvertStringToT<int>(eIDAtt);
const char* vertexPosition = vertexParser.ReadArrayChildElement("Pos");
const char* vertexUV = vertexParser.ReadArrayChildElement("UV");
XMFLOAT3 position = ZShadeSandboxGlobal::Convert::ConvertToFloat3(vertexPosition);
XMFLOAT2 uv = ZShadeSandboxGlobal::Convert::ConvertToFloat2(vertexUV);
vertices[id].position = position;
vertices[id].texture = uv;
} while (vertexParser.ArrayElementNotNull("Vertex"));
const char* index_count_str = xmlParser.ReadElement("IndexCount");
int index_count = ZShadeSandboxGlobal::Convert::ConvertStringToT<int>(index_count_str);
vector<UINT> indices(index_count);
ArrayElementXMLParser indexParser(xmlParser.Element());
indexParser.ReadArrayElement("Indices", "Index");
do
{
string eName = indexParser.ReadArrayElementValue();
string eIDAtt = indexParser.ReadArrayElementAttribute("id");
int id = ZShadeSandboxGlobal::Convert::ConvertStringToT<int>(eIDAtt);
const char* value = indexParser.ReadArrayChildElement("Value");
UINT index_value = ZShadeSandboxGlobal::Convert::ConvertStringToT<UINT>(value);
indices[id] = index_value;
} while (indexParser.ArrayElementNotNull("Index"));
const char* material_name_str = xmlParser.ReadElement("MaterialName");
const char* polygon_rotation_str = xmlParser.ReadElement("Rotation");
XMFLOAT3 polygon_rotation = ZShadeSandboxGlobal::Convert::ConvertToFloat3(polygon_rotation_str);
const char* polygon_scale_str = xmlParser.ReadElement("Scale");
XMFLOAT3 polygon_scale = ZShadeSandboxGlobal::Convert::ConvertToFloat3(polygon_scale_str);
if (poly == 0)
{
poly = new ZShadeSandboxMath::Polygon();
}
poly->Name() = name_str;
poly->Create(vertices);
poly->CreateIndices(indices);
// Since it is a template it will start out at the origin
// or the position that was clicked by the mouse
poly->Position() = XMFLOAT3(0, 0, 0);
poly->Rotation() = polygon_rotation;
poly->Scale() = polygon_scale;
poly->MaterialName() = material_name_str;
return true;
}
