/// <summary>
/// Set active camera
/// </summary>
/// <param name="name">The name.</param>
/// <param name="type">The type.</param>
/// <param name="timeOrStep">The time or step.</param>
public void SetActiveCamera(String name, InterpolationType type, float timeOrStep)
{
if (activeCameraType == State.NORMAL)
{
activeCameraType = State.INTERPOLATING;
int ind = _cameras.FindIndex(delegate(CameraDescription t) { return(t.name == name); });
if (ind == -1)
{
ActiveLogger.LogMessage("Camera Name Not found, maybe you did not added it to the camera manager", LogLevel.RecoverableError);
return;
}
CameraInterpolator ci = new CameraInterpolator(_activeCam, _cameras[ind].cam, type, timeOrStep);
ci.OnInterpolationFinished += new CameraInterpolator.InterpolationFinished(ci_OnInterpolationFinished);
ci.Name = INTERPOLATORCAMERA;
CameraDescription cc = new CameraDescription();
cc.cam = ci;
cc.name = INTERPOLATORCAMERA;
_cameras.Add(cc);
int added = _cameras.FindIndex(delegate(CameraDescription t) { return(t.name == INTERPOLATORCAMERA); });
_activeCam = _cameras[added].cam;
}
else
{
CameraInterpolator ac = (_activeCam as CameraInterpolator);
int ind = _cameras.FindIndex(delegate(CameraDescription t) { return(t.name == name); });
if (ind == -1)
{
ActiveLogger.LogMessage("Camera Name Not found, maybe you did not added it to the camera manager", LogLevel.RecoverableError);
}
ac.Reset(_activeCam, _cameras[ind].cam);
}
}
public void StartAcelerometer()
{
if (useAcelerometer)
{
if (accelActive == true)
{
return;
}
try
{
accelSensor.Start();
accelActive = true;
}
catch (Microsoft.Devices.Sensors.AccelerometerFailedException e)
{
// the accelerometer couldn't be started. No fun!
accelActive = false;
}
catch (UnauthorizedAccessException e)
{
// This exception is thrown in the emulator-which doesn't support an accelerometer.
accelActive = false;
}
}
else
{
ActiveLogger.LogMessage("need to enable acelerometer before trying to start it on the camerafirstperson", LogLevel.RecoverableError);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="IWorld"/> class.
/// </summary>
/// <param name="PhysicWorld">The physic world.</param>
/// <param name="particleManager">The particle manager.</param>
/// <param name="culler">The culler.</param>
public I2DWorld(I2DPhysicWorld PhysicWorld, IParticleManager particleManager = null, I2DCuller culler = null)
{
if (PhysicWorld == null)
{
ActiveLogger.LogMessage("Physic World cannot be null", LogLevel.FatalError);
Debug.Assert(PhysicWorld != null);
throw new Exception("Physic World cannot be null");
}
if (culler == null)
{
this.culler = new Simple2DCuller();
}
else
{
this.culler = culler;
}
this.culler.world = this;
this.particleManager = particleManager;
this.PhysicWorld = PhysicWorld;
Dummies = new List <IDummy>();
Objects = new List <I2DObject>();
SoundEmiters2D = new List <ISoundEmitter2D>();
CleanUpObjectsOnDispose = true;
#if !WINDOWS_PHONE && !REACH
Lights2D = new List <PloobsEngine.Light2D.Light2D>();
#endif
}
/// <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="specularIntensity">The specular intensity.</param>
/// <param name="specularPower">The specular power.</param>
public DeferredShatterCustomShader(bool useGlow, bool useBump, bool useSpecular, bool useParalax, float specularIntensity = 0, float specularPower = 0)
{
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;
}
this.specularIntensity = specularIntensity;
this.specularPower = specularPower;
this.useGlow = useGlow;
this.useSpecular = useSpecular;
this.useBump = useBump;
this.useParalax = useParalax;
specularPowerMapScale = 1;
specularIntensityMapScale = 1;
if (useParalax == true && useBump == false)
{
ActiveLogger.LogMessage("Are you sure you will use only Paralax without BUMP, the paralax expects bump", LogLevel.Warning);
}
}
public PreRenderTechnic(PrePassRenderTechnicInitDescription desc)
: base(PostEffectType.Deferred)
{
this.desc = desc;
deferredGBuffer = new PreGBuffer();
deferredLightMap = new PreLightMap();
if (desc.LightDebug)
{
ActiveLogger.LogMessage("LighDebug is not implemented yet, will be disabled", LogLevel.Warning);
}
if (desc.DefferedDebug)
{
if (desc.RenderTargetsNameToDefferedDebug != null)
{
if (desc.RenderTargetsNameToDefferedDebug.Count() != 4)
{
ActiveLogger.LogMessage("RenderTargetsNameToDefferedDebug must be 4, Deferred Degug Disabled", LogLevel.RecoverableError);
desc.DefferedDebug = false;
}
}
else
{
ActiveLogger.LogMessage("RenderTargetsNameToDefferedDebug must be 4, Deferred Degub Disabled", LogLevel.RecoverableError);
desc.DefferedDebug = false;
}
}
}
public IWorld(IPhysicWorld PhysicWorld, ICuller Culler, IParticleManager particleManager = null)
#endif
{
if (PhysicWorld == null)
{
ActiveLogger.LogMessage("Physic World cannot be null", LogLevel.FatalError);
Debug.Assert(PhysicWorld != null);
throw new Exception("Physic World cannot be null");
}
if (Culler == null)
{
ActiveLogger.LogMessage("Culler cannot be null", LogLevel.FatalError);
Debug.Assert(Culler != null);
throw new Exception("Culler cannot be null");
}
this.particleManager = particleManager;
this.PhysicWorld = PhysicWorld;
this.CameraManager = new CameraManager();
Dummies = new List <IDummy>();
Lights = new List <ILight>();
Objects = new List <IObject>();
Triggers = new List <ITrigger>();
SoundEmiters3D = new List <ISoundEmitter3D>();
this.Culler = Culler;
this.culler.world = this;
CleanUpObjectsOnDispose = true;
#if WINDOWS
this.multThreading = multiThread;
#endif
}
/// <summary>
/// Checks if render target properties combination is supported.
/// </summary>
/// <param name="format">The format.</param>
/// <param name="depthFormat">The depth format.</param>
/// <param name="useMipMap">if set to <c>true</c> [use mip map].</param>
/// <param name="multisample">The multisample.</param>
/// <param name="GraphicsProfile">The graphics profile.</param>
/// <returns></returns>
public bool CheckIfRenderTargetFormatIsSupported(SurfaceFormat format, DepthFormat depthFormat, bool useMipMap, int multisample, GraphicsProfile GraphicsProfile = GraphicsProfile.HiDef)
{
SurfaceFormat outformat;
DepthFormat outdepthFormat;
int outmultisample;
if (GraphicsAdapter.QueryRenderTargetFormat(GraphicsProfile, format, depthFormat, multisample, out outformat, out outdepthFormat, out outmultisample) == false)
{
if (outformat != format)
{
ActiveLogger.LogMessage("The Combination is not supported, problem in the format", LogLevel.Warning);
}
if (outdepthFormat != depthFormat)
{
ActiveLogger.LogMessage("The Combination is not supported, problem in the dephformat", LogLevel.Warning);
}
if (outmultisample != multisample)
{
ActiveLogger.LogMessage("The Combination is not supported, problem in the multisample", LogLevel.Warning);
}
return(false);
}
else //true !!!
{
return(true);
}
}
/// <summary>
/// Init Screen
/// </summary>
/// <param name="GraphicInfo">The graphic info.</param>
/// <param name="engine"></param>
protected override void InitScreen(GraphicInfo GraphicInfo, EngineStuff engine)
{
SetWorldAndRenderTechnich(out _renderTecnic, out _world);
if (_renderTecnic == null)
{
ActiveLogger.LogMessage("IScene must have a renderTechnic", LogLevel.FatalError);
#if WINDOWS
Debug.Fail("IScene must have a renderTechnic");
#endif
throw new Exception("IScene must have a renderTechnic");
}
if (_world == null)
{
ActiveLogger.LogMessage("World cannot be null", LogLevel.FatalError);
#if WINDOWS
Debug.Fail("World cannot be null");
#endif
throw new Exception("World cannot be null");
}
this._world.GraphicsFactory = GraphicFactory;
this._world.GraphicsInfo = GraphicInfo;
this._world.ContentManager = screenManager.contentManager;
this._world.iInitWorld();
base.InitScreen(GraphicInfo, engine);
}
/// <summary>
/// Add a camera and set it active if not yet was setted
/// </summary>
/// <param name="cam"></param>
public void AddCamera(ICamera cam)
{
if (cam == null)
{
ActiveLogger.LogMessage("Can add null camera, Skipping adding this Camera", LogLevel.RecoverableError);
return;
}
if (String.IsNullOrEmpty(cam.Name))
{
AddCamera(cam, DEFAULTCAMERA);
if (_activeCam == null)
{
SetActiveCamera(DEFAULTCAMERA);
}
}
else
{
AddCamera(cam, cam.Name);
if (_activeCam == null)
{
SetActiveCamera(cam.Name);
}
}
}
/// <summary>
/// Sets the volume.
/// </summary>
/// <param name="vol">The vol.</param>
public void setVolume(float vol)
{
if (started)
{
videoPlayer.Volume = vol;
}
ActiveLogger.LogMessage("Cant set volume if the movie did not started", LogLevel.RecoverableError);
}
/// <summary>
/// Adds the light.
/// </summary>
/// <param name="light">The light.</param>
public virtual void AddLight(ILight light)
{
if (light == null)
{
ActiveLogger.LogMessage("Cant Add null Light", LogLevel.RecoverableError);
return;
}
Lights.Add(light);
}
public override void AddSoundEmitter(Audio.ISoundEmitter3D em, bool play = false)
{
if (em == null)
{
ActiveLogger.LogMessage("Emitter is Null " + em.ToString(), LogLevel.RecoverableError);
return;
}
SoundEmiters3D.Add(em);
}
/// <summary>
/// Retorna o nome da camera ativa
/// </summary>
/// <returns></returns>
public String GetActiveCameraName()
{
if (_activeCameraIndex == -1)
{
ActiveLogger.LogMessage("No camera has been added yet, can access any, returning null", LogLevel.RecoverableError);
return(null);
}
return(_cameras[_activeCameraIndex].name);
}
/// <summary>
/// Contains the specified obj.
/// </summary>
/// <param name="obj">The obj.</param>
/// <returns></returns>
public virtual bool ContainsObject(IObject obj)
{
if (obj == null)
{
ActiveLogger.LogMessage("Cant compare with null obj", LogLevel.RecoverableError);
return(false);
}
return(Objects.Contains(obj));
}
/// <summary>
/// Gets the state.
/// </summary>
/// <returns></returns>
public MediaState getState()
{
if (started)
{
return(videoPlayer.State);
}
ActiveLogger.LogMessage("Cant get state if the movie did not started", LogLevel.RecoverableError);
return(MediaState.Stopped);
}
/// <summary>
/// Initializes a new instance of the <see cref="DPFSParticleSystem"/> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="IDPSFParticleSystem">The IDPSF particle system.</param>
public DPFSParticleSystem(String name, IDPSFParticleSystem IDPSFParticleSystem)
: base(name)
{
if (IDPSFParticleSystem == null)
{
ActiveLogger.LogMessage("IDPSFParticleSystem cannot be null", LogLevel.FatalError);
throw new Exception("IDPSFParticleSystem cannot be null");
}
this.IDPSFParticleSystem = IDPSFParticleSystem;
}
public SkyBoxSetTextureCube(String textureCubeName, bool enable = true)
{
if (String.IsNullOrEmpty(textureCubeName))
{
ActiveLogger.LogMessage("You must provide the a name for the TextureCube of the Skybox", LogLevel.FatalError);
throw new Exception("You must provide the a name for the TextureCube of the Skybox");
}
this.texName = textureCubeName;
this.enable = enable;
}
/// <summary>
/// TODO
/// Populates a <see cref="T:System.Runtime.Serialization.SerializationInfo"/> with the data needed to serialize the target object.
/// </summary>
/// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> to populate with data.</param>
/// <param name="context">The destination (see <see cref="T:System.Runtime.Serialization.StreamingContext"/>) for this serialization.</param>
/// <exception cref="T:System.Security.SecurityException">The caller does not have the required permission. </exception>
public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
{
ActiveLogger.LogMessage("Serialization not implemented", LogLevel.RecoverableError);
//info.AddValue("Objects", Objects, Objects.GetType());
//info.AddValue("Lights", Lights, Lights.GetType());
//info.AddValue("Triggers", Triggers, Triggers.GetType());
//info.AddValue("SoundEmitter3D", SoundEmiters3D, SoundEmiters3D.GetType());
//info.AddValue("Culler", Culler, Culler.GetType());
//info.AddValue("PhysicWorld", PhysicWorld, PhysicWorld.GetType());
}
/// <summary>
/// Removes one post effect.
/// </summary>
/// <param name="postEffect">The post effect.</param>
public virtual void RemovePostEffect(IPostEffect postEffect)
{
System.Diagnostics.Debug.Assert(postEffect != null);
if ((postEffect.PostEffectType & PostEffectType) != PostEffectType)
{
ActiveLogger.LogMessage("Trying to remove a wrong post effect type for this Render Technich, pls check if the PostEffectType of the IPostEffect is All or " + PostEffectType + ", The engine is ignoring this operation", LogLevel.RecoverableError);
}
PostEffects.RemoveLocation(postEffect);
postEffect.tech = null;
}
public override void Init(PloobsEngine.Engine.GraphicInfo ginfo, PloobsEngine.Engine.GraphicFactory factory)
{
switch (BlurRadiusSize)
{
case BlurRadiusSize.Fifteen:
effect = factory.GetEffect("sblur", true, true);
break;
case BlurRadiusSize.Seven:
effect = factory.GetEffect("sblur2", true, true);
break;
case BlurRadiusSize.Three:
effect = factory.GetEffect("sblur3", true, true);
break;
default:
ActiveLogger.LogMessage("Wrong Blur Radius Size Specified", LogLevel.RecoverableError);
effect = factory.GetEffect("sblur", true, true);
break;
}
if (!destinySize.HasValue)
{
destinySize = new Vector2(ginfo.BackBufferWidth, ginfo.BackBufferHeight);
}
if (SurfaceFormat.HasValue)
{
if (SurfaceFormat.Value == Microsoft.Xna.Framework.Graphics.SurfaceFormat.Single ||
SurfaceFormat.Value == Microsoft.Xna.Framework.Graphics.SurfaceFormat.HalfSingle)
{
effect.CurrentTechnique = effect.Techniques["GAUSSSingle"];
}
else
{
effect.CurrentTechnique = effect.Techniques["GAUSSTriple"];
}
RenderTarget2D = factory.CreateRenderTarget((int)destinySize.Value.X, (int)destinySize.Value.Y, SurfaceFormat.Value);
}
else
{
RenderTarget2D = factory.CreateRenderTarget(ginfo.BackBufferWidth, ginfo.BackBufferHeight);
}
ComputeKernel(BLUR_RADIUS, BLUR_AMOUNT);
if (OriginSize.HasValue)
{
ComputeOffsets(OriginSize.Value.X, OriginSize.Value.Y);
}
else
{
ComputeOffsets(ginfo.BackBufferWidth, ginfo.BackBufferHeight);
}
}
public void SetIndices(int[] indices)
{
if (isDynamic)
{
BatchInformations[0][0].IndexBuffer.SetData <int>(indices);
}
else
{
ActiveLogger.LogMessage("Cant set indices/vertices on Non Dynamic Modelo", LogLevel.RecoverableError);
}
}
public void AddVertex(T vertex)
{
if (added)
{
ActiveLogger.LogMessage("cant change the model after build it", LogLevel.RecoverableError);
}
else
{
vertices.Add(vertex);
}
}
public override void ReportError(ErrorCode errorCode, string message, string file, int lineNumber)
{
if (errorCode == ErrorCode.Assertion || errorCode == ErrorCode.InternalError || errorCode == ErrorCode.OutOfMemory)
{
ActiveLogger.LogMessage("PhysX: " + message, LogLevel.FatalError);
}
else
{
ActiveLogger.LogMessage("PhysX: " + message, LogLevel.RecoverableError);
}
}
/// <summary>
/// Return a list of RecieveEntities that has the parameter tag
/// </summary>
/// <param name="tag">tag</param>
/// <returns></returns>
public IList <IRecieveMessageEntity> GetTagRecieveEntity(string tag)
{
System.Diagnostics.Debug.Assert(tag != null);
if (tagRecieveEntity.ContainsKey(tag))
{
return(tagRecieveEntity[tag]);
}
ActiveLogger.LogMessage("Tag does not exists: " + tag, LogLevel.FatalError);
throw new Exception("Tag does not exists: " + tag);
}
/// <summary>
/// Initializes a new instance of the <see cref="IParticleSystem"/> class.
/// </summary>
/// <param name="name">The name.</param>
public IParticleSystem(String name, BoundingBox?BoundingBox = null)
{
this.BoundingBox = BoundingBox;
if (String.IsNullOrEmpty(name))
{
ActiveLogger.LogMessage("ParticleSystem name cannot be null/empty", LogLevel.FatalError);
throw new Exception("ParticleSystem name cannot be null/empty");
}
this.Name = name;
}
/// <summary>
/// Gets the particle system.
/// </summary>
/// <param name="particleSystemName">Name of the particle system.</param>
/// <returns></returns>
public override IParticleSystem GetParticleSystem(string particleSystemName)
{
if (ParticleSystem.ContainsKey(particleSystemName))
{
return(ParticleSystem[particleSystemName]);
}
else
{
ActiveLogger.LogMessage("ParticleMessage: " + particleSystemName + " Not Found, returning NULL", LogLevel.Warning);
return(null);
}
}
/// <summary>
/// Stops the sound
/// </summary>
public virtual void Stop(bool imediately = true)
{
#if DEBUG
if (!isAdded)
{
ActiveLogger.LogMessage("Cant Play/Stop/Pause/Resume a 3D Sound before adding it to the world, Action ignored", LogLevel.RecoverableError);
return;
}
#endif
soundEngineInstance.Stop(imediately);
}
/// <summary>
/// Gets the camera by name.
/// </summary>
/// <param name="name">The name.</param>
/// <returns></returns>
public ICamera GetCamera(String name)
{
int camIndex = _cameras.FindIndex(delegate(CameraDescription t) { return(t.name == name); });
if (camIndex == -1)
{
ActiveLogger.LogMessage("Camera not found in Camera Manager, are you sure you added it ?!", LogLevel.RecoverableError);
return(null);
}
return(_cameras[camIndex].cam);
}
/// <summary>
/// Add A Sound Effect to the Repo
/// Sounds are shared here
/// </summary>
/// <param name="musicNamePath">filepath</param>
/// <param name="musicName">Name used to refer to this effect latter</param>
/// <param name="volume">between 0 - 1</param>
/// <param name="pitch">between -1 to 1 (octaves)</param>
/// <param name="pan">between -1 to 1 (left - right)</param>
/// <param name="isLooped">if set to <c>true</c> [is looped].</param>
public void AddSoundToRepository(string musicNamePath, String musicName, float volume = 1, float pitch = 0, float pan = 0, bool isLooped = false)
{
System.Diagnostics.Debug.Assert(!String.IsNullOrEmpty(musicNamePath));
System.Diagnostics.Debug.Assert(!String.IsNullOrEmpty(musicName));
SimpleSoundEffect sse = new SimpleSoundEffect(manager, musicNamePath, volume, pitch, pan, isLooped);
if (musics.ContainsKey(musicName))
{
ActiveLogger.LogMessage("Already contains this song " + musicName + " , Overwriting", LogLevel.Warning);
}
musics[musicName] = sse;
}
public void EvaluateTestes(String path, String logPath = null, String pathToScreenShot = null)
{
if (Path.IsPathRooted(path) == false)
{
path = Path.Combine(Environment.CurrentDirectory, path);
}
Assembly u = Assembly.LoadFile(path);
IList <Type> Screens = new List <Type>();
IList <Type> AlgClass = new List <Type>();
foreach (var item in u.GetTypes())
{
foreach (var att in item.GetCustomAttributes(false))
{
if (att is TesteVisualScreen)
{
Screens.Add(item);
}
if (att is TesteAlgorithmClass)
{
AlgClass.Add(item);
}
}
}
List <IScreen> screens = new List <IScreen>();
foreach (var item in Screens)
{
screens.Add((IScreen)Activator.CreateInstance(item));
}
InitialEngineDescription InitialEngineDescription = InitialEngineDescription.Default();
InitialEngineDescription.Logger = new logger(logPath);
InitialEngineDescription.UnhandledException_Handler =
(a, b) =>
{
ActiveLogger.LogMessage("Fatal Error: " + b.ExceptionObject, LogLevel.FatalError);
Environment.Exit(-1);
};
EngineStuff EngineStuff = new EngineStuff(ref InitialEngineDescription,
(a) =>
{
a.AddScreen(new AlgoMainTest(AlgClass, screens, pathToScreenShot));
}
);
EngineStuff.Run();
Environment.Exit(0);
}
