public void Release()
{
Log("", " *** Release ***********************************************", "");
preventRelease = true;
#if THREAD_SAFE_CONTENT
lock (lockObject)
#endif
foreach (var r in contentByMetaResourceAndType)
{
OnDestroy(r.Value.MetaResource, r.Value);
var key = new Common.Tuple <Type, Type>(r.Value.MetaResource.GetType(), r.Value.Object.GetType());
mappers[key].Do(MetaResourceDo.Release, r.Value.MetaResource, this, r.Value.Object);
}
RemoveToPrunes();
#if THREAD_SAFE_CONTENT
lock (lockObject)
{
#endif
contentByMetaResourceAndType.Clear();
contentByResource.Clear();
#if THREAD_SAFE_CONTENT
}
#endif
preventRelease = false;
}
public LoadingScreen(string picturePath, Vector2 pictureSize)
{
Background = new ImageGraphic
{
Texture = new TextureFromFile("Interface/LoadingScreen/background.png"),
TextureAdressMode = SlimDX.Direct3D9.TextureAddress.Wrap,
};
Common.Tuple<string, Vector2> picture;
if (picturePath != null)
picture = new Common.Tuple<string, Vector2>(picturePath, pictureSize);
else
picture = defaultPictures[new Random().Next(defaultPictures.Length)];
var picMetaTexture = new TextureFromFile(picture.First) { DontScale = true };
var pic = new Control
{
Background = new ImageGraphic
{
Texture = picMetaTexture,
SizeMode = SizeMode.AutoAdjust
},
Anchor = Orientation.Center,
Size = picture.Second
};
Dock = System.Windows.Forms.DockStyle.Fill;
pic.AddChild(progress);
AddChild(pic);
}
void RemoveToPrunes()
{
foreach (var r in pruneToDestroy)
{
OnDestroy(r.Value.MetaResource, r.Value);
var key = new Common.Tuple <Type, Type>(r.Value.MetaResource.GetType(), r.Value.Object.GetType());
mappers[key].Do(MetaResourceDo.Release, r.Value.MetaResource, this, r.Value.Object);
}
pruneToDestroy.Clear();
}
/// <summary>
/// Temporary acquire of an object which does not need to be Released
/// The object can only be guaranteed to be valid until the next Prune
/// </summary>
public T Peek <T>(MetaResourceBase metaResource) where T : class
{
if (metaResource == null)
{
return(default(T));
}
OnPeek(metaResource);
VerifyMetaResource(metaResource);
// This is a small optimization, just see if the last acquired object was the same as this one,
// in that case return it. Turns out often around half the acquires can be handled like this
if (Object.Equals(lastAcquiredMetaResource, metaResource))
{
lastAcquiredResource.LastAcquired = pruneK;
return((T)lastAcquiredResource.Object);
}
var key = new Common.Tuple <MetaResourceBase, Type>(metaResource, typeof(T));
Resource o = null;
#if THREAD_SAFE_CONTENT
lock (lockObject)
#endif
if (contentByMetaResourceAndType.TryGetValue(key, out o))
{
o.LastAcquired = pruneK;
key.First = (MetaResourceBase)metaResource.Clone();
lastAcquiredMetaResource = key;
lastAcquiredResource = o;
return((T)o.Object);
}
T ob;
if (resetting)
{
ob = ResetAcquire <T>(metaResource);
}
else
{
ob = Acquire <T>(metaResource);
}
Release(ob);
return(ob);
}
/// <summary>
/// Remove all dead objects
/// </summary>
public void Prune(float dtime)
{
pruneAcc += dtime;
if (pruneAcc >= 1)
{
pruneAcc = 0;
pruneK++;
List <KeyValuePair <Common.Tuple <MetaResourceBase, Type>, Resource> > toRemove =
new List <KeyValuePair <Common.Tuple <MetaResourceBase, Type>, Resource> >();
#if THREAD_SAFE_CONTENT
lock (lockObject)
{
#endif
foreach (var r in contentByMetaResourceAndType)
{
if (r.Value.References <= 0 && r.Value.LastAcquired + pruneDelta < pruneK)
{
pruneToDestroy.Enqueue(r);
toRemove.Add(r);
}
}
foreach (var r in toRemove)
{
contentByResource.Remove(r.Value.Object);
contentByMetaResourceAndType.Remove(r.Key);
}
#if THREAD_SAFE_CONTENT
}
#endif
}
else if (pruneToDestroy.Count > 0)
{
//int nClears = Math.Max(1, pruneToDestroy.Count / 10);
int nClears = pruneToDestroy.Count;
for (int x = 0; x < nClears; x++)
{
var r = pruneToDestroy.Dequeue();
OnDestroy(r.Value.MetaResource, r.Value.Object);
var key = new Common.Tuple <Type, Type>(r.Value.MetaResource.GetType(), r.Value.Object.GetType());
mappers[key].Do(MetaResourceDo.Release, r.Value.MetaResource, this, r.Value.Object);
}
}
}
public void SetMapper(MetaMapperBase mapper, Type metaType, Type resourceType)
{
var key = new Common.Tuple <Type, Type>(metaType, resourceType);
MetaMapperBase oldMapper;
if (mappers.TryGetValue(key, out oldMapper))
{
foreach (var v in contentByMetaResourceAndType.Values)
{
if (v.MetaResource.GetType() == metaType &&
v.Object.GetType() == resourceType)
{
oldMapper.Do(MetaResourceDo.Release, v.MetaResource, this, v.Object);
v.Object = mapper.Do(MetaResourceDo.Construct, v.MetaResource, this, null);
}
}
}
mappers[key] = mapper;
}
T ResetAcquire <T>(MetaResourceBase metaResource) where T : class
{
if (metaResource == null)
{
return(default(T));
}
var key = new Common.Tuple <MetaResourceBase, Type>((MetaResourceBase)metaResource.Clone(), typeof(T));
Resource o;
// This object has already been reset
if (resetResourcesById.TryGetValue(key, out o))
{
return((T)o.Object);
}
// This resource doesn't exists yet, create it
bool ok = false;
#if THREAD_SAFE_CONTENT
lock (lockObject)
#endif
ok = contentByMetaResourceAndType.TryGetValue(key, out o);
if (!ok)
{
return(InnerAcquire <T>(metaResource));
}
var mapperKey = new Common.Tuple <Type, Type>(o.MetaResource.GetType(), o.Object.GetType());
o.Object = mappers[mapperKey].Do(MetaResourceDo.ResetDevice, o.MetaResource, this, o.Object);
OnResetAcquire(o.MetaResource, o.Object);
#if THREAD_SAFE_CONTENT
lock (lockObject)
#endif
contentByResource.Add(o.Object, o);
resetResourcesById.Add(key, o);
return((T)o.Object);
}
public void LostDevice()
{
Log("", " *** LostDevice ********************************************", "");
RemoveToPrunes();
#if HARD_RESET_ON_LOST_DEVICE
Release();
#else
preventRelease = true;
#if THREAD_SAFE_CONTENT
lock (lockObject)
#endif
foreach (Resource r in contentByMetaResourceAndType.Values)
{
OnLostDevice(r.MetaResource, r.Object);
var key = new Common.Tuple <Type, Type>(r.MetaResource.GetType(), r.Object.GetType());
mappers[key].Do(MetaResourceDo.LostDevice, r.MetaResource, this, r.Object);
}
preventRelease = false;
#endif
}
public LoadingScreen(string picturePath, Vector2 pictureSize)
{
Background = new ImageGraphic
{
Texture = new TextureFromFile("Interface/LoadingScreen/background.png"),
TextureAdressMode = SlimDX.Direct3D9.TextureAddress.Wrap,
};
Common.Tuple <string, Vector2> picture;
if (picturePath != null)
{
picture = new Common.Tuple <string, Vector2>(picturePath, pictureSize);
}
else
{
picture = defaultPictures[new Random().Next(defaultPictures.Length)];
}
var picMetaTexture = new TextureFromFile(picture.First)
{
DontScale = true
};
var pic = new Control
{
Background = new ImageGraphic
{
Texture = picMetaTexture,
SizeMode = SizeMode.AutoAdjust
},
Anchor = Orientation.Center,
Size = picture.Second
};
Dock = System.Windows.Forms.DockStyle.Fill;
pic.AddChild(progress);
AddChild(pic);
}
public void ResetDevice()
{
Log("", " *** ResetDevice *******************************************", "");
#if HARD_RESET_ON_LOST_DEVICE
#else
contentByResource.Clear();
resetting = true;
resetResourcesById = new Dictionary <Common.Tuple <MetaResourceBase, Type>, Resource>();
List <Resource> cbmrat;
#if THREAD_SAFE_CONTENT
lock (lockObject)
#endif
cbmrat = new List <Resource>(contentByMetaResourceAndType.Values);
foreach (var r in cbmrat)
{
var key = new Common.Tuple <MetaResourceBase, Type>(r.MetaResource, r.Object.GetType());
if (resetResourcesById.ContainsKey(key))
{
if (log != null)
{
log.Write("Skipping: " + r.MetaResource);
}
continue;
}
OnResetDevice(r.MetaResource, r.Object);
var mapperKey = new Common.Tuple <Type, Type>(r.MetaResource.GetType(), r.Object.GetType());
r.Object = mappers[mapperKey].Do(MetaResourceDo.ResetDevice, r.MetaResource, this, r.Object);
#if THREAD_SAFE_CONTENT
lock (lockObject)
#endif
contentByResource.Add(r.Object, r);
resetResourcesById.Add(key, r);
}
resetting = false;
#endif
}
public void RemoveMapper(Type metaType, Type resourceType)
{
var key = new Common.Tuple <Type, Type>(metaType, resourceType);
mappers.Remove(key);
List <Common.Tuple <MetaResourceBase, Type> > toRemove = new List <Common.Tuple <MetaResourceBase, Type> >();
foreach (var v in contentByMetaResourceAndType)
{
if (v.Value.MetaResource.GetType() == metaType &&
v.Value.Object.GetType() == resourceType)
{
toRemove.Add(v.Key);
contentByResource.Remove(v.Value.Object);
}
}
foreach (var v in toRemove)
{
contentByMetaResourceAndType.Remove(v);
}
}
public static void SetCache(string sqlfmt, params object[] args)
{
var sql = string.Format(sqlfmt, args);
if (_cache_string == sql)
return;
_cache_string = sql;
_cache = Connections.Connection.GetDataTable("cache", sqlfmt, args);
_cache_dictionary = new Dictionary<Common.Tuple<int, int>, DataRow>();
foreach (DataRow row in _cache.Rows)
{
Common.Tuple<int, int> key = new Common.Tuple<int, int>(Convert.ToInt32(row["recnum"]), Convert.ToInt32(row["linnum"]));
_cache_dictionary.Add(key, row);
}
}
T InnerAcquire <T>(MetaResourceBase metaResource) where T : class
{
if (metaResource == null)
{
return(default(T));
}
var key = new Common.Tuple <MetaResourceBase, Type>(metaResource, typeof(T));
// This is a small optimization, just see if the last acquired object was the same as this one,
// in that case return it. Turns out often around half the acquires can be handled like this
if (Object.Equals(lastAcquiredMetaResource, metaResource))
{
OnAcquire(metaResource);
lastAcquiredResource.References++;
lastAcquiredResource.LastAcquired = pruneK;
return((T)lastAcquiredResource.Object);
}
Resource o = null;
#if THREAD_SAFE_CONTENT
lock (lockObject)
{
#endif
if (contentByMetaResourceAndType.TryGetValue(key, out o))
{
OnAcquire(metaResource);
o.References++;
o.LastAcquired = pruneK;
key.First = (MetaResourceBase)metaResource.Clone();
lastAcquiredMetaResource = key;
lastAcquiredResource = o;
return((T)o.Object);
}
key.First = (MetaResourceBase)metaResource.Clone();
#if DEBUG_CONTENT
if (key.First.GetHashCode() != metaResource.GetHashCode())
{
throw new Exception("Error in meta resource Clone or GetHashCode");
}
if (!Object.Equals(key.First, metaResource))
{
string diffs = "";
key.First.ReportEqualsDiffs(metaResource, (d) => diffs += "\n" + d);
throw new Exception("Error in meta resource Clone or Equals\n\nDiffs:\n" + diffs);
}
#endif
var mapperKey = new Common.Tuple <Type, Type>(metaResource.GetType(), typeof(T));
object ob = mappers[mapperKey].Do(MetaResourceDo.Construct, metaResource, this, null);
OnConstruct(metaResource, ob);
if (ob == null)
{
lastAcquiredMetaResource = new Common.Tuple <MetaResourceBase, Type>(null, null);
lastAcquiredResource = null;
return((T)ob);
}
#if DEBUG_CONTENT
if (key.First.GetHashCode() != metaResource.GetHashCode())
{
throw new Exception("MetaResource was changed during construction (No longer the same hash code)");
}
if (!Object.Equals(key.First, metaResource))
{
throw new Exception("MetaResource was changed during construction (No longer Equals)");
}
#endif
#if THREAD_SAFE_CONTENT
//lock (lockObject)
//{
#endif
OnAcquire(metaResource);
contentByMetaResourceAndType.Add(key, o = new Resource
{
MetaResource = metaResource,
Object = ob,
References = 1,
LastAcquired = pruneK,
FirstAcquired = pruneK
});
#if DEBUG_CONTENT
Resource debugR;
if (contentByResource.TryGetValue(o.Object, out debugR))
{
throw new Exception("Content by resource old: " + debugR.MetaResource + " new: " + o.MetaResource);
}
#endif
contentByResource.Add(o.Object, o);
#if THREAD_SAFE_CONTENT
}
#endif
lastAcquiredMetaResource = key;
lastAcquiredResource = o;
return((T)o.Object);
}
protected override void OnUpdate(UpdateEventArgs e)
{
base.OnUpdate(e);
if (fade)
{
fadeSurvive -= e.Dtime;
offset += e.Dtime;
entity.Remove();
if (fadeSurvive < 0)
Remove();
float opacity = fadeSurvive / fadeTotal;
entity.MainGraphic = new MetaModel
{
Opacity = opacity,
ReceivesAmbientLight = Priority.Never,
ReceivesDiffuseLight = Priority.Never,
ReceivesFog = false,
HasAlpha = true,
Texture = texture,
XMesh = new MeshConcretize
{
Mesh = MeshFromCoordinates(this.coordinates),
Layout = global::Graphics.Software.Vertex.PositionNormalTexcoord.Instance
}
};
AddChild(entity);
}
else if (delay < 0)
{
ttl -= e.Dtime;
offset += e.Dtime;
var ea = Scene.View.Content.Peek<global::Graphics.Renderer.Renderer.EntityAnimation>(mainCharacter.MetaEntityAnimation);
Common.Tuple<Vector3, Vector3> coordinates = new Common.Tuple<Vector3, Vector3>(Vector3.Zero, SwordOffset);
var hand = ea.GetFrame("sword1");
coordinates.First = Vector3.TransformCoordinate(coordinates.First, ea.FrameTransformation[hand]);
coordinates.Second = Vector3.TransformCoordinate(coordinates.Second, ea.FrameTransformation[hand]);
this.coordinates.Add(coordinates);
if (this.coordinates.Count > 1)
{
entity.Remove();
entity.MainGraphic = new MetaModel
{
ReceivesAmbientLight = Priority.Never,
ReceivesDiffuseLight = Priority.Never,
HasAlpha = true,
Texture = texture,
XMesh = new MeshConcretize
{
Mesh = MeshFromCoordinates(this.coordinates),
Layout = global::Graphics.Software.Vertex.PositionNormalTexcoord.Instance
}
};
//if (opacity < 0.2f)
// System.Diagnostics.Debugger.Break();
AddChild(entity);
if (ttl < fadeSurvive)
fade = true;
}
}
else
delay -= e.Dtime;
}
