bool TmxImageLayer2D::Load(const XMLElement& element, const TileMapInfo2D& info)
{
LoadInfo(element);
XMLElement imageElem = element.GetChild("image");
if (!imageElem)
return false;
position_ = Vector2(0.0f, info.GetMapHeight());
source_ = imageElem.GetAttribute("source");
String textureFilePath = GetParentPath(tmxFile_->GetName()) + source_;
ResourceCache* cache = tmxFile_->GetSubsystem<ResourceCache>();
SharedPtr<Texture2D> texture(cache->GetResource<Texture2D>(textureFilePath));
if (!texture)
{
URHO3D_LOGERROR("Could not load texture " + textureFilePath);
return false;
}
sprite_ = new Sprite2D(tmxFile_->GetContext());
sprite_->SetTexture(texture);
sprite_->SetRectangle(IntRect(0, 0, texture->GetWidth(), texture->GetHeight()));
// Set image hot spot at left top
sprite_->SetHotSpot(Vector2(0.0f, 1.0f));
if (element.HasChild("properties"))
LoadPropertySet(element.GetChild("properties"));
return true;
}
//------------------------------------------------------------------------------------------------------------------------------------------------------
bool Settings::GetFloatFromChild(char *category, char *name, float *value)
{
if (!root.HasChild(category))
{
return false;
}
XMLElement child = root.GetChild(category);
if (!child.HasChild(name))
{
return false;
}
*value = Urho3D::ToFloat(child.GetChild(name).GetValue());
return true;
}
//------------------------------------------------------------------------------------------------------------------------------------------------------
bool Settings::GetIntFromChild(char *category, char *name, int *value)
{
if (!root.HasChild(category))
{
return false;
}
XMLElement child = root.GetChild(category);
if (!child.HasChild(name))
{
return false;
}
*value = ToInt(child.GetChild(name).GetValue());
return true;
}
bool TmxTileLayer2D::Load(const XMLElement& element, const TileMapInfo2D& info)
{
LoadInfo(element);
XMLElement dataElem = element.GetChild("data");
if (!dataElem)
{
URHO3D_LOGERROR("Could not find data in layer");
return false;
}
if (dataElem.HasAttribute("encoding") && dataElem.GetAttribute("encoding") != "xml")
{
URHO3D_LOGERROR("Encoding not support now");
return false;
}
XMLElement tileElem = dataElem.GetChild("tile");
tiles_.Resize((unsigned)(width_ * height_));
for (int y = 0; y < height_; ++y)
{
for (int x = 0; x < width_; ++x)
{
if (!tileElem)
return false;
int gid = tileElem.GetInt("gid");
if (gid > 0)
{
SharedPtr<Tile2D> tile(new Tile2D());
tile->gid_ = gid;
tile->sprite_ = tmxFile_->GetTileSprite(gid);
tile->propertySet_ = tmxFile_->GetTilePropertySet(gid);
tiles_[y * width_ + x] = tile;
}
tileElem = tileElem.GetNext("tile");
}
}
if (element.HasChild("properties"))
LoadPropertySet(element.GetChild("properties"));
return true;
}
bool ParticleEffect2D::Load(Deserializer& source)
{
XMLFile xmlFile(context_);
if (!xmlFile.Load(source))
return false;
XMLElement rootElem = xmlFile.GetRoot("particleEmitterConfig");
if (!rootElem)
return false;
String texture = rootElem.GetChild("texture").GetAttribute("name");
ResourceCache* cache = GetSubsystem<ResourceCache>();
sprite_= cache->GetResource<Sprite2D>(texture, false);
// If sprite not found, try get in current directory
if (!sprite_)
sprite_= cache->GetResource<Sprite2D>(GetParentPath(GetName()) + texture);
if (!sprite_)
return false;
sourcePositionVariance_ = ReadVector2(rootElem.GetChild("sourcePositionVariance"));
speed_ = rootElem.GetChild("speed").GetFloat("value");
speedVariance_ = rootElem.GetChild("speedVariance").GetFloat("value");
particleLifeSpan_ = Max(0.01f, rootElem.GetChild("particleLifeSpan").GetFloat("value"));
particleLifespanVariance_ = rootElem.GetChild("particleLifespanVariance").GetFloat("value");
angle_ = rootElem.GetChild("angle").GetFloat("value");
angleVariance_ = rootElem.GetChild("angleVariance").GetFloat("value");
gravity_ = ReadVector2(rootElem.GetChild("gravity"));
radialAcceleration_ = rootElem.GetChild("radialAcceleration").GetFloat("value");
tangentialAcceleration_ = rootElem.GetChild("tangentialAcceleration").GetFloat("value");
radialAccelVariance_ = rootElem.GetChild("radialAccelVariance").GetFloat("value");
tangentialAccelVariance_ = rootElem.GetChild("tangentialAccelVariance").GetFloat("value");
startColor_ = ReadColor(rootElem.GetChild("startColor"));
startColorVariance_ = ReadColor(rootElem.GetChild("startColorVariance"));
finishColor_ = ReadColor(rootElem.GetChild("finishColor"));
finishColorVariance_ = ReadColor(rootElem.GetChild("finishColorVariance"));
maxParticles_ = rootElem.GetChild("maxParticles").GetInt("value");
startParticleSize_ = rootElem.GetChild("startParticleSize").GetFloat("value");
startParticleSizeVariance_ = rootElem.GetChild("startParticleSizeVariance").GetFloat("value");
finishParticleSize_ = rootElem.GetChild("finishParticleSize").GetFloat("value");
FinishParticleSizeVariance_ = rootElem.GetChild("FinishParticleSizeVariance").GetFloat("value");
duration_ = M_INFINITY;
if (rootElem.HasChild("duration"))
{
float duration = rootElem.GetChild("duration").GetFloat("value");
if (duration > 0.0f)
duration_ = duration;
}
emitterType_ = (EmitterType2D)rootElem.GetChild("emitterType").GetInt("value");
maxRadius_ = rootElem.GetChild("maxRadius").GetFloat("value");
maxRadiusVariance_ = rootElem.GetChild("maxRadiusVariance").GetFloat("value");
minRadius_ = rootElem.GetChild("minRadius").GetFloat("value");
rotatePerSecond_ = rootElem.GetChild("rotatePerSecond").GetFloat("value");
rotatePerSecondVariance_ = rootElem.GetChild("rotatePerSecondVariance").GetFloat("value");
int blendFuncSource = rootElem.GetChild("blendFuncSource").GetInt("value");
int blendFuncDestination = rootElem.GetChild("blendFuncDestination").GetInt("value");
blendMode_ = BLEND_ALPHA;
for (int i = 0; i < MAX_BLENDMODES; ++i)
{
if (blendFuncSource == srcBlendFuncs[i] && blendFuncDestination == destBlendFuncs[i])
{
blendMode_ = (BlendMode)i;
break;
}
}
rotationStart_ = rootElem.GetChild("rotationStart").GetFloat("value");
rotationStartVariance_ = rootElem.GetChild("rotationStartVariance").GetFloat("value");
rotationEnd_ = rootElem.GetChild("rotationEnd").GetFloat("value");
rotationEndVariance_ = rootElem.GetChild("rotationEndVariance").GetFloat("value");
return true;
}
bool ParticleEffect::Load(const XMLElement& source)
{
// Reset to defaults first so that missing parameters in case of a live reload behave as expected
material_.Reset();
numParticles_ = DEFAULT_NUM_PARTICLES;
updateInvisible_ = false;
relative_ = true;
scaled_ = true;
sorted_ = false;
fixedScreenSize_ = false;
animationLodBias_ = 0.0f;
emitterType_ = EMITTER_SPHERE;
emitterSize_ = Vector3::ZERO;
directionMin_ = DEFAULT_DIRECTION_MIN;
directionMax_ = DEFAULT_DIRECTION_MAX;
constantForce_ = Vector3::ZERO;
dampingForce_ = 0.0f;
activeTime_ = 0.0f;
inactiveTime_ = 0.0;
emissionRateMin_ = DEFAULT_EMISSION_RATE;
emissionRateMax_ = DEFAULT_EMISSION_RATE;
sizeMin_ = DEFAULT_PARTICLE_SIZE;
sizeMax_ = DEFAULT_PARTICLE_SIZE;
timeToLiveMin_ = DEFAULT_TIME_TO_LIVE;
timeToLiveMax_ = DEFAULT_TIME_TO_LIVE;
velocityMin_ = DEFAULT_VELOCITY;
velocityMax_ = DEFAULT_VELOCITY;
rotationMin_ = 0.0f;
rotationMax_ = 0.0f;
rotationSpeedMin_ = 0.0f;
rotationSpeedMax_ = 0.0f;
sizeAdd_ = 0.0f;
sizeMul_ = 1.0f;
colorFrames_.Clear();
textureFrames_.Clear();
faceCameraMode_ = FC_ROTATE_XYZ;
if (source.IsNull())
{
URHO3D_LOGERROR("Can not load particle effect from null XML element");
return false;
}
if (source.HasChild("material"))
{
loadMaterialName_ = source.GetChild("material").GetAttribute("name");
// If async loading, can not GetResource() the material. But can do a background request for it
if (GetAsyncLoadState() == ASYNC_LOADING)
GetSubsystem<ResourceCache>()->BackgroundLoadResource<Material>(loadMaterialName_, true, this);
}
if (source.HasChild("numparticles"))
SetNumParticles((unsigned)source.GetChild("numparticles").GetInt("value"));
if (source.HasChild("updateinvisible"))
updateInvisible_ = source.GetChild("updateinvisible").GetBool("enable");
if (source.HasChild("relative"))
relative_ = source.GetChild("relative").GetBool("enable");
if (source.HasChild("scaled"))
scaled_ = source.GetChild("scaled").GetBool("enable");
if (source.HasChild("sorted"))
sorted_ = source.GetChild("sorted").GetBool("enable");
if (source.HasChild("fixedscreensize"))
fixedScreenSize_ = source.GetChild("fixedscreensize").GetBool("enable");
if (source.HasChild("animlodbias"))
SetAnimationLodBias(source.GetChild("animlodbias").GetFloat("value"));
if (source.HasChild("emittertype"))
{
String type = source.GetChild("emittertype").GetAttributeLower("value");
if (type == "point")
{
// Point emitter type is deprecated, handled as zero sized sphere
emitterType_ = EMITTER_SPHERE;
emitterSize_ = Vector3::ZERO;
}
else
emitterType_ = (EmitterType)GetStringListIndex(type.CString(), emitterTypeNames, EMITTER_SPHERE);
}
if (source.HasChild("emittersize"))
emitterSize_ = source.GetChild("emittersize").GetVector3("value");
if (source.HasChild("emitterradius"))
emitterSize_.x_ = emitterSize_.y_ = emitterSize_.z_ = source.GetChild("emitterradius").GetFloat("value");
if (source.HasChild("direction"))
GetVector3MinMax(source.GetChild("direction"), directionMin_, directionMax_);
if (source.HasChild("constantforce"))
constantForce_ = source.GetChild("constantforce").GetVector3("value");
if (source.HasChild("dampingforce"))
dampingForce_ = source.GetChild("dampingforce").GetFloat("value");
if (source.HasChild("activetime"))
activeTime_ = source.GetChild("activetime").GetFloat("value");
if (activeTime_ < 0.0f)
activeTime_ = M_INFINITY;
if (source.HasChild("inactivetime"))
inactiveTime_ = source.GetChild("inactivetime").GetFloat("value");
if (inactiveTime_ < 0.0f)
inactiveTime_ = M_INFINITY;
if (source.HasChild("emissionrate"))
GetFloatMinMax(source.GetChild("emissionrate"), emissionRateMin_, emissionRateMax_);
if (source.HasChild("interval"))
{
float intervalMin = 0.0f;
float intervalMax = 0.0f;
GetFloatMinMax(source.GetChild("interval"), intervalMin, intervalMax);
emissionRateMax_ = 1.0f / intervalMin;
emissionRateMin_ = 1.0f / intervalMax;
}
if (source.HasChild("particlesize"))
GetVector2MinMax(source.GetChild("particlesize"), sizeMin_, sizeMax_);
if (source.HasChild("timetolive"))
GetFloatMinMax(source.GetChild("timetolive"), timeToLiveMin_, timeToLiveMax_);
if (source.HasChild("velocity"))
GetFloatMinMax(source.GetChild("velocity"), velocityMin_, velocityMax_);
if (source.HasChild("rotation"))
GetFloatMinMax(source.GetChild("rotation"), rotationMin_, rotationMax_);
if (source.HasChild("rotationspeed"))
GetFloatMinMax(source.GetChild("rotationspeed"), rotationSpeedMin_, rotationSpeedMax_);
if (source.HasChild("faceCameraMode"))
{
String type = source.GetChild("faceCameraMode").GetAttributeLower("value");
faceCameraMode_ = (FaceCameraMode)GetStringListIndex(type.CString(), faceCameraModeNames, FC_ROTATE_XYZ);
}
if (source.HasChild("sizedelta"))
{
XMLElement deltaElem = source.GetChild("sizedelta");
if (deltaElem.HasAttribute("add"))
sizeAdd_ = deltaElem.GetFloat("add");
if (deltaElem.HasAttribute("mul"))
sizeMul_ = deltaElem.GetFloat("mul");
}
if (source.HasChild("color"))
{
ColorFrame colorFrame(source.GetChild("color").GetColor("value"));
SetColorFrame(0, colorFrame);
}
if (source.HasChild("colorfade"))
{
Vector<ColorFrame> fades;
for (XMLElement colorFadeElem = source.GetChild("colorfade"); colorFadeElem;
colorFadeElem = colorFadeElem.GetNext("colorfade"))
fades.Push(ColorFrame(colorFadeElem.GetColor("color"), colorFadeElem.GetFloat("time")));
SetColorFrames(fades);
}
if (colorFrames_.Empty())
colorFrames_.Push(ColorFrame(Color::WHITE));
if (source.HasChild("texanim"))
{
Vector<TextureFrame> animations;
for (XMLElement animElem = source.GetChild("texanim"); animElem; animElem = animElem.GetNext("texanim"))
{
TextureFrame animation;
animation.uv_ = animElem.GetRect("uv");
animation.time_ = animElem.GetFloat("time");
animations.Push(animation);
}
SetTextureFrames(animations);
}
return true;
}
bool ParticleEmitter::Load(XMLFile* file)
{
if (!file)
{
LOGERROR("Null particle emitter parameter file");
return false;
}
XMLElement rootElem = file->GetRoot();
if (!rootElem)
{
LOGERROR("Particle emitter parameter file does not have a valid root element");
return false;
}
if (rootElem.HasChild("material"))
SetMaterial(GetSubsystem<ResourceCache>()->GetResource<Material>(rootElem.GetChild("material").GetAttribute("name")));
if (rootElem.HasChild("numparticles"))
SetNumParticles(rootElem.GetChild("numparticles").GetInt("value"));
if (rootElem.HasChild("updateinvisible"))
updateInvisible_ = rootElem.GetChild("updateinvisible").GetBool("enable");
if (rootElem.HasChild("relative"))
relative_ = rootElem.GetChild("relative").GetBool("enable");
if (rootElem.HasChild("scaled"))
scaled_ = rootElem.GetChild("scaled").GetBool("enable");
if (rootElem.HasChild("sorted"))
sorted_ = rootElem.GetChild("sorted").GetBool("enable");
if (rootElem.HasChild("animlodbias"))
SetAnimationLodBias(rootElem.GetChild("relative").GetFloat("value"));
if (rootElem.HasChild("emittertype"))
{
String type = rootElem.GetChild("emittertype").GetAttributeLower("value");
if (type == "point")
{
// Point emitter type is deprecated, handled as zero sized sphere
emitterType_ = EMITTER_SPHERE;
emitterSize_ = Vector3::ZERO;
}
else if (type == "box")
emitterType_ = EMITTER_BOX;
else if (type == "sphere")
emitterType_ = EMITTER_SPHERE;
else
LOGERROR("Unknown particle emitter type " + type);
}
if (rootElem.HasChild("emittersize"))
emitterSize_ = rootElem.GetChild("emittersize").GetVector3("value");
if (rootElem.HasChild("emitterradius"))
emitterSize_.x_ = emitterSize_.y_ = emitterSize_.z_ = rootElem.GetChild("emitterradius").GetFloat("value");
if (rootElem.HasChild("direction"))
GetVector3MinMax(rootElem.GetChild("direction"), directionMin_, directionMax_);
if (rootElem.HasChild("constantforce"))
constantForce_ = rootElem.GetChild("constantforce").GetVector3("value");
if (rootElem.HasChild("dampingforce"))
dampingForce_ = rootElem.GetChild("dampingforce").GetFloat("value");
if (rootElem.HasChild("activetime"))
activeTime_ = rootElem.GetChild("activetime").GetFloat("value");
if (activeTime_ < 0.0f)
activeTime_ = M_INFINITY;
if (rootElem.HasChild("inactivetime"))
inactiveTime_ = rootElem.GetChild("inactivetime").GetFloat("value");
if (inactiveTime_ < 0.0f)
inactiveTime_ = M_INFINITY;
if (rootElem.HasChild("emissionrate"))
GetFloatMinMax(rootElem.GetChild("emissionrate"), emissionRateMin_, emissionRateMax_);
if (rootElem.HasChild("interval"))
{
float intervalMin = 0.0f;
float intervalMax = 0.0f;
GetFloatMinMax(rootElem.GetChild("interval"), intervalMin, intervalMax);
emissionRateMax_ = 1.0f / intervalMin;
emissionRateMin_ = 1.0f / intervalMax;
}
if (rootElem.HasChild("particlesize"))
GetVector2MinMax(rootElem.GetChild("particlesize"), sizeMin_, sizeMax_);
if (rootElem.HasChild("timetolive"))
GetFloatMinMax(rootElem.GetChild("timetolive"), timeToLiveMin_, timeToLiveMax_);
if (rootElem.HasChild("velocity"))
GetFloatMinMax(rootElem.GetChild("velocity"), velocityMin_, velocityMax_);
if (rootElem.HasChild("rotation"))
GetFloatMinMax(rootElem.GetChild("rotation"), rotationMin_, rotationMax_);
if (rootElem.HasChild("rotationspeed"))
GetFloatMinMax(rootElem.GetChild("rotationspeed"), rotationSpeedMin_, rotationSpeedMax_);
if (rootElem.HasChild("sizedelta"))
{
XMLElement deltaElem = rootElem.GetChild("sizedelta");
if (deltaElem.HasAttribute("add"))
sizeAdd_ = deltaElem.GetFloat("add");
if (deltaElem.HasAttribute("mul"))
sizeMul_ = deltaElem.GetFloat("mul");
}
if (rootElem.HasChild("color"))
SetColor(rootElem.GetChild("color").GetColor("value"));
if (rootElem.HasChild("colorfade"))
{
Vector<ColorFrame> fades;
XMLElement colorFadeElem = rootElem.GetChild("colorfade");
while (colorFadeElem)
{
fades.Push(ColorFrame(colorFadeElem.GetColor("color"), colorFadeElem.GetFloat("time")));
colorFadeElem = colorFadeElem.GetNext("colorfade");
}
SetColors(fades);
}
if (rootElem.HasChild("texanim"))
{
Vector<TextureFrame> animations;
XMLElement animElem = rootElem.GetChild("texanim");
while (animElem)
{
TextureFrame animation;
animation.uv_ = animElem.GetRect("uv");
animation.time_ = animElem.GetFloat("time");
animations.Push(animation);
animElem = animElem.GetNext("texanim");
}
textureFrames_ = animations;
}
MarkNetworkUpdate();
return true;
}
bool ParticleEffect2D::BeginLoad(Deserializer& source)
{
loadSpriteName_.Clear();
XMLFile xmlFile(context_);
if (!xmlFile.Load(source))
return false;
XMLElement rootElem = xmlFile.GetRoot("particleEmitterConfig");
if (!rootElem)
return false;
String texture = rootElem.GetChild("texture").GetAttribute("name");
loadSpriteName_ = GetParentPath(GetName()) + texture;
// If async loading, request the sprite beforehand
if (GetAsyncLoadState() == ASYNC_LOADING)
GetSubsystem<ResourceCache>()->BackgroundLoadResource<Sprite2D>(loadSpriteName_, true, this);
sourcePositionVariance_ = ReadVector2(rootElem, "sourcePositionVariance");
speed_ = ReadFloat(rootElem, "speed");
speedVariance_ = ReadFloat(rootElem, "speedVariance");
particleLifeSpan_ = Max(0.01f, ReadFloat(rootElem, "particleLifeSpan"));
particleLifespanVariance_ = ReadFloat(rootElem, "particleLifespanVariance");
angle_ = ReadFloat(rootElem, "angle");
angleVariance_ = ReadFloat(rootElem, "angleVariance");
gravity_ = ReadVector2(rootElem, "gravity");
radialAcceleration_ = ReadFloat(rootElem, "radialAcceleration");
tangentialAcceleration_ = ReadFloat(rootElem, "tangentialAcceleration");
radialAccelVariance_ = ReadFloat(rootElem, "radialAccelVariance");
tangentialAccelVariance_ = ReadFloat(rootElem, "tangentialAccelVariance");
startColor_ = ReadColor(rootElem, "startColor");
startColorVariance_ = ReadColor(rootElem, "startColorVariance");
finishColor_ = ReadColor(rootElem, "finishColor");
finishColorVariance_ = ReadColor(rootElem, "finishColorVariance");
maxParticles_ = ReadInt(rootElem, "maxParticles");
startParticleSize_ = ReadFloat(rootElem, "startParticleSize");
startParticleSizeVariance_ = ReadFloat(rootElem, "startParticleSizeVariance");
finishParticleSize_ = ReadFloat(rootElem, "finishParticleSize");
// Typo in pex file
FinishParticleSizeVariance_ = ReadFloat(rootElem, "FinishParticleSizeVariance");
duration_ = M_INFINITY;
if (rootElem.HasChild("duration"))
{
float duration = ReadFloat(rootElem, "duration");
if (duration > 0.0f)
duration_ = duration;
}
emitterType_ = (EmitterType2D)ReadInt(rootElem, "emitterType");
maxRadius_ = ReadFloat(rootElem, "maxRadius");
maxRadiusVariance_ = ReadFloat(rootElem, "maxRadiusVariance");
minRadius_ = ReadFloat(rootElem, "minRadius");
minRadiusVariance_ = ReadFloat(rootElem, "minRadiusVariance");
rotatePerSecond_ = ReadFloat(rootElem, "rotatePerSecond");
rotatePerSecondVariance_ = ReadFloat(rootElem, "rotatePerSecondVariance");
int blendFuncSource = ReadInt(rootElem, "blendFuncSource");
int blendFuncDestination = ReadInt(rootElem, "blendFuncDestination");
blendMode_ = BLEND_ALPHA;
for (int i = 0; i < MAX_BLENDMODES; ++i)
{
if (blendFuncSource == srcBlendFuncs[i] && blendFuncDestination == destBlendFuncs[i])
{
blendMode_ = (BlendMode)i;
break;
}
}
rotationStart_ = ReadFloat(rootElem, "rotationStart");
rotationStartVariance_ = ReadFloat(rootElem, "rotationStartVariance");
rotationEnd_ = ReadFloat(rootElem, "rotationEnd");
rotationEndVariance_ = ReadFloat(rootElem, "rotationEndVariance");
return true;
}
bool TmxFile2D::LoadTileSet(const XMLElement& element)
{
int firstgid = element.GetInt("firstgid");
XMLElement tileSetElem;
if (element.HasAttribute("source"))
{
String source = element.GetAttribute("source");
HashMap<String, SharedPtr<XMLFile> >::Iterator i = tsxXMLFiles_.Find(source);
if (i == tsxXMLFiles_.End())
{
SharedPtr<XMLFile> tsxXMLFile = LoadTSXFile(source);
if (!tsxXMLFile)
return false;
// Add to napping to avoid release
tsxXMLFiles_[source] = tsxXMLFile;
tileSetElem = tsxXMLFile->GetRoot("tileset");
}
else
tileSetElem = i->second_->GetRoot("tileset");
}
else
tileSetElem = element;
XMLElement imageElem = tileSetElem.GetChild("image");
String textureFilePath = GetParentPath(GetName()) + imageElem.GetAttribute("source");
ResourceCache* cache = GetSubsystem<ResourceCache>();
SharedPtr<Texture2D> texture(cache->GetResource<Texture2D>(textureFilePath));
if (!texture)
{
URHO3D_LOGERROR("Could not load texture " + textureFilePath);
return false;
}
tileSetTextures_.Push(texture);
int tileWidth = tileSetElem.GetInt("tilewidth");
int tileHeight = tileSetElem.GetInt("tileheight");
int spacing = tileSetElem.GetInt("spacing");
int margin = tileSetElem.GetInt("margin");
int imageWidth = imageElem.GetInt("width");
int imageHeight = imageElem.GetInt("height");
// Set hot spot at left bottom
Vector2 hotSpot(0.0f, 0.0f);
if (tileSetElem.HasChild("tileoffset"))
{
XMLElement offsetElem = tileSetElem.GetChild("tileoffset");
hotSpot.x_ += offsetElem.GetFloat("x") / (float)tileWidth;
hotSpot.y_ += offsetElem.GetFloat("y") / (float)tileHeight;
}
int gid = firstgid;
for (int y = margin; y + tileHeight <= imageHeight - margin; y += tileHeight + spacing)
{
for (int x = margin; x + tileWidth <= imageWidth - margin; x += tileWidth + spacing)
{
SharedPtr<Sprite2D> sprite(new Sprite2D(context_));
sprite->SetTexture(texture);
sprite->SetRectangle(IntRect(x, y, x + tileWidth, y + tileHeight));
sprite->SetHotSpot(hotSpot);
gidToSpriteMapping_[gid++] = sprite;
}
}
for (XMLElement tileElem = tileSetElem.GetChild("tile"); tileElem; tileElem = tileElem.GetNext("tile"))
{
if (tileElem.HasChild("properties"))
{
SharedPtr<PropertySet2D> propertySet(new PropertySet2D());
propertySet->Load(tileElem.GetChild("properties"));
gidToPropertySetMapping_[firstgid + tileElem.GetInt("id")] = propertySet;
}
}
return true;
}
bool TmxObjectGroup2D::Load(const XMLElement& element, const TileMapInfo2D& info)
{
LoadInfo(element);
for (XMLElement objectElem = element.GetChild("object"); objectElem; objectElem = objectElem.GetNext("object"))
{
SharedPtr<TileMapObject2D> object(new TileMapObject2D());
if (objectElem.HasAttribute("name"))
object->name_ = objectElem.GetAttribute("name");
if (objectElem.HasAttribute("type"))
object->type_ = objectElem.GetAttribute("type");
if (objectElem.HasAttribute("gid"))
object->objectType_ = OT_TILE;
else if (objectElem.HasChild("polygon"))
object->objectType_ = OT_POLYGON;
else if (objectElem.HasChild("polyline"))
object->objectType_ = OT_POLYLINE;
else if (objectElem.HasChild("ellipse"))
object->objectType_ = OT_ELLIPSE;
else
object->objectType_ = OT_RECTANGLE;
const Vector2 position(objectElem.GetFloat("x"), objectElem.GetFloat("y"));
const Vector2 size(objectElem.GetFloat("width"), objectElem.GetFloat("height"));
switch (object->objectType_)
{
case OT_RECTANGLE:
case OT_ELLIPSE:
object->position_ = info.ConvertPosition(Vector2(position.x_, position.y_ + size.y_));
object->size_ = Vector2(size.x_ * PIXEL_SIZE, size.y_ * PIXEL_SIZE);
break;
case OT_TILE:
object->position_ = info.ConvertPosition(position);
object->gid_ = objectElem.GetInt("gid");
object->sprite_ = tmxFile_->GetTileSprite(object->gid_);
if (objectElem.HasAttribute("width") || objectElem.HasAttribute("height"))
{
object->size_ = Vector2(size.x_ * PIXEL_SIZE, size.y_ * PIXEL_SIZE);
}
else if (object->sprite_)
{
IntVector2 spriteSize = object->sprite_->GetRectangle().Size();
object->size_ = Vector2(spriteSize.x_, spriteSize.y_);
}
break;
case OT_POLYGON:
case OT_POLYLINE:
{
Vector<String> points;
const char* name = object->objectType_ == OT_POLYGON ? "polygon" : "polyline";
XMLElement polygonElem = objectElem.GetChild(name);
points = polygonElem.GetAttribute("points").Split(' ');
if (points.Size() <= 1)
continue;
object->points_.Resize(points.Size());
for (unsigned i = 0; i < points.Size(); ++i)
{
points[i].Replace(',', ' ');
Vector2 point = position + ToVector2(points[i]);
object->points_[i] = info.ConvertPosition(point);
}
}
break;
default: break;
}
if (objectElem.HasChild("properties"))
{
object->propertySet_ = new PropertySet2D();
object->propertySet_->Load(objectElem.GetChild("properties"));
}
objects_.Push(object);
}
if (element.HasChild("properties"))
LoadPropertySet(element.GetChild("properties"));
return true;
}
