public SpotLightCircularUpdater(IScreen screen, SpotLightPE pl, float speed, float radius, float initialAngle, bool clockwise)
: base(screen)
{
speedAcumullated = initialAngle;
this.sl = pl;
center = pl.Direction;
this.speed = speed * 0.05f;
this.radius = radius;
this.clockwise = clockwise;
this.Start(); ///Start to call the update
}
protected void DrawnSpotLight(ICamera camera, IList <ILight> lights, IDeferredGBuffer DeferredGBuffer, RenderHelper render)
{
render.PushRasterizerState(RasterizerState.CullNone);
render.PushDepthStencilState(DepthStencilState.None);
render.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
spotLightEffect.Parameters["View"].SetValue(camera.View);
spotLightEffect.Parameters["Projection"].SetValue(camera.Projection);
spotLightEffect.Parameters["cameraPosition"].SetValue(camera.Position);
ApplyFrustumCorners(directionalLightEffect.Parameters["FrustumCorners"], -Vector2.One, Vector2.One);
foreach (ILight item in lights)
{
if (item.LightType == LightType.Deferred_Spot && item.Enabled == true)
{
SpotLightPE sl = item as SpotLightPE;
Vector3 viewSpaceLPos = Vector3.Transform(sl.Position, camera.View);
Vector3 viewSpaceLDir = Vector3.Transform(sl.Direction, camera.View);
spotLightEffect.Parameters["lightPosition"].SetValue(viewSpaceLPos);
spotLightEffect.Parameters["lightDirection"].SetValue(viewSpaceLDir);
spotLightEffect.Parameters["lightRadius"].SetValue(sl.LightRadius);
spotLightEffect.Parameters["lightDecayExponent"].SetValue(sl.ConeDecay);
spotLightEffect.Parameters["Color"].SetValue(sl.Color.ToVector3());
spotLightEffect.Parameters["lightAngleCosine"].SetValue(sl.LightAngleCosine);
spotLightEffect.Parameters["lightIntensity"].SetValue(sl.LightIntensity);
render.RenderFullScreenQuadVertexPixel(spotLightEffect);
}
}
render.PopDepthStencilState();
render.PopRasterizerState();
render.SetSamplerState(s2, 2);
}
protected void DrawnSpotLight(ICamera camera, IList <ILight> lights, IDeferredGBuffer DeferredGBuffer, RenderHelper render)
{
render.PushRasterizerState(RasterizerState.CullNone);
render.PushDepthStencilState(DepthStencilState.None);
render.device.Textures[0] = DeferredGBuffer[GBufferTypes.COLOR];
render.device.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.device.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
spotLightEffect.Parameters["View"].SetValue(camera.View);
spotLightEffect.Parameters["Projection"].SetValue(camera.Projection);
spotLightEffect.Parameters["cameraPosition"].SetValue(camera.Position);
spotLightEffect.Parameters["InvertViewProjection"].SetValue(Matrix.Invert(camera.View * camera.Projection));
foreach (ILight item in lights)
{
if (item.LightType == LightType.Deferred_Spot && item.Enabled == true)
{
SpotLightPE sl = item as SpotLightPE;
spotLightEffect.Parameters["lightPosition"].SetValue(sl.Position);
spotLightEffect.Parameters["lightDirection"].SetValue(sl.Direction);
spotLightEffect.Parameters["lightRadius"].SetValue(sl.LightRadius);
spotLightEffect.Parameters["lightDecayExponent"].SetValue(sl.ConeDecay);
spotLightEffect.Parameters["Color"].SetValue(sl.Color.ToVector3());
spotLightEffect.Parameters["lightAngleCosine"].SetValue(sl.LightAngleCosine);
spotLightEffect.Parameters["lightIntensity"].SetValue(sl.LightIntensity);
render.RenderFullScreenQuadVertexPixel(spotLightEffect);
}
}
render.PopDepthStencilState();
render.PopRasterizerState();
render.SetSamplerState(s2, 2);
}
protected override void LoadContent(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.GraphicFactory factory, IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
Picking picking = new Picking(this);
this.AddScreenUpdateable(picking);
#region Models
{
SimpleModel sm = new SimpleModel(factory, "..\\Content\\Model\\cenario");
IPhysicObject pi = new TriangleMeshObject(sm, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
DeferredNormalShader shader = new DeferredNormalShader();
IMaterial mat = new DeferredMaterial(shader);
IObject obj3 = new IObject(mat, sm, pi);
obj3.Name = "cenario";
this.World.AddObject(obj3);
}
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
SimpleModel sm = new SimpleModel(factory, "..\\Content\\Model\\cubo");
sm.SetTexture(factory.CreateTexture2DColor(1, 1, Color.White), TextureType.DIFFUSE);
BoxObject pi = new BoxObject(new Vector3(i * 10, 100, j * 10), 1, 1, 1, 1, new Vector3(5), Matrix.Identity, MaterialDescription.DefaultBepuMaterial());
pi.isMotionLess = true;
DeferredNormalShader shader = new DeferredNormalShader();
IMaterial mat = new DeferredMaterial(shader);
IObject obj4 = new IObject(mat, sm, pi);
obj4.Name = "Block " + i + " : " + j;
this.World.AddObject(obj4);
}
}
#endregion
cam = new CameraFirstPerson(GraphicInfo);
cam.FarPlane = 3000;
#region NormalLight
///Conjunto de luzes direcionais
DirectionalLightPE ld1 = new DirectionalLightPE(Vector3.Left, Color.White);
DirectionalLightPE ld2 = new DirectionalLightPE(Vector3.Right, Color.White);
DirectionalLightPE ld3 = new DirectionalLightPE(Vector3.Backward, Color.White);
DirectionalLightPE ld4 = new DirectionalLightPE(Vector3.Forward, Color.White);
DirectionalLightPE ld5 = new DirectionalLightPE(Vector3.Down, Color.White);
float li = 0.2f;
ld1.LightIntensity = li;
ld2.LightIntensity = li;
ld3.LightIntensity = li;
ld4.LightIntensity = li;
ld5.LightIntensity = li;
this.World.AddLight(ld1);
this.World.AddLight(ld2);
this.World.AddLight(ld3);
this.World.AddLight(ld4);
this.World.AddLight(ld5);
#endregion
this.World.CameraManager.AddCamera(cam);
picking.OnPickedNoneButton += new OnPicked(onPick);
sp1 = new SpotLightPE(new Vector3(0, 150, 0), new Vector3(0, -1, 0), Color.PapayaWhip, 1, 200, (float)Math.Cos(Math.PI / 12), 2f);
this.World.AddLight(sp1);
}
public void DrawLights(GameTime gameTime, IWorld world, IDeferredGBuffer deferredGBuffer, RenderHelper render)
{
render.Clear(Color.Transparent, ClearOptions.Target);
foreach (ILight light in world.Lights.Where((a) => a.CastShadown == true && a.Enabled == true))
{
switch (light.LightType)
{
case LightType.Deferred_Directional:
DirectionalLightPE dl = light as DirectionalLightPE;
shadowMap = shadow.Render(gameTime, render, ginfo, dl, world.CameraManager.ActiveCamera, world, deferredGBuffer);
render.PushBlendState(_lightAddBlendState);
DrawDirectionalLight(render, ginfo, world.CameraManager.ActiveCamera, dl, deferredGBuffer);
render.PopBlendState();
break;
case LightType.Deferred_Point:
#if WINDOWS
System.Diagnostics.Debug.Fail("Point Light Shadow not supported, in production no error will be created, the light just wont cast any shadow");
#endif
render.PushBlendState(_lightAddBlendState);
DrawPointLight(render, ginfo, world.CameraManager.ActiveCamera, light as PointLightPE, deferredGBuffer, true);
render.PopBlendState();
break;
case LightType.Deferred_Spot:
SpotLightPE sl = light as SpotLightPE;
Matrix v = sl.ViewMatrix;
Matrix p = sl.ProjMatrix;
RenderShadowMap(gameTime, render, ref v, ref p, world, deferredGBuffer);
render.PushBlendState(_lightAddBlendState);
DrawnSpotLight(render, ginfo, world.CameraManager.ActiveCamera, sl, deferredGBuffer);
render.PopBlendState();
break;
default:
throw new Exception("Light type Unexpected");
}
}
render.DettachBindedTextures();
render.SetSamplerStates(ginfo.SamplerState);
render.PushBlendState(_lightAddBlendState);
foreach (ILight light in world.Lights.Where((a) => a.CastShadown != true && a.Enabled == true))
{
switch (light.LightType)
{
case LightType.Deferred_Directional:
DirectionalLightPE dl = light as DirectionalLightPE;
DrawDirectionalLight(render, ginfo, world.CameraManager.ActiveCamera, dl, deferredGBuffer);
break;
case LightType.Deferred_Point:
DrawPointLight(render, ginfo, world.CameraManager.ActiveCamera, light as PointLightPE, deferredGBuffer, true);
break;
case LightType.Deferred_Spot:
SpotLightPE sl = light as SpotLightPE;
DrawnSpotLight(render, ginfo, world.CameraManager.ActiveCamera, sl, deferredGBuffer);
break;
default:
throw new Exception("Light type Unexpected");
}
}
render.PopBlendState();
}
private void DrawnSpotLight(RenderHelper render, GraphicInfo ginfo, ICamera camera, SpotLightPE sl, IDeferredGBuffer DeferredGBuffer)
{
//if(sl.CastShadown)
// spotLightEffect.Parameters["xShadowMap"].SetValue(shadowMap);
//else
// spotLightEffect.Parameters["xShadowMap"].SetValue(blank);
if (sl.CastShadown)
{
render.device.Textures[3] = shadowMap;
}
else
{
render.device.Textures[3] = blank;
}
spotLightEffect.Parameters["shadowBufferSize"].SetValue(shadownBufferSize);
spotLightEffect.Parameters["BIAS"].SetValue(sl.SHADOWBIAS);
//spotLightEffect.Parameters["colorMap"].SetValue(DeferredGBuffer[GBufferTypes.COLOR]);
//spotLightEffect.Parameters["normalMap"].SetValue(DeferredGBuffer[GBufferTypes.NORMAL]);
//spotLightEffect.Parameters["depthMap"].SetValue(DeferredGBuffer[GBufferTypes.DEPH]);
render.device.Textures[0] = DeferredGBuffer[GBufferTypes.COLOR];
render.device.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.device.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
SamplerState s3 = render.SetSamplerState(SamplerState.PointClamp, 3);
spotLightEffect.Parameters["xLightViewProjection"].SetValue(sl.ViewMatrix * sl.ProjMatrix);
spotLightEffect.Parameters["View"].SetValue(camera.View);
spotLightEffect.Parameters["Projection"].SetValue(camera.Projection);
spotLightEffect.Parameters["cameraPosition"].SetValue(camera.Position);
spotLightEffect.Parameters["shadown"].SetValue(sl.CastShadown);
spotLightEffect.Parameters["InvertViewProjection"].SetValue(Matrix.Invert(camera.ViewProjection));
spotLightEffect.Parameters["halfPixel"].SetValue(ginfo.HalfPixel);
spotLightEffect.Parameters["lightPosition"].SetValue(sl.Position);
spotLightEffect.Parameters["lightDirection"].SetValue(sl.Direction);
spotLightEffect.Parameters["lightRadius"].SetValue(sl.LightRadius);
spotLightEffect.Parameters["lightDecayExponent"].SetValue(sl.ConeDecay);
spotLightEffect.Parameters["Color"].SetValue(sl.Color.ToVector3());
spotLightEffect.Parameters["lightAngleCosine"].SetValue(sl.LightAngleCosine);
spotLightEffect.Parameters["lightIntensity"].SetValue(sl.LightIntensity);
render.PushDepthStencilState(DepthStencilState.None);
render.RenderFullScreenQuadVertexPixel(spotLightEffect);
render.PopDepthStencilState();
render.SetSamplerState(s2, 2);
render.SetSamplerState(s3, 3);
}
protected override void LoadContent(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.GraphicFactory factory, IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
///Create a Simple Model
IModelo sm = new SimpleModel(factory, "..\\Content\\Model\\cenario");
///Create a Physic Object
IPhysicObject pi = new TriangleMeshObject(sm, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
///Create a shader
IShader shader = new DeferredNormalShader();
///Create a Material
IMaterial mat = new DeferredMaterial(shader);
///Create a an Object that englobs everything and add it to the world
IObject obj4 = new IObject(mat, sm, pi);
this.World.AddObject(obj4);
lt = new LightThrowBepu(this.World, factory);
///Create a FirstPerson Camera
///This is a special camera, used in the development
///You can move around using wasd / qz / and the mouse
ICamera cam = new CameraFirstPerson(GraphicInfo);
this.World.CameraManager.AddCamera(cam);
{
SpotLightPE sp1 = new SpotLightPE(new Vector3(0, 150, 0), new Vector3(0, -1, 0), Color.YellowGreen, 1, 600, (float)Math.Cos(Math.PI / 7), 0.5f);
SpotLightCircularUpdater spc1 = new SpotLightCircularUpdater(this, sp1, 0.01f, 1, 0, true);
this.World.AddLight(sp1);
SpotLightPE sp2 = new SpotLightPE(new Vector3(0, 150, 0), new Vector3(0, -1, 0), Color.Red, 1, 600, (float)Math.Cos(Math.PI / 7), 0.5f);
SpotLightCircularUpdater spc2 = new SpotLightCircularUpdater(this, sp2, 0.01f, 1, (float)Math.PI / 2, true);
this.World.AddLight(sp2);
SpotLightPE sp3 = new SpotLightPE(new Vector3(0, 150, 0), new Vector3(0, -1, 0), Color.Red, 1, 600, (float)Math.Cos(Math.PI / 7), 0.5f);
SpotLightCircularUpdater spc3 = new SpotLightCircularUpdater(this, sp3, 0.01f, 1, (float)Math.PI, true);
this.World.AddLight(sp3);
SpotLightPE sp4 = new SpotLightPE(new Vector3(0, 150, 0), new Vector3(0, -1, 0), Color.Green, 1, 600, (float)Math.Cos(Math.PI / 7), 0.5f);
SpotLightCircularUpdater spc4 = new SpotLightCircularUpdater(this, sp4, 0.01f, 1, (float)(Math.PI * 3) / 2, true);
this.World.AddLight(sp4);
}
{
SpotLightPE sp1 = new SpotLightPE(new Vector3(0, 150, 0), new Vector3(0, -1, 0), Color.Purple, 1, 600, (float)Math.Cos(Math.PI / 7), 0.5f);
SpotLightCircularUpdater spc1 = new SpotLightCircularUpdater(this, sp1, 0.02f, 2, 0, false);
this.World.AddLight(sp1);
SpotLightPE sp2 = new SpotLightPE(new Vector3(0, 150, 0), new Vector3(0, -1, 0), Color.PowderBlue, 1, 600, (float)Math.Cos(Math.PI / 7), 0.5f);
SpotLightCircularUpdater spc2 = new SpotLightCircularUpdater(this, sp2, 0.02f, 2, (float)Math.PI / 2, false);
this.World.AddLight(sp2);
SpotLightPE sp3 = new SpotLightPE(new Vector3(0, 150, 0), new Vector3(0, -1, 0), Color.YellowGreen, 1, 600, (float)Math.Cos(Math.PI / 7), 0.5f);
SpotLightCircularUpdater spc3 = new SpotLightCircularUpdater(this, sp3, 0.02f, 2, (float)Math.PI, false);
this.World.AddLight(sp3);
SpotLightPE sp4 = new SpotLightPE(new Vector3(0, 150, 0), new Vector3(0, -1, 0), Color.Maroon, 1, 600, (float)Math.Cos(Math.PI / 7), 0.5f);
SpotLightCircularUpdater spc4 = new SpotLightCircularUpdater(this, sp4, 0.02f, 2, (float)(Math.PI * 3) / 2, false);
this.World.AddLight(sp4);
}
{
SpotLightPE sp1 = new SpotLightPE(new Vector3(0, 150, 0), new Vector3(0, -1, 0), Color.PapayaWhip, 1, 600, (float)Math.Cos(Math.PI / 7), 0.5f);
SpotLightCircularUpdater spc1 = new SpotLightCircularUpdater(this, sp1, 0.03f, 3, (float)Math.PI / 4, true);
this.World.AddLight(sp1);
SpotLightPE sp2 = new SpotLightPE(new Vector3(0, 150, 0), new Vector3(0, -1, 0), Color.LightSeaGreen, 1, 600, (float)Math.Cos(Math.PI / 7), 0.5f);
SpotLightCircularUpdater spc2 = new SpotLightCircularUpdater(this, sp2, 0.03f, 3, (float)Math.PI / 4 + (float)Math.PI / 2, true);
this.World.AddLight(sp2);
SpotLightPE sp3 = new SpotLightPE(new Vector3(0, 150, 0), new Vector3(0, -1, 0), Color.Gold, 1, 600, (float)Math.Cos(Math.PI / 7), 0.5f);
SpotLightCircularUpdater spc3 = new SpotLightCircularUpdater(this, sp3, 0.03f, 3, (float)Math.PI / 4 + (float)Math.PI, true);
this.World.AddLight(sp3);
SpotLightPE sp4 = new SpotLightPE(new Vector3(0, 150, 0), new Vector3(0, -1, 0), Color.Aqua, 1, 600, (float)Math.Cos(Math.PI / 7), 0.5f);
SpotLightCircularUpdater spc4 = new SpotLightCircularUpdater(this, sp4, 0.03f, 3, (float)Math.PI / 4 + (float)(Math.PI * 3) / 2, true);
this.World.AddLight(sp4);
}
this.RenderTechnic.AddPostEffect(new AntiAliasingPostEffect());
}
public ModelLoaderData Load(GraphicFactory factory, GraphicInfo ginfo, String Name)
{
ModelLoaderData elements = new ModelLoaderData();
Dictionary <String, XmlModelMeshInfo> infos = new Dictionary <string, XmlModelMeshInfo>();
Dictionary <String, targetInfo> targets = new Dictionary <string, targetInfo>();
Dictionary <String, SpotLightInformation> spotLights = new Dictionary <string, SpotLightInformation>();
//Dictionary<String, ConstraintInformation> constraints = new Dictionary<string, ConstraintInformation>();
Dictionary <String, CameraInfo> cameras = new Dictionary <string, CameraInfo>();
Dictionary <String, ParticleInfo> particles = new Dictionary <string, ParticleInfo>();
SerializerHelper.ChangeDecimalSymbolToPoint();
XmlDocument xDoc = new XmlDocument();
xDoc.Load(path + Name + ".xml");
XmlNodeList worldNode = xDoc["SCENE"].ChildNodes;
foreach (XmlNode node in worldNode)
{
if (node.Name == "Constraint")
{
ConstraintInfo cinfo = new ConstraintInfo();
cinfo.Name = SerializerHelper.DeserializeAttributeBaseType <String>("name", node);
XmlElement type = node["type"];
if (type != null)
{
cinfo.type = SerializerHelper.DeserializeAttributeBaseType <String>("value", type);
}
XmlElement child = node["child"];
if (child != null)
{
cinfo.bodyA = SerializerHelper.DeserializeAttributeBaseType <String>("name", child);
}
XmlElement parent = node["parent"];
if (parent != null)
{
cinfo.bodyB = SerializerHelper.DeserializeAttributeBaseType <String>("name", parent);
}
XmlElement breakable = node["isBreakable"];
if (breakable != null)
{
cinfo.breakable = SerializerHelper.DeserializeAttributeBaseType <bool>("value", breakable);
}
Vector3 pos = SerializerHelper.DeserializeVector3("position", node);
cinfo.Position = new Vector3(pos.X, pos.Y, pos.Z);
elements.ConstraintInfo.Add(cinfo);
}
if (node.Name == "particle")
{
ParticleInfo pinfo = new ParticleInfo();
pinfo.Name = SerializerHelper.DeserializeAttributeBaseType <String>("name", node);
pinfo.Position = SerializerHelper.DeserializeVector3("position", node);
pinfo.Orientation = SerializerHelper.DeserializeQuaternion("rotation", node);
XmlElement mass = node["type"];
if (mass != null)
{
pinfo.Type = SerializerHelper.DeserializeAttributeBaseType <String>("value", mass);
}
elements.ParticleInfo.Add(pinfo);
}
if (node.Name == "body")
{
XmlModelMeshInfo info = new XmlModelMeshInfo();
info.modelName = SerializerHelper.DeserializeAttributeBaseType <String>("name", node);
XmlElement mass = node["mass"];
if (mass != null)
{
info.mass = SerializerHelper.DeserializeAttributeBaseType <float>("value", mass);
}
XmlElement dfric = node["dinamicfriction"];
if (dfric != null)
{
info.dinamicfriction = SerializerHelper.DeserializeAttributeBaseType <float>("value", dfric);
}
XmlElement sfric = node["staticfriction"];
if (sfric != null)
{
info.staticfriction = SerializerHelper.DeserializeAttributeBaseType <float>("value", sfric);
}
XmlElement ellas = node["ellasticity"];
if (ellas != null)
{
info.ellasticity = SerializerHelper.DeserializeAttributeBaseType <float>("value", ellas);
}
XmlElement collision = node["collision"];
if (collision != null)
{
info.collisionType = SerializerHelper.DeserializeAttributeBaseType <String>("type", collision);
if (info.collisionType.Contains("Water"))
{
Vector3 pos = SerializerHelper.DeserializeVector3("position", collision);
float width = SerializerHelper.DeserializeAttributeBaseType <float>("value", collision["width"]);
float length = SerializerHelper.DeserializeAttributeBaseType <float>("value", collision["length"]);
info.material.extrainformation = new Dictionary <string, object>();
info.material.extrainformation.Add("position", pos);
info.material.extrainformation.Add("width", width);
info.material.extrainformation.Add("length", length);
}
}
XmlElement material = node["material"];
if (material == null)
{
info.material.difuseName = "white";
}
else
{
XmlElement reflect = material["reflection"];
if (reflect != null)
{
info.material.reflectionName = removeExtension(SerializerHelper.DeserializeAttributeBaseType <String>("name", reflect));
}
else
{
XmlElement difuse = material["diffuse"];
if (difuse != null)
{
info.material.difuseName = removeExtension(SerializerHelper.DeserializeAttributeBaseType <String>("name", difuse));
}
XmlElement bump = material["bump"];
if (bump != null)
{
info.material.bumpName = removeExtension(SerializerHelper.DeserializeAttributeBaseType <String>("name", bump));
}
XmlElement specular = material["specular"];
if (specular != null)
{
info.material.specularName = removeExtension(SerializerHelper.DeserializeAttributeBaseType <String>("name", specular));
}
XmlElement glow = material["glow"];
if (glow != null)
{
info.material.glowName = removeExtension(SerializerHelper.DeserializeAttributeBaseType <String>("name", glow));
}
}
}
infos.Add(info.modelName, info);
}
else if (node.Name == "pointlight")
{
String name = SerializerHelper.DeserializeAttributeBaseType <String>("name", node);
Vector3 pos = SerializerHelper.DeserializeVector3("position", node);
pos = new Vector3(pos.X, -pos.Y, -pos.Z);
Vector3 vColor = SerializerHelper.DeserializeVector3("color", node);
Color color = new Color(vColor.X / 255, vColor.Y / 255, vColor.Z / 255);
float amount = SerializerHelper.DeserializeAttributeBaseType <float>("amount", node["multiplier"]);
float decay = SerializerHelper.DeserializeAttributeBaseType <float>("value", node["decay"]);
PointLightPE pl = new PointLightPE(pos, color, 200, amount);
pl.Name = name;
pl.UsePointLightQuadraticAttenuation = true;
elements.LightsInfo.Add(pl);
}
else if (node.Name == "spotlight")
{
String name = SerializerHelper.DeserializeAttributeBaseType <String>("name", node);
Vector3 pos = SerializerHelper.DeserializeVector3("position", node);
pos = new Vector3(pos.X, -pos.Y, -pos.Z);
Vector3 vColor = SerializerHelper.DeserializeVector3("color", node);
float fallof = SerializerHelper.DeserializeBaseType <float>("fallof", node);
Color color = new Color(vColor.X / 255, vColor.Y / 255, vColor.Z / 255);
float amount = SerializerHelper.DeserializeAttributeBaseType <float>("amount", node["multiplier"]);
float decay = SerializerHelper.DeserializeAttributeBaseType <float>("value", node["decay"]);
bool castShadow = SerializerHelper.DeserializeBaseType <bool>("castShadows", node);
SpotLightInformation spi = new SpotLightInformation();
spi.angle = MathHelper.ToRadians(fallof);
spi.color = color;
spi.decay = decay;
spi.multiplier = amount;
spi.name = name;
spi.pos = pos;
spi.castShadow = castShadow;
spotLights.Add(spi.name, spi);
}
else if (node.Name == "target")
{
String name = SerializerHelper.DeserializeAttributeBaseType <String>("name", node);
Vector3 pos = SerializerHelper.DeserializeVector3("position", node);
pos = new Vector3(pos.X, -pos.Y, -pos.Z);
targetInfo ti = new targetInfo();
ti.targetPos = pos;
ti.name = name;
targets.Add(ti.name, ti);
}
else if (node.Name == "camera")
{
String name = SerializerHelper.DeserializeAttributeBaseType <String>("name", node);
Vector3 pos = SerializerHelper.DeserializeVector3("position", node);
pos = new Vector3(pos.X, -pos.Y, -pos.Z);
CameraInfo co = new CameraInfo();
co.Name = name;
co.Position = pos;
cameras.Add(co.Name, co);
}
else if (node.Name == "dummy")
{
String name = SerializerHelper.DeserializeAttributeBaseType <String>("name", node);
Vector3 pos = SerializerHelper.DeserializeVector3("position", node);
pos = new Vector3(pos.X, -pos.Y, -pos.Z);
DummyInfo di = new DummyInfo();
di.Name = name;
di.Position = pos;
elements.DummyInfo.Add(di);
}
}
///////PROCCESS LIGHTS /////////////////////
foreach (var item in spotLights)
{
SpotLightInformation si = item.Value;
targetInfo ti = targets[item.Key + ".Target"];
SpotLightPE sl = new SpotLightPE(si.pos, Vector3.Normalize(ti.targetPos - si.pos), si.color, si.decay, (ti.targetPos - si.pos).Length() * 10f, (float)Math.Cos(si.angle / 2), si.multiplier);
sl.CastShadown = si.castShadow;
sl.Name = si.name;
elements.LightsInfo.Add(sl);
}
///////PROCCESS CAMERAS/////////////////////
foreach (var item in cameras)
{
CameraInfo ci = item.Value;
targetInfo ti = targets[item.Key + ".Target"];
ci.Target = ti.targetPos;
elements.CameraInfo.Add(ci);
}
Model model = factory.GetModel(modelPath + Name);
modelNames.Add(modelPath + Name);
Matrix[] m = new Matrix[model.Bones.Count];
model.CopyAbsoluteBoneTransformsTo(m);
////////////EXTRAINDO MESHES
for (int i = 0; i < model.Meshes.Count; i++)
{
String name = model.Meshes[i].Name.Substring(5);
if (infos.ContainsKey(name))
{
for (int j = 0; j < model.Meshes[i].MeshParts.Count; j++)
{
XmlModelMeshInfo inf = infos[name];
Matrix tr = m[model.Meshes[i].ParentBone.Index];
Vector3 scale;
Vector3 pos;
Quaternion ori;
tr.Decompose(out scale, out ori, out pos);
ObjectInformation mi = new ObjectInformation();
mi.modelName = inf.modelName;
mi.meshPartIndex = j;
mi.meshIndex = i;
mi.position = pos;
mi.scale = scale;
mi.rotation = ori;
ModelBuilderHelper.Extract(m, model.Meshes[i].MeshParts[j], out mi.batchInformation);
mi.ellasticity = inf.ellasticity;
mi.dinamicfriction = inf.dinamicfriction;
mi.staticfriction = inf.staticfriction;
mi.collisionType = inf.collisionType;
mi.mass = inf.mass;
mi.batchInformation.ModelLocalTransformation = m[model.Meshes[i].ParentBone.Index];
mi.textureInformation = new TextureInformation(false, factory);
if (inf.material.reflectionName != null)
{
mi.textureInformation.SetCubeTexture(factory.GetTextureCube(texturePath + inf.material.reflectionName), TextureType.ENVIRONMENT);
texturesNames.Add(texturePath + inf.material.reflectionName);
}
else
{
if (inf.material.difuseName != null)
{
mi.textureInformation.SetTexture(factory.GetTexture2D(texturePath + inf.material.difuseName), TextureType.DIFFUSE);
texturesNames.Add(texturePath + inf.material.difuseName);
}
if (inf.material.glowName != null)
{
mi.textureInformation.SetTexture(factory.GetTexture2D(texturePath + inf.material.glowName), TextureType.GLOW);
texturesNames.Add(texturePath + inf.material.glowName);
}
if (inf.material.specularName != null)
{
mi.textureInformation.SetTexture(factory.GetTexture2D(texturePath + inf.material.specularName), TextureType.SPECULAR);
texturesNames.Add(texturePath + inf.material.specularName);
}
if (inf.material.bumpName != null)
{
mi.textureInformation.SetTexture(factory.GetTexture2D(texturePath + inf.material.bumpName), TextureType.BUMP);
texturesNames.Add(texturePath + inf.material.bumpName);
}
}
if (inf.collisionType != null)
{
if (inf.collisionType.Contains("Water"))
{
mi.extra = inf.material.extrainformation;
}
}
mi.textureInformation.LoadTexture();
elements.ModelMeshesInfo.Add(mi);
}
}
}
SerializerHelper.ChangeDecimalSymbolToSystemDefault();
//Clear Stuffs
infos.Clear();
targets.Clear();
spotLights.Clear();
cameras.Clear();
return(elements);
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory, IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
ExtractXmlModelLoader ext = new ExtractXmlModelLoader("Content//ModelInfos//", "Model//", "Textures//");
this.AttachCleanUpAble(ext);
ModelLoaderData data = ext.Load(factory, GraphicInfo, "tree");//shadow
WorldLoader wl = new WorldLoader();
wl.OnCreateIObject += new CreateIObject(wl_OnCreateIObject);
wl.OnCreateILight += new CreateILight(wl_OnCreateILight);
wl.LoadWorld(factory, GraphicInfo, World, data);
///Create the water
///Water is just a Shader that Creats a Water like texture and binds it to a model
{
IModelo sm = new SimpleModel(factory, "Model\\block");
Matrix trans = Matrix.CreateTranslation(new Vector3(0, 50, 0));
Plane plano = Plane.Transform(new Plane(0, 1, 0, 0), trans);
///The water is VERRRRY big, the reflection and refraction will looks like blocked, its normal, increasy the size of the reflection/refrection buffer to correct this (bigger cost)
///We normally use the SAME transformation applyied to the plane (if not stranges affects can happen)
IPhysicObject pi = new BoxObject(new Vector3(0, 50, 0), 1, 1, 1, 5, new Vector3(3000, 0.1f, 3000), trans, MaterialDescription.DefaultBepuMaterial());
pi.isMotionLess = true;
///Water shader, will refract and reflect according to the plano passed in the parameter
///Using default Parameters, there are lots of things that can be changed. See WaterCompleteShader
DeferredWaterCompleteShader shader = new DeferredWaterCompleteShader(800, 600, plano, 0.1f);
shader.SpecularIntensity = 0.01f;
shader.SpecularPower = 50;
IMaterial mat = new DeferredMaterial(shader);
IObject obj4 = new IObject(mat, sm, pi);
this.World.AddObject(obj4);
}
IObject spobj = this.World.Objects[0];
LightThrowBepu lt = new LightThrowBepu(this.World, factory);
#region NormalLight
DirectionalLightPE ld1 = new DirectionalLightPE(Vector3.Left, Color.White);
DirectionalLightPE ld2 = new DirectionalLightPE(Vector3.Right, Color.White);
DirectionalLightPE ld3 = new DirectionalLightPE(Vector3.Backward, Color.White);
DirectionalLightPE ld4 = new DirectionalLightPE(Vector3.Forward, Color.White);
DirectionalLightPE ld5 = new DirectionalLightPE(Vector3.Down, Color.White);
float li = 0.5f;
ld1.LightIntensity = li;
ld2.LightIntensity = li;
ld3.LightIntensity = li;
ld4.LightIntensity = li;
ld5.LightIntensity = li;
this.World.AddLight(ld1);
this.World.AddLight(ld2);
this.World.AddLight(ld3);
this.World.AddLight(ld4);
this.World.AddLight(ld5);
//ld1 = new DirectionalLightPE(new Vector3(0.2f, -1, 0.2f), Color.White);
//ld1.CastShadown = true;
//float li = 0.9f;
//ld1.LightIntensity = li;
//this.World.AddLight(ld1);
SpotLightPE sl = new SpotLightPE(new Vector3(-56, 700, 30), new Vector3(0.1f, -0.8f, 0.3f), Color.White, 1f, 100000, (float)Math.Cos(Math.PI / 3), 1f);
sl.CastShadown = true;
this.World.AddLight(sl);
#endregion
CameraFirstPerson cam = new CameraFirstPerson(GraphicInfo);
cam.MoveSpeed *= 5;
this.World.CameraManager.AddCamera(cam);
SkyBoxSetTextureCube stc = new SkyBoxSetTextureCube("Textures//grasscube");
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(stc);
/////Interpolator to change lightDirection
//inter.Start(new Vector3(0, -1, 0), new Vector3(1, -1, 1), 3, true);
//this.RenderTechnic.AddPostEffect(new AntiAliasingPostEffect());
}
