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
}
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);
}
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(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());
}
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);
}