/// <summary>
/// Removes the light.
/// </summary>
/// <param name="light">The light.</param>
public virtual void RemoveLight(ILight light)
{
if (light == null)
{
ActiveLogger.LogMessage("Cant remove null Light", LogLevel.RecoverableError);
return;
}
bool resp = Lights.Remove(light);
if (!resp)
{
ActiveLogger.LogMessage("Light not found: " + light.Name, LogLevel.Warning);
}
}
/// <summary>
/// Add a Dummy to the world
/// Its like a position,
/// usefull to serializable position from a world editor
/// </summary>
/// <param name="dummy">The dummy.</param>
public virtual void AddDummy(IDummy dummy)
{
if (dummy == null)
{
ActiveLogger.LogMessage("Cant Add Null dummy", LogLevel.RecoverableError);
return;
}
if (String.IsNullOrEmpty(dummy.Name))
{
ActiveLogger.LogMessage("Dummy with no Name", LogLevel.Warning);
}
Dummies.Add(dummy);
}
/// <summary>
/// Removes the dummy.
/// </summary>
/// <param name="dummy">The dummy.</param>
public virtual void RemoveDummy(IDummy dummy)
{
if (dummy == null)
{
ActiveLogger.LogMessage("Cant Remove Null dummy", LogLevel.RecoverableError);
return;
}
bool resp = Dummies.Remove(dummy);
if (!resp)
{
ActiveLogger.LogMessage("Dummy not found: " + dummy.Name, LogLevel.Warning);
}
}
public override void RemoveSoundEmitter(Audio.ISoundEmitter3D em)
{
if (em == null)
{
ActiveLogger.LogMessage("Emitter is Null " + em.ToString(), LogLevel.RecoverableError);
return;
}
bool resp = SoundEmiters3D.Remove(em);
if (!resp)
{
ActiveLogger.LogMessage("Emitter not found: " + em.ToString(), LogLevel.Warning);
}
}
public Texture2D this[DeferredLightMapType type]
{
get {
switch (type)
{
case DeferredLightMapType.LIGHTMAP:
return(lightRT);
default:
ActiveLogger.LogMessage("DeferredLightMapTypetype not present", LogLevel.FatalError);
throw new Exception("Type not present in this implementation");
}
}
}
/// <summary>
/// Add a camera
/// if camera name is DEFAULTCAMERA it becomes the active one
/// </summary>
/// <param name="cam"></param>
/// <param name="name"></param>
public void AddCamera(ICamera cam, String name)
{
if (cam == null || String.IsNullOrEmpty(name))
{
ActiveLogger.LogMessage("Can add null camera or invalid name, Skipping adding this Camera", LogLevel.RecoverableError);
return;
}
CameraDescription cc;
cc.cam = cam;
cc.name = name;
_cameras.Add(cc);
}
protected override void AfterLoadContent(IContentManager manager, Engine.GraphicInfo ginfo, Engine.GraphicFactory factory)
{
this.ginfo = ginfo;
if (desc.UseFloatingBufferForLightMap)
{
if (ginfo.CheckIfRenderTargetFormatIsSupported(SurfaceFormat.HdrBlendable, DepthFormat.Depth24Stencil8, ginfo.UseMipMap, ginfo.MultiSample) == false)
{
throw new NotSupportedException("The plataform does not support the specified Render target Combination for Deferred Rendering, check the logs for more info");
}
}
if (ginfo.CheckIfRenderTargetFormatIsSupported(SurfaceFormat.Color, DepthFormat.Depth24Stencil8, ginfo.UseMipMap, ginfo.MultiSample) == false)
{
throw new NotSupportedException("The plataform does not support the specified Render target Combination for Deferred Rendering, check the logs for more info");
}
if (ginfo.CheckIfRenderTargetFormatIsSupported(SurfaceFormat.Single, DepthFormat.Depth24Stencil8, false, 0) == false)
{
throw new NotSupportedException("The plataform does not support the specified Render target Combination for Deferred Rendering, check the logs for more info");
}
if (ginfo.CheckIfRenderTargetFormatIsSupported(SurfaceFormat.Single, DepthFormat.Depth24Stencil8, ginfo.UseMipMap, ginfo.MultiSample) == false)
{
ActiveLogger.LogMessage("Shadow can behave strange, you dont have the minimum requirements", LogLevel.Warning);
}
deferredGBuffer.LoadContent(manager, ginfo, factory, desc.BackGroundColor, desc.UseFloatingBufferForLightMap);
deferredLightMap.LoadContent(manager, ginfo, factory, desc.CullPointLight, desc.UseFloatingBufferForLightMap);
deferredFinalCombination.LoadContent(manager, ginfo, factory, desc.UseFloatingBufferForLightMap, desc.ExtraForwardPass);
if (desc.UseFloatingBufferForLightMap)
{
target = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.HdrBlendable, ginfo.UseMipMap, DepthFormat.Depth24Stencil8, ginfo.MultiSample);
target2 = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.HdrBlendable, ginfo.UseMipMap, DepthFormat.Depth24Stencil8, ginfo.MultiSample);
}
else
{
target = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.Depth24Stencil8, ginfo.MultiSample);
target2 = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight, SurfaceFormat.Color, ginfo.UseMipMap, DepthFormat.Depth24Stencil8, ginfo.MultiSample);
}
PostEffectTarget = target;
halfWidth = ginfo.Viewport.Width / 2;
halfHeight = ginfo.Viewport.Height / 2;
restoreDepth = new RestoreDepth(desc.UseFloatingBufferForLightMap, manager, factory, ginfo);
}
/// <summary>
/// Removes the sound emitter.
/// </summary>
/// <param name="em">The em.</param>
public virtual void RemoveSoundEmitter(ISoundEmitter2D em)
{
if (em == null)
{
ActiveLogger.LogMessage("Emitter is Null " + em.ToString(), LogLevel.RecoverableError);
return;
}
em.Stop();
bool resp = SoundEmiters2D.Remove(em);
if (!resp)
{
ActiveLogger.LogMessage("Emitter not found: " + em.ToString(), LogLevel.Warning);
}
}
/// <summary>
/// Adds an object to the world.
/// </summary>
/// <param name="obj">The obj.</param>
/// <returns></returns>
public virtual void AddObject(I2DObject obj)
{
if (obj == null)
{
ActiveLogger.LogMessage("Cant add null obj", LogLevel.RecoverableError);
return;
}
EntityMapper.getInstance().AddEntity(obj);
obj.Material.Initialization(GraphicsInfo, GraphicsFactory, obj);
PhysicWorld.AddObject(obj.PhysicObject);
obj.PhysicObject.Owner = obj;
Objects.Add(obj);
culler.onObjectAdded(obj);
}
/// <summary>
/// Adds the sound emitter.
/// </summary>
/// <param name="em">The em.</param>
/// <param name="play">if set to <c>true</c> [play].</param>
public virtual void AddSoundEmitter(ISoundEmitter3D em, bool play = false)
{
if (em == null)
{
ActiveLogger.LogMessage("Emitter is Null " + em.ToString(), LogLevel.RecoverableError);
return;
}
SoundEmiters3D.Add(em);
em.Apply3D();
if (play)
{
em.Play();
}
}
public Texture2D this[GBufferTypes type]
{
get
{
if (type == GBufferTypes.FINALIMAGE)
{
return(this.target);
}
else
{
ActiveLogger.LogMessage("Wrong Image Type requested", LogLevel.FatalError);
throw new Exception("wrong type");
}
}
}
/// <summary>
/// Adds one post effect.
/// </summary>
/// <param name="postEffect">The post effect.</param>
public virtual void AddPostEffect(IPostEffect postEffect)
{
System.Diagnostics.Debug.Assert(postEffect != null);
if ((postEffect.PostEffectType & PostEffectType) != PostEffectType)
{
ActiveLogger.LogMessage("Trying to add a wrong post effect for this Render Technich, pls check if the PostEffectType of the IPostEffect is All or " + PostEffectType + ", The engine is ignoring this operation", LogLevel.RecoverableError);
}
else
{
if (ginfo != null && factory != null)
{
postEffect.Init(ginfo, factory);
}
PostEffects.Push(postEffect);
postEffect.tech = this;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TextureInformation"/> class.
/// </summary>
/// <param name="isinternal">if set to <c>true</c> [isinternal].</param>
/// <param name="factory">The factory.</param>
/// <param name="diffuseTextureName">Name of the diffuse texture.</param>
/// <param name="bumpTextureName">Name of the bump texture.</param>
/// <param name="specularTextureName">Name of the specular texture.</param>
/// <param name="glowTextureName">Name of the glow texture.</param>
public TextureInformation(bool isinternal, GraphicFactory factory, String diffuseTextureName = null, String bumpTextureName = null, String specularTextureName = null, String glowTextureName = null)
{
isDisposed = false;
this.isInternal = isinternal;
if (factory == null)
{
ActiveLogger.LogMessage("Factory Cannot Be null", LogLevel.FatalError);
throw new Exception("Factory Cannot Be null");
}
this._diffuseName = diffuseTextureName;
this._specularName = specularTextureName;
this._bumpName = bumpTextureName;
this._glowName = glowTextureName;
this.factory = factory;
}
public override void RemoveObject(IObject obj)
{
if (obj == null)
{
ActiveLogger.LogMessage("Cant remove with null obj", LogLevel.RecoverableError);
return;
}
obj.RemoveThisObject();
EntityMapper.getInstance().RemoveEntity(obj);
PhysicWorld.RemoveObject(obj.PhysicObject);
bool resp = Objects.Remove(obj);
if (!resp)
{
ActiveLogger.LogMessage("Cant remove (not found) obj: " + obj.Name, LogLevel.RecoverableError);
}
}
public override void Initialize(Engine.GraphicInfo ginfo, Engine.GraphicFactory factory, IObject obj)
{
base.Initialize(ginfo, factory, obj);
effect = factory.GetEffect("Water", true, true);
normal = factory.GetTexture2D("waves2", true);
//effect.Parameters["tNormalMap"].SetValue(factory.GetTexture2D("waves2",true));
if (String.IsNullOrEmpty(TexureName) && environmentTexture == null)
{
ActiveLogger.LogMessage("WaterModel: TextCubeName cannot be null/empty", LogLevel.FatalError);
throw new Exception("WaterModel: TextCubeName cannot be null/empty");
}
if (environmentTexture == null)
{
environmentTexture = factory.GetTextureCube(TexureName);
}
}
/// <summary>
/// Determines whether [This Audio Player has] [the specified sound effect name].
/// </summary>
/// <param name="soundEffectName">Name of the sound effect.</param>
/// <returns>
/// <c>true</c> if [has the specified sound effect] otherwise, <c>false</c>.
/// </returns>
public bool HasSoundEffect(String soundEffectName)
{
if (String.IsNullOrEmpty(soundEffectName))
{
ActiveLogger.LogMessage("Bad sound effect name (null/empty) on GetSound(), returning false", LogLevel.Warning);
return(false);
}
if (musics.ContainsKey(soundEffectName))
{
return(true);
}
else
{
return(false);
}
}
private void onfinished(IAsyncResult ar)
{
if (ar.IsCompleted == false)
{
ActiveLogger.LogMessage("Thread finished with errors " + ar.ToString(), LogLevel.RecoverableError);
return;
}
ITask task = ar.AsyncState as ITask;
System.Diagnostics.Debug.Assert(task != null);
lock (finished)
{
finished.Add(task);
}
}
/// <summary>
/// Starts the task.
/// </summary>
/// <param name="task">The task.</param>
public void StartTask(ITask task)
{
#if !WINDOWS_PHONE
Task t = new Task(task.Process);
if (task.TaskEndType == TaskEndType.INSTANT)
{
t.BeginInvoke(new AsyncCallback(task.Result), null);
}
else if (task.TaskEndType == TaskEndType.ON_NEXT_UPDATE)
{
t.BeginInvoke(new AsyncCallback(onfinished), task);
}
#else
Worker worker = new Worker();
worker.DoWork += new System.ComponentModel.DoWorkEventHandler(
(a, b) => task.Process()
);
if (task.TaskEndType == TaskEndType.INSTANT)
{
worker.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(
(a, b) => task.Result()
);
}
else if (task.TaskEndType == TaskEndType.ON_NEXT_UPDATE)
{
worker.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(
(a, b) =>
{
if (b.Error != null)
{
ActiveLogger.LogMessage("Thread finished with errors " + b.Error.ToString(), LogLevel.RecoverableError);
return;
}
lock (finished)
{
finished.Add(task);
}
}
);
}
worker.RunWorkerAsync();
#endif
}
/// <summary>
/// Removes the effect from repository.
/// </summary>
/// <param name="soundEffectName">Name of the sound effect.</param>
public void RemoveSoundFromRepository(string soundEffectName)
{
System.Diagnostics.Debug.Assert(!String.IsNullOrEmpty(soundEffectName));
if (String.IsNullOrEmpty(soundEffectName))
{
ActiveLogger.LogMessage("Bad sound effect name (null/empty), not removing the sound", LogLevel.Warning);
return;
}
if (musics.ContainsKey(soundEffectName))
{
musics.Remove(soundEffectName);
}
else
{
ActiveLogger.LogMessage("Sound not found on repo: " + soundEffectName, LogLevel.Warning);
}
}
/// <summary>
/// Sets the bilboard instances.
/// </summary>
/// <param name="instances">The instances.</param>
public void SetBilboardInstances(BilboardInstance[] instances)
{
if (instances.Count() < dynamicBufferSize)
{
this.instances = instances;
BatchInformations[0][0].InstanceCount = instances.Count();
BatchInformations[0][0].InstancedVertexBuffer.SetData(instances);
}
else
{
ActiveLogger.LogMessage("Calling SetBilboardInstances with different BilboardInstance size is not recomended, lot of performance penalty here", LogLevel.Warning);
this.instances = instances;
VertexBuffer InstancedvertexBufferS = factory.CreateDynamicVertexBuffer(vd, instances.Count(), BufferUsage.WriteOnly);
InstancedvertexBufferS.SetData(instances);
BatchInformations[0][0].InstanceCount = instances.Count();
BatchInformations[0][0].InstancedVertexBuffer = InstancedvertexBufferS;
}
}
/// <summary>
/// Gets the sound effect instance.
/// The SimpleSoundEffect MUST BE ALREADY IN THE REPO !!!
/// TO CREATE A Non SHARED SIMPLESOUNDEFFECT, USE THE SIMPLESOUNDEFFECT CONSTRUTOR.
/// </summary>
/// <param name="soundEffectName">Name of the sound effect.</param>
/// <returns></returns>
public SimpleSoundEffect GetSoundEffectInstance(String soundEffectName)
{
if (String.IsNullOrEmpty(soundEffectName))
{
ActiveLogger.LogMessage("Bad sound effect name (null/empty) on GetSound(), returning null", LogLevel.Warning);
return(null);
}
if (musics.ContainsKey(soundEffectName))
{
return(musics[soundEffectName]);
}
else
{
ActiveLogger.LogMessage("Sound Not Found in this Repo", LogLevel.Warning);
return(null);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DeferredCustomShader"/> class.
/// </summary>
/// <param name="useGlow">if set to <c>true</c> [use glow].</param>
/// <param name="useBump">if set to <c>true</c> [use bump].</param>
/// <param name="useSpecular">if set to <c>true</c> [use specular].</param>
/// <param name="useParalax">if set to <c>true</c> [use paralax].</param>
/// /// <param name="useAmbientCubeMap">if set to <c>true</c> [use AmbientCubeMap].</param>
/// <param name="specularIntensity">The specular intensity.</param>
/// <param name="specularPower">The specular power.</param>
/// <param name="ambientCubeMapScale ">The ambientCubeMap Scale.</param>
public DeferredCustomShader(bool useGlow, bool useBump, bool useSpecular, bool useParalax, bool useAmbientCubeMap = false, float specularIntensity = 0, float specularPower = 0, float ambientCubeMapScale = 0.1f)
{
if (specularPower < 0)
{
ActiveLogger.LogMessage("specularPower cannot be negative, setting to 0", LogLevel.RecoverableError);
specularPower = 0;
}
if (specularIntensity < 0)
{
ActiveLogger.LogMessage("specularIntensity cannot be negative, setting to 0", LogLevel.RecoverableError);
specularIntensity = 0;
}
if (ambientCubeMapScale < 0)
{
ActiveLogger.LogMessage("ambientCubeMapScale cannot be negative, setting to 0.1f", LogLevel.RecoverableError);
ambientCubeMapScale = 0.1f;
}
this.AmbientCubeMapScale = ambientCubeMapScale;
this.effect = "AllBuffer";
this.specularIntensity = specularIntensity;
this.specularPower = specularPower;
this.useGlow = useGlow;
this.useSpecular = useSpecular;
this.useBump = useBump;
this.useParalax = useParalax;
specularPowerMapScale = 1;
specularIntensityMapScale = 1;
if (useAmbientCubeMap == true && useGlow == true)
{
ActiveLogger.LogMessage("Cant enable GLow and AmbientCubeMap together, AmbientCubeMap being disabled", LogLevel.RecoverableError);
useAmbientCubeMap = false;
}
this.UseAmbientCubeMap = useAmbientCubeMap;
if (useParalax == true && useBump == false)
{
ActiveLogger.LogMessage("Are you sure you will use only Paralax without BUMP, the paralax expects bump", LogLevel.Warning);
}
}
/// <summary>
/// Sets the cube texture.
/// </summary>
/// <param name="tex">The tex.</param>
/// <param name="type">The type.</param>
public void SetCubeTexture(TextureCube tex, TextureType type)
{
switch (type)
{
case TextureType.AMBIENT_CUBE_MAP:
this._ambientName = "CUSTOM";
this.ambient = tex;
break;
case TextureType.ENVIRONMENT:
this._reflectionName = "CUSTOM";
this.reflection = tex;
break;
default:
ActiveLogger.LogMessage("Setting Invalid Type of Texture", LogLevel.RecoverableError);
break;
}
}
/// <summary>
/// Removes the trigger.
/// </summary>
/// <param name="trigger">The trigger.</param>
public virtual void RemoveTrigger(ITrigger trigger)
{
if (trigger == null)
{
ActiveLogger.LogMessage("Cant Remove Null Trigger", LogLevel.RecoverableError);
return;
}
bool resp = Triggers.Remove(trigger);
if (!resp)
{
ActiveLogger.LogMessage("Trigger not found: " + trigger.Name, LogLevel.Warning);
}
if (trigger.GhostObject != null)
{
PhysicWorld.RemoveObject(trigger.GhostObject);
}
}
/// <summary>
/// Removes the particle system.
/// </summary>
/// <param name="particleSystem">The particle system.</param>
public override void RemoveParticleSystem(IParticleSystem particleSystem)
{
System.Diagnostics.Debug.Assert(particleSystem != null, "Particle System cannot be null");
if (particleSystem is DPFSParticleSystem)
{
if (ParticleSystem.ContainsKey(particleSystem.Name))
{
manager.RemoveParticleSystem((particleSystem as DPFSParticleSystem).IDPSFParticleSystem);
}
else
{
ActiveLogger.LogMessage("Particle System do not Exist", LogLevel.Warning);
}
}
else
{
ActiveLogger.LogMessage("You can only remove DPFS particles in this manager, operation ignored", LogLevel.RecoverableError);
}
}
public Microsoft.Xna.Framework.Graphics.Texture2D this[GBufferTypes type]
{
get {
switch (type)
{
case GBufferTypes.DEPH:
return(depthRT);
case GBufferTypes.NORMAL:
return(normalRT);
case GBufferTypes.Extra1:
return(lightOclusionRT);
default:
ActiveLogger.LogMessage("Invalid Buffer requested", LogLevel.FatalError);
throw new Exception("This GBUFFER dont use this Buffer Type");
}
}
}
/// <summary>
/// Adds the trigger.
/// </summary>
/// <param name="trigger">The trigger.</param>
public virtual void AddTrigger(ITrigger trigger)
{
if (trigger == null)
{
ActiveLogger.LogMessage("Cant Add null Trigger", LogLevel.RecoverableError);
return;
}
if (String.IsNullOrEmpty(trigger.Name))
{
ActiveLogger.LogMessage("Trigger with no Name", LogLevel.Warning);
}
Triggers.Add(trigger);
if (trigger.GhostObject != null)
{
PhysicWorld.AddObject(trigger.GhostObject);
}
}
/// <summary>
/// Adds the and initialize particle system.
/// </summary>
/// <param name="particleSystem">The particle system.</param>
public override void AddAndInitializeParticleSystem(IParticleSystem particleSystem)
{
System.Diagnostics.Debug.Assert(particleSystem != null, "Particle System cannot be null");
if (ParticleSystem.ContainsKey(particleSystem.Name))
{
ActiveLogger.LogMessage("Particle System already exist, overwriting", LogLevel.Warning);
}
ParticleSystem[particleSystem.Name] = particleSystem as DPFSParticleSystem;
if (particleSystem is DPFSParticleSystem)
{
DPFSParticleSystem ps = particleSystem as DPFSParticleSystem;
ps.IDPSFParticleSystem.AutoInitialize(GraphicFactory.device, GraphicFactory.contentManager.ContentManager, GraphicFactory.SpriteBatch);
manager.AddParticleSystem(ps.IDPSFParticleSystem);
}
else
{
ActiveLogger.LogMessage("You can only add DPFS particles in this manager, operation ignored", LogLevel.RecoverableError);
}
}
protected override void Update(Microsoft.Xna.Framework.GameTime gameTime)
{
if (firstTime)
{
bet.InitOrRestart(gameTime);
firstTime = false;
}
if (bet.hasPassed(gameTime))
{
i += 1;
if (i == IScreen.Count)
{
Environment.Exit(0);
}
ScreenManager.AddScreen(IScreen[i]);
TimePassed.InitOrRestart(gameTime);
ActiveLogger.LogMessage("Added Screen: " + IScreen[i].GetType().AssemblyQualifiedName, LogLevel.Info);
if (pathToScreenShot != null)
{
takeScreen = true;
}
}
if (TimePassed.hasPassed(gameTime))
{
ScreenManager.RemoveScreen(IScreen[i]);
bet.InitOrRestart(gameTime);
ActiveLogger.LogMessage("Removed Screen: " + IScreen[i].GetType().AssemblyQualifiedName, LogLevel.Info);
foreach (var item in contentManager.DumpAssetReferenceCount())
{
ActiveLogger.LogMessage("Assets Dump: " + item.Key + " : " + item.Value, LogLevel.Info);
}
System.Diagnostics.Debug.Assert(contentManager.DumpAssetReferenceCount().Count == 0);
}
base.Update(gameTime);
}
/// <summary>
/// Adds an object to the world.
/// </summary>
/// <param name="obj">The obj.</param>
/// <param name="InitMaterial">if set to <c>true</c> [init material].</param>
public virtual void AddObject(IObject obj, bool InitMaterial = true)
{
if (obj == null)
{
ActiveLogger.LogMessage("Cant add null obj", LogLevel.RecoverableError);
return;
}
EntityMapper.getInstance().AddEntity(obj);
PhysicWorld.AddObject(obj.PhysicObject);
obj.PhysicObject.ObjectOwner = obj;
Objects.Add(obj);
if (InitMaterial)
{
obj.Material.Initialization(graphicsInfo, graphicFactory, obj);
}
Culler.onObjectAdded(obj);
obj.FireOnBeingAdd(this);
obj.afterAddedToTheWorld();
}
