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, "shadow");
WorldLoader wl = new WorldLoader();
wl.OnCreateIObject += new CreateIObject(wl_OnCreateIObject);
wl.OnCreateILight += new CreateILight(wl_OnCreateILight);
wl.LoadWorld(factory, GraphicInfo, World, data);
lt = new LightThrowBepu(this.World, factory);
#region NormalLight
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);
#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());
}
protected void DrawDirectionalLight(ICamera camera, IList <ILight> lights, IDeferredGBuffer DeferredGBuffer, RenderHelper render)
{
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);
DirectionalcameraPosition.SetValue(camera.Position);
DirectionalInvertViewProjection.SetValue(Matrix.Invert(camera.ViewProjection));
DirectionalhalfPixel.SetValue(ginfo.HalfPixel);
foreach (ILight item in lights)
{
if (item.LightType == LightType.Deferred_Directional && item.Enabled == true)
{
PloobsEngine.Light.DirectionalLightPE dl = item as PloobsEngine.Light.DirectionalLightPE;
DirectionallightDirection.SetValue(dl.LightDirection);
DirectionalColor.SetValue(dl.Color.ToVector3());
DirectionallightIntensity.SetValue(dl.LightIntensity);
render.RenderFullScreenQuadVertexPixel(directionalLightEffect);
}
}
render.SetSamplerState(s2, 2);
}
protected void DrawDirectionalLight(ICamera camera, IList <ILight> lights, IDeferredGBuffer DeferredGBuffer, RenderHelper render)
{
ComputeFrustumCorners(camera);
ApplyFrustumCorners(directionalLightEffect.Parameters["FrustumCorners"], -Vector2.One, Vector2.One);
render.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
DirectionalhalfPixel.SetValue(ginfo.HalfPixel);
foreach (ILight item in lights)
{
if (item.LightType == LightType.Deferred_Directional && item.Enabled == true)
{
PloobsEngine.Light.DirectionalLightPE dl = item as PloobsEngine.Light.DirectionalLightPE;
Vector3 vldir = Vector3.Transform(dl.LightDirection, camera.View);
DirectionallightDirection.SetValue(vldir);
DirectionalColor.SetValue(dl.Color.ToVector3());
DirectionallightIntensity.SetValue(dl.LightIntensity);
render.RenderFullScreenQuadVertexPixel(directionalLightEffect);
}
}
render.SetSamplerState(s2, 2);
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory, IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
CameraFirstPerson CameraFirstPerson = new CameraFirstPerson(true, GraphicInfo);
Texture2D tMap = factory.GetTexture2D("Textures//hmap_10243");
QuadTerrain q = new PloobsEngine.Material.QuadTerrain(factory, tMap, 33, 513, 10, 3f);
DeferredTerrainMaterial mat = new DeferredTerrainMaterial(q);
//Set various terrain stats.
mat.diffuseScale = q.flatScale / 4;
mat.detailScale = q.flatScale / 100;
mat.detailMapStrength = 2;
mat.textureBlend = factory.GetTexture2D("Textures//hmap_256blend");
mat.textureDetail = factory.GetTexture2D("Textures//coolgrass2DOT3");
mat.textureRed = factory.GetTexture2D("Textures//TexR");
mat.textureGreen = factory.GetTexture2D("Textures//TexG");
mat.textureBlue = factory.GetTexture2D("Textures//TexB");
mat.textureBlack = factory.GetTexture2D("Textures//TexBase");
TerrainObject to = new TerrainObject(factory,Vector3.Zero, Matrix.Identity, q.getHeightMap() ,MaterialDescription.DefaultBepuMaterial());
IObject obj3 = new IObject(mat, null, to);
this.World.AddObject(obj3);
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);
#endregion
this.World.CameraManager.AddCamera(CameraFirstPerson);
CameraFirstPerson.FarPlane = 20000;
SkyBoxSetTextureCube stc = new SkyBoxSetTextureCube("Textures//cubemap");
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(stc);
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory ,IContentManager contentManager)
{
base.LoadContent(GraphicInfo,factory, contentManager);
{
SimpleModel simpleModel = new SimpleModel(factory, "Model//cenario");
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
DeferredNormalShader shader = new DeferredNormalShader();
DeferredMaterial fmaterial = new DeferredMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
{
SimpleModel sm = new SimpleModel(factory, "..\\Content\\Model\\block");
sm.SetTexture(factory.CreateTexture2DColor(1, 1, Color.White), TextureType.DIFFUSE);
BoxObject pi = new BoxObject(new Vector3(100, 40, 0), 1, 1, 1, 25, new Vector3(100, 10, 100), Matrix.Identity, MaterialDescription.DefaultBepuMaterial());
DeferredNormalShader shader = new DeferredNormalShader();
IMaterial mat = new DeferredMaterial(shader);
IObject obj3 = new IObject(mat, sm, pi);
this.World.AddObject(obj3);
}
#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);
#endregion
//SBlurPost hsv = new SBlurPost(1, SurfaceFormat.HdrBlendable);
//hsv.ImageSamplerState = SamplerState.PointClamp;
//this.RenderTechnic.AddPostEffect(hsv);
DownSamplePostEffect DownSamplePostEffect = new Post.DownSamplePostEffect();
this.RenderTechnic.AddPostEffect(DownSamplePostEffect);
CameraFirstPerson cam = new CameraFirstPerson(GraphicInfo);
cam.MoveSpeed *= 5;
this.World.CameraManager.AddCamera(cam);
LightThrowBepu lt = new LightThrowBepu(this.World, factory);
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory, IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
{
SimpleModel simpleModel = new SimpleModel(factory, "Model//cenario");
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
DeferredNormalShader shader = new DeferredNormalShader();
DeferredMaterial fmaterial = new DeferredMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
{
SimpleModel sm = new SimpleModel(factory, "..\\Content\\Model\\block");
sm.SetTexture(factory.CreateTexture2DColor(1, 1, Color.White), TextureType.DIFFUSE);
BoxObject pi = new BoxObject(new Vector3(100, 40, 0), 1, 1, 1, 25, new Vector3(100, 10, 100), Matrix.Identity, MaterialDescription.DefaultBepuMaterial());
DeferredNormalShader shader = new DeferredNormalShader();
IMaterial mat = new DeferredMaterial(shader);
IObject obj3 = new IObject(mat, sm, pi);
this.World.AddObject(obj3);
}
#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);
#endregion
CameraFirstPerson cam = new CameraFirstPerson(GraphicInfo);
cam.MoveSpeed *= 5;
this.World.CameraManager.AddCamera(cam);
//this.RenderTechnic.AddPostEffect(new PloobsEngine.SceneControl.SimpleMotionBlurPostEffect());
this.RenderTechnic.AddPostEffect(new MotionBlurCompletePostEffect());
SkyBoxSetTextureCube stc = new SkyBoxSetTextureCube("Textures//grasscube");
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(stc);
}
/// <summary>
/// Load content for the screen.
/// </summary>
/// <param name="GraphicInfo"></param>
/// <param name="factory"></param>
/// <param name="contentManager"></param>
protected override void LoadContent(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.GraphicFactory factory, IContentManager contentManager)
{
///must be called before all
base.LoadContent(GraphicInfo, factory, contentManager);
RegisterDebugDrawCommand rc = new RegisterDebugDrawCommand(ddrawer);
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(rc);
ddrawer.AddShape(new DebugBox(new BoundingBox(new Vector3(-50),new Vector3(50)),Color.Red));
DebugLine dl = new DebugLine(Vector3.Zero, new Vector3(1000, 1000, 1000), Color.Red);
ddrawer.AddShape(dl);
DebugLines dls = new DebugLines();
ddrawer.AddShape(dls);
dls.AddLine(Vector3.Zero, new Vector3(-1000, 1000, -1000), Color.Green);
dls.AddLine(Vector3.Zero, new Vector3(-1000, 1000, 1000), Color.Pink);
SimpleModel simpleModel = new SimpleModel(factory, "Model//cenario");
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
DeferredNormalShader shader = new DeferredNormalShader();
DeferredMaterial fmaterial = new DeferredMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
///Add some directional lights to completely iluminate the world
#region Lights
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.4f;
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
///Add a AA post effect
this.RenderTechnic.AddPostEffect(new AntiAliasingPostEffect());
///add a camera
this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo));
}
/// <summary>
/// Load content for the screen.
/// </summary>
/// <param name="GraphicInfo"></param>
/// <param name="factory"></param>
/// <param name="contentManager"></param>
protected override void LoadContent(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.GraphicFactory factory, IContentManager contentManager)
{
///must be called before all
base.LoadContent(GraphicInfo, factory, contentManager);
{
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
float x, y;
x = -i * 100;
y = -j * 100;
TreeModel tm = new TreeModel(factory,"Trees\\Pine",null,null);
DeferredTreeShader ts = new DeferredTreeShader();
TreeMaterial tmat = new TreeMaterial(ts, new WindStrengthSin());
GhostObject go = new GhostObject(new Vector3(x, 0, y), Matrix.Identity, new Vector3(0.05f));
IObject ox = new IObject(tmat, tm, go);
this.World.AddObject(ox);
}
}
}
///Add some directional lights to completely iluminate the world
#region Lights
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.4f;
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
///Add a AA post effect
this.RenderTechnic.AddPostEffect(new AntiAliasingPostEffect());
///add a camera
this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo.Viewport));
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory ,IContentManager contentManager)
{
base.LoadContent(GraphicInfo,factory, contentManager);
this.contentManager = contentManager;
SimpleModel simpleModel = new SimpleModel(factory, "Model//cenario");
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
DeferredNormalShader shader = new DeferredNormalShader();
DeferredMaterial fmaterial = new DeferredMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
//ap = new SoundAudioPlayer(contentManager);
//ap.AddSoundToRepository("Songs/bye", "bye");
//se = new SimpleSoundEffect(contentManager, "Songs/alarm");
//LocalMediaAudioPlayer lm = new LocalMediaAudioPlayer();
//AlbumCollection ac = lm.MediaLibrary.Albums;
//lm.PlayAlbum(ac[0]);
sound = new Static3DSound(factory, "Songs/pianosong", Vector3.Zero);
this.World.AddSoundEmitter(sound, true);
//ObjectFollower3DSound sound2 = new ObjectFollower3DSound(contentManager, "Songs/pianosong", obj);
#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);
#endregion
this.World.CameraManager.AddCamera(new CameraFirstPerson(true,GraphicInfo));
SkyBoxSetTextureCube stc = new SkyBoxSetTextureCube("Textures//cubemap");
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(stc);
}
/// <summary>
/// Load content for the screen.
/// </summary>
/// <param name="GraphicInfo"></param>
/// <param name="factory"></param>
/// <param name="contentManager"></param>
protected override void LoadContent(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.GraphicFactory factory, IContentManager contentManager)
{
///must be called before all
base.LoadContent(GraphicInfo, factory, contentManager);
List<IObject> balls = new List<IObject>();
Vector3 pos1,pos2;
pos1 = new Vector3(0, 20, 0);
pos2 = new Vector3(0,-50,0);
IObject ball1 = CreateSphere(pos1, Matrix.Identity, Color.Red);
ball1.PhysicObject.isMotionLess = true; // Setting the Parent object as static
World.AddObject(ball1);
IObject ball2 = CreateSphere(pos2,Matrix.Identity,Color.White);
World.AddObject(ball2);
balls.Add(ball2);
constraint = new PointPointConstraint((pos1 + pos2) / 2, ball1.PhysicObject, ball2.PhysicObject);
World.PhysicWorld.AddConstraint(constraint);
///Add some directional lights to completely iluminate the world
#region Lights
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.4f;
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
lt = new LightThrowBepu(this.World, factory);
lt.force = 60;
///add a camera
this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo));
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory ,IContentManager contentManager)
{
base.LoadContent(GraphicInfo,factory, contentManager);
ExtractXmlModelLoader ext = new ExtractXmlModelLoader("Content//ModelInfos//", "Model//", "Textures//");
ModelLoaderData data = ext.Load(factory, GraphicInfo, "sponza");
WorldLoader wl = new WorldLoader();
wl.LoadWorld(factory, GraphicInfo, World, data);
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.1f;
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);
#endregion
CameraFirstPerson cam = new CameraFirstPerson(GraphicInfo);
//cam.MoveSpeed *= 5;
this.World.CameraManager.AddCamera(cam);
/////Interpolator to change lightDirection
//inter.Start(new Vector3(0, -1, 0), new Vector3(1, -1, 1), 3, true);
this.RenderTechnic.AddPostEffect(new AntiAliasingPostEffectStalker());
this.RenderTechnic.AddPostEffect(new BloomPostEffect());
//HdrPostEffect HdrPostEffect = new HdrPostEffect();
//HdrPostEffect.bloomMultiplier = 0.3f;
//this.RenderTechnic.AddPostEffect(HdrPostEffect);
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory ,IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
ExtractXmlModelLoader ext = new ExtractXmlModelLoader("Content//ModelInfos//", "Model//", "Textures//");
ModelLoaderData data = ext.Load(factory, GraphicInfo, "techdemo");
WorldLoader wl = new WorldLoader();
wl.OnCreateIObject += new CreateIObject(wl_OnCreateIObject);
wl.OnCreateILight += new CreateILight(wl_OnCreateILight);
wl.LoadWorld(factory, GraphicInfo, World, data);
LightThrowBepu lt = new LightThrowBepu(this.World, factory);
{
l = new DirectionalLightPE(new Vector3(0.2f, -1, 0.2f), Color.White);
l.CastShadown = true;
float lii = 0.6f;
l.LightIntensity = lii;
this.World.AddLight(l);
}
#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);
//DirectionalLightPE ld6 = new DirectionalLightPE(Vector3.Up, Color.White);
//float li = 0.5f;
//ld1.LightIntensity = li;
//ld2.LightIntensity = li;
//ld3.LightIntensity = li;
//ld4.LightIntensity = li;
//ld5.LightIntensity = li;
//ld6.LightIntensity = li;
//this.World.AddLight(ld1);
//this.World.AddLight(ld2);
//this.World.AddLight(ld3);
//this.World.AddLight(ld4);
//this.World.AddLight(ld5);
//this.World.AddLight(ld6);
#endregion
CameraFirstPerson cam = new CameraFirstPerson(GraphicInfo);
cam.FarPlane = 1000;
cam.MoveSpeed *= 5;
this.World.CameraManager.AddCamera(cam);
this.RenderTechnic.AddPostEffect(new AntiAliasingPostEffect());
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory ,IContentManager contentManager)
{
base.LoadContent(GraphicInfo,factory, contentManager);
Picking picking = new Picking(this);
this.AddScreenUpdateable(picking);
perlim = factory.CreateTexture2DPerlinNoise(512, 512, 0.03f, 3f, 0.5f, 1);
to = new TerrainObject(factory,perlim, Vector3.Zero, Matrix.Identity, MaterialDescription.DefaultBepuMaterial(), 2, 2);
//TerrainObject to = new TerrainObject(factory,"..\\Content\\Textures\\Untitled",Vector3.Zero,Matrix.Identity,MaterialDescription.DefaultBepuMaterial(),2,1);
TerrainModel stm = new TerrainModel(factory, to,"TerrainName","..\\Content\\Textures\\Terraingrass", "..\\Content\\Textures\\rock", "..\\Content\\Textures\\sand", "..\\Content\\Textures\\snow");
DeferredTerrainShader shader = new DeferredTerrainShader(TerrainType.MULTITEXTURE);
DeferredMaterial mat = new DeferredMaterial(shader);
IObject obj3 = new IObject(mat, stm, to);
this.World.AddObject(obj3);
#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);
#endregion
this.World.CameraManager.AddCamera(new CameraFirstPerson(true,GraphicInfo));
SkyBoxSetTextureCube stc = new SkyBoxSetTextureCube("Textures//cubemap");
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(stc);
///O PICKING FUNCIONA APENAS COM OBJETOS QUE TENHAM CORPO FISICO REAL !!!
///OS GHOST E OS DUMMY NUNCA SERAO SELECIONADOS
///Para ser informado a todo frame sobre as colisoes do raio, basta utilizar o outro construtor
picking.OnPickedLeftButton += new OnPicked(onPick);
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory ,IContentManager contentManager)
{
base.LoadContent(GraphicInfo,factory, contentManager);
{
SimpleModel simpleModel = new SimpleModel(factory, "Model//techdemo");
GhostObject tmesh = new GhostObject();
DeferredNormalShader shader = new DeferredNormalShader();
DeferredMaterial fmaterial = new DeferredMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
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);
DirectionalLightPE ld6 = new DirectionalLightPE(Vector3.Up, Color.White);
float li = 0.9f;
ld1.LightIntensity = li;
ld2.LightIntensity = li;
ld3.LightIntensity = li;
ld4.LightIntensity = li;
ld5.LightIntensity = li;
ld6.LightIntensity = li;
this.World.AddLight(ld1);
this.World.AddLight(ld2);
this.World.AddLight(ld3);
this.World.AddLight(ld4);
this.World.AddLight(ld5);
this.World.AddLight(ld6);
#endregion
CameraFirstPerson cam = new CameraFirstPerson(GraphicInfo);
cam.MoveSpeed *= 5;
this.World.CameraManager.AddCamera(cam);
this.RenderTechnic.AddPostEffect(new AntiAliasingPostEffect());
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory ,IContentManager contentManager)
{
base.LoadContent(GraphicInfo,factory, contentManager);
///Create the Terrain Object
///Controls how the heigh map is loaded
TerrainObject to = new TerrainObject(factory,"..\\Content\\Textures\\Untitled",Vector3.Zero,Matrix.Identity,MaterialDescription.DefaultBepuMaterial(),2,1);
///Create the Model using the Terrain Object. Here we pass the textures used, in our case we are using MultiTextured Terrain so we pass lots of textures
TerrainModel stm = new TerrainModel(factory, to,"TerrainName","..\\Content\\Textures\\Terraingrass", "..\\Content\\Textures\\rock", "..\\Content\\Textures\\sand", "..\\Content\\Textures\\snow");
///Create the shader
///In this sample we passed lots of textures, each one describe a level in the terrain, the ground is the sand and grass. the hills are rocks and the "mountains" are snow
///They are interpolated in the shader, you can control how using the shader parameters exposed in the DeferredTerrainShader
DeferredTerrainShader shader = new DeferredTerrainShader(TerrainType.MULTITEXTURE);
///the classic material
DeferredMaterial mat = new DeferredMaterial(shader);
IObject obj3 = new IObject(mat, stm, to);
this.World.AddObject(obj3);
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);
#endregion
CameraFirstPerson cam = new CameraFirstPerson(MathHelper.ToRadians(30), MathHelper.ToRadians(-10), new Vector3(200, 150, 250), GraphicInfo);
this.World.CameraManager.AddCamera(cam);
SkyBoxSetTextureCube stc = new SkyBoxSetTextureCube("Textures//grassCube");
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(stc);
this.RenderTechnic.AddPostEffect(new AntiAliasingPostEffectStalker());
}
/// <summary>
/// Load content for the screen.
/// </summary>
/// <param name="GraphicInfo"></param>
/// <param name="factory"></param>
/// <param name="contentManager"></param>
protected override void LoadContent(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.GraphicFactory factory, IContentManager contentManager)
{
///must be called before all
base.LoadContent(GraphicInfo, factory, contentManager);
///Uncoment to Add an object
/////Create a simple object
/////Geomtric Info and textures (this model automaticaly loads the texture)
//SimpleModel simpleModel = new SimpleModel(factory, "Model FILEPATH GOES HERE", "Diffuse Texture FILEPATH GOES HERE -- Use only if it is not embeded in the Model file");
/////Physic info (position, rotation and scale are set here)
//TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
/////Shader info (must be a deferred type)
//DeferredNormalShader shader = new DeferredNormalShader();
/////Material info (must be a deferred type also)
//DeferredMaterial fmaterial = new DeferredMaterial(shader);
/////The object itself
//IObject obj = new IObject(fmaterial, simpleModel, tmesh);
/////Add to the world
//this.World.AddObject(obj);
///Add some directional lights to completely iluminate the world
#region Lights
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.4f;
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
///Add a AA post effect
this.RenderTechnic.AddPostEffect(new AntiAliasingPostEffect());
///add a camera
this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo.Viewport));
}
/// <summary>
/// Load content for the screen.
/// </summary>
/// <param name="GraphicInfo"></param>
/// <param name="factory"></param>
/// <param name="contentManager"></param>
protected override void LoadContent(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.GraphicFactory factory, IContentManager contentManager)
{
///must be called before all
base.LoadContent(GraphicInfo, factory, contentManager);
///Create a simple object
///Geomtric Info and textures (this model automaticaly loads the texture)
SimpleModel simpleModel = new SimpleModel(factory, "Model//cenario");
///Physic info (postion, rotation and scale are set here)
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
///Shader info (must be a deferred type -- BECAUSE OF THE RENDER TECHNICH)
DeferredNormalShader shader = new DeferredNormalShader();
///Material info (must be a deferred type also)
DeferredMaterial fmaterial = new DeferredMaterial(shader);
///The object itself
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
///Add to the world
this.World.AddObject(obj);
///Add some directional lights
#region Lights
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.4f;
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
///Add a post effect
this.RenderTechnic.AddPostEffect(new AntiAliasingPostEffect());
///add a camera
this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo));
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory ,IContentManager contentManager)
{
base.LoadContent(GraphicInfo,factory, contentManager);
ExplosionParticleSystem exp = new ExplosionParticleSystem();
DPFSParticleSystem ps = new DPFSParticleSystem("exp", exp);
this.World.ParticleManager.AddAndInitializeParticleSystem(ps);
//SimpleModel simpleModel = new SimpleModel(factory, "Model//cenario");
//TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
//DeferredNormalShader shader = new DeferredNormalShader();
//DeferredMaterial fmaterial = new DeferredMaterial(shader);
//IObject obj = new IObject(fmaterial, simpleModel, tmesh);
//this.World.AddObject(obj);
#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);
#endregion
this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo));
//SkyBoxSetTextureCube stc = new SkyBoxSetTextureCube("Textures//cubemap");
//CommandProcessor.getCommandProcessor().SendCommandAssyncronous(stc);
//this.RenderTechnic.AddPostEffect(new AntiAliasingPostEffectTabula());
this.RenderTechnic.AddPostEffect(new AntiAliasingPostEffectStalker());
}
/// <summary>
/// Load content for the screen.
/// </summary>
/// <param name="GraphicInfo"></param>
/// <param name="factory"></param>
/// <param name="contentManager"></param>
protected override void LoadContent(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.GraphicFactory factory, IContentManager contentManager)
{
///must be called before all
base.LoadContent(GraphicInfo, factory, contentManager);
SimpleModel simpleModel = new SimpleModel(factory, "Model//cenario");
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
DeferredNormalShader shader = new DeferredNormalShader();
DeferredMaterial fmaterial = new DeferredMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
///Add some directional lights to completely iluminate the world
#region Lights
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.4f;
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
///Add a AA post effect
//this.RenderTechnic.AddPostEffect(new AntiAliasingPostEffect());
lt = new LightThrowBepu(this.World, factory);
///add a camera
this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo));
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory ,IContentManager contentManager)
{
base.LoadContent(GraphicInfo,factory, contentManager);
SimpleModel simpleModel = new SimpleModel(factory, "Model//cenario");
simpleModel.SetTexture(factory.GetTexture2D("textures/islandmap2"), TextureType.DIFFUSE);
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
DeferredNormalShader shader = new DeferredNormalShader();
DeferredMaterial fmaterial = new DeferredMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
this.RenderTechnic.AddPostEffect(new GammaCorrectionPostEffect(GammaType.Normal));
#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);
#endregion
this.World.CameraManager.AddCamera(new CameraFirstPerson(true,GraphicInfo));
SkyBoxSetTextureCube stc = new SkyBoxSetTextureCube("Textures//cubeMapGamma");
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(stc);
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory ,IContentManager contentManager)
{
base.LoadContent(GraphicInfo,factory, contentManager);
TerrainObject to = new TerrainObject(factory,"..\\Content\\Textures\\Untitled",Vector3.Zero,Matrix.Identity,MaterialDescription.DefaultBepuMaterial(),2,1);
TerrainModel stm = new TerrainModel(factory, to,"TerrainName","..\\Content\\Textures\\Terraingrass", "..\\Content\\Textures\\rock", "..\\Content\\Textures\\sand", "..\\Content\\Textures\\snow");
DeferredTerrainShader shader = new DeferredTerrainShader(TerrainType.MULTITEXTURE);
DeferredMaterial mat = new DeferredMaterial(shader);
IObject obj3 = new IObject(mat, stm, to);
this.World.AddObject(obj3);
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);
#endregion
this.World.CameraManager.AddCamera(new CameraFirstPerson(true,GraphicInfo));
SkyBoxSetTextureCube stc = new SkyBoxSetTextureCube("Textures//cubemap");
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(stc);
}
private void DrawDirectionalLight(RenderHelper render, GraphicInfo ginfo, ICamera camera, DirectionalLightPE dl, IDeferredGBuffer DeferredGBuffer)
{
directionalLightEffect.Parameters["shadowBufferSize"].SetValue(shadownBufferSize);
if(dl.CastShadown)
//directionalLightEffect.Parameters["xShadowMap"].SetValue(shadowMap);
render.device.Textures[3] = shadowMap;
else
//directionalLightEffect.Parameters["xShadowMap"].SetValue(blank);
render.device.Textures[3] = blank;
//directionalLightEffect.Parameters["colorMap"].SetValue(DeferredGBuffer[GBufferTypes.COLOR]);
//directionalLightEffect.Parameters["normalMap"].SetValue(DeferredGBuffer[GBufferTypes.NORMAL]);
//directionalLightEffect.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);
directionalLightEffect.Parameters["View"].SetValue(camera.View);
directionalLightEffect.Parameters["Projection"].SetValue(camera.Projection);
directionalLightEffect.Parameters["cameraPosition"].SetValue(camera.Position);
directionalLightEffect.Parameters["shadown"].SetValue(dl.CastShadown);
directionalLightEffect.Parameters["InvertViewProjection"].SetValue(Matrix.Invert(camera.ViewProjection));
directionalLightEffect.Parameters["halfPixel"].SetValue(ginfo.HalfPixel);
directionalLightEffect.Parameters["lightDirection"].SetValue(dl.LightDirection);
directionalLightEffect.Parameters["Color"].SetValue(dl.Color.ToVector3());
directionalLightEffect.Parameters["lightIntensity"].SetValue(dl.LightIntensity);
render.PushDepthStencilState(DepthStencilState.None);
render.RenderFullScreenQuadVertexPixel(directionalLightEffect);
render.PopDepthStencilState();
render.SetSamplerState(s2, 2);
render.SetSamplerState(s3, 3);
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory ,IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
{
SimpleModel simpleModel = new SimpleModel(factory, "Model//cenario");
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
PrePassShader shader = new PrePassShader();
DeferredMaterial fmaterial = new DeferredMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
#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.3f;
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
LightThrowBepu LightThrowBepu = new LightThrowBepu(this.World,factory);
this.AttachCleanUpAble(LightThrowBepu);
this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo));
}
protected override void LoadContent(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.GraphicFactory factory, IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
#region Models
///Cria uma textura 1x1 com a cor branca
Texture2D white = factory.CreateTexture2DColor(1,1, Color.White);
{
SimpleModel sm = new SimpleModel(factory, "..\\Content\\Model\\cubo");
sm.SetTexture(white, TextureType.DIFFUSE);
BoxObject pi = new BoxObject(new Vector3(100, 20, 0), 1,1,1, 5,new Vector3(100, 5, 100),Matrix.Identity,MaterialDescription.DefaultBepuMaterial());
DeferredNormalShader shader = new DeferredNormalShader();
///Setando alguns parametros do material
shader.SpecularIntensity = 0.01f;
shader.SpecularPower = 50;
IMaterial mat = new DeferredMaterial(shader);
IObject obj3 = new IObject(mat, sm, pi);
this.World.AddObject(obj3);
}
{
SimpleModel sm = new SimpleModel(factory,"..\\Content\\Model\\cubo");
sm.SetTexture(white, TextureType.DIFFUSE);
BoxObject pi = new BoxObject(new Vector3(90, 30, 0), 1,1,1, 10,new Vector3(1),Matrix.Identity,MaterialDescription.DefaultBepuMaterial());
DeferredNormalShader shader = new DeferredNormalShader();
IMaterial mat = new DeferredMaterial(shader);
IObject obj3 = new IObject(mat, sm, pi);
this.World.AddObject(obj3);
}
{
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);
this.World.AddObject(obj3);
}
#endregion
#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.4f;
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
///Criando uma camera estatica
CameraStatic camx = new CameraStatic(new Vector3(130, 100, 700), Vector3.Zero);
///Dando um nome a ela (para poder recupera-la depois)
camx.Name = "default";
camx.FarPlane = 3000;
///Adiciona ao Manager (NAO ESTA SENDO ATIVADA, APENAS ADICIONADA)
this.World.CameraManager.AddCamera(camx, camx.Name);
///Ativa a camera atual (AO ADICIONAR UMA CAMERA AO WORLD USANDO mundo.AddCamera(cam) A CAMERA EH AUTOMATICAMENTE ATIVADA )
this.World.CameraManager.SetActiveCamera(camx.Name);
///Adiciona na lista circular
camerasNames.Value = camx.Name;
camerasNames.Next();
///Idem para uma segunda camera (Porem esta nao eh ativada)
CameraStatic cam2 = new CameraStatic(new Vector3(100, 100, 100), Vector3.Zero);
cam2.Name = "StaticCamera";
cam2.FarPlane = 3000;
this.World.CameraManager.AddCamera(cam2, cam2.Name);
camerasNames.Value = cam2.Name;
camerasNames.Next();
///Idem para a terceira
CameraStatic cam3 = new CameraStatic(new Vector3(500, 300, 300), Vector3.Zero);
cam3.Name = "StaticCamera3";
cam3.FarPlane = 3000;
this.World.CameraManager.AddCamera(cam3, cam3.Name);
camerasNames.Value = cam3.Name;
camerasNames.Next();
SimpleConcreteKeyboardInputPlayable ikp = new SimpleConcreteKeyboardInputPlayable(StateKey.PRESS, Keys.Space, KeyStateChange);
bk = new BindKeyCommand(ikp, BindAction.ADD);
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(bk);
}
protected override void LoadContent(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.GraphicFactory factory, IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
{
SimpleModel sm = new SimpleModel(factory, "..\\Content\\Model\\ball");
sm.SetTexture(factory.CreateTexture2DColor(1, 1, Color.Blue), TextureType.DIFFUSE);
IPhysicObject pi = new SphereObject(new Vector3(0, 0, 0), 1, 10, 30, MaterialDescription.DefaultBepuMaterial());
pi.isMotionLess = true;
ForwardXNABasicShader shader = new ForwardXNABasicShader();
IMaterial mat = new ForwardMaterial(shader);
IObject obj3 = new IObject(mat, sm, pi);
this.World.AddObject(obj3);
shader.BasicEffect.EnableDefaultLighting();
BepuPhysicWorld physicWorld;
physicWorld = this.World.PhysicWorld as BepuPhysicWorld;
System.Diagnostics.Debug.Assert(physicWorld != null);
var field = new GravitationalFieldObject(new InfiniteForceFieldShape(), obj3.PhysicObject.Position, 66730 / 2f, 10000, physicWorld);
///This Method is from BepuPhysicWorld not from th IPhysicObject
///You can use everithing from Bepu using this object instead of the interface
///but take care, the engine dont know about THIS !!! it does not manage these things
physicWorld.Space.Add(field);
}
int numColumns = 7;
int numRows = 7;
int numHigh = 7;
float separation = 3;
{
///reuse instances that does not change
SimpleModel sm = new SimpleModel(factory, "..\\Content\\Model\\cubo");
sm.SetTexture(factory.CreateTexture2DColor(1, 1, Color.White), TextureType.DIFFUSE);
ForwardXNABasicShader shader = new ForwardXNABasicShader();
IMaterial mat = new ForwardMaterial(shader);
for (int i = 0; i < numRows; i++)
{
for (int j = 0; j < numColumns; j++)
{
for (int k = 0; k < numHigh; k++)
{
BoxObject pi = new BoxObject(new Vector3(separation * i - numRows * separation / 2, 40 + k * separation, separation * j - numColumns * separation / 2), 1, 1, 1, 5, new Vector3(1), Matrix.Identity, MaterialDescription.DefaultBepuMaterial());
pi.Entity.LinearDamping = 0;
pi.Entity.AngularDamping = 0;
IObject obj3 = new IObject(mat, sm, pi);
this.World.AddObject(obj3);
pi.Entity.LinearVelocity = new Vector3(30, 0, 0);
}
}
}
shader.BasicEffect.EnableDefaultLighting();
}
//cam = new CameraFirstPerson(GraphicInfo);
//cam.FarPlane = 3000;
#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.4f;
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
RotatingCamera cam = new RotatingCamera(this,new Vector3(0,0,-300));
this.World.CameraManager.AddCamera(cam);
}
/// <summary>
/// Load content for the screen.
/// </summary>
/// <param name="GraphicInfo"></param>
/// <param name="factory"></param>
/// <param name="contentManager"></param>
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory, IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
#region Models
{
///Need to load the height, the normal texture and the difuse texture
SimpleModel sm = new SimpleModel(factory, "..\\Content\\Model\\block", "..\\Content\\Textures\\color_map");
sm.SetTexture("Textures\\normal_map", TextureType.BUMP);
sm.SetCubeTexture(factory.GetTextureCube("Textures//grassCUBE"), TextureType.AMBIENT_CUBE_MAP);
BoxObject pi = new BoxObject(new Vector3(200, 110, 0), 1, 1, 1, 5, new Vector3(100, 100, 100), Matrix.Identity, MaterialDescription.DefaultBepuMaterial());
DeferredCustomShader DeferredCustomShader = new DeferredCustomShader(false, true, false,false,true);
DeferredCustomShader.SpecularIntensity = 0.2f;
DeferredCustomShader.SpecularPower = 30;
DeferredCustomShader.AmbientCubeMapScale = 0.05f;
IMaterial mat = new DeferredMaterial(DeferredCustomShader);
IObject obj3 = new IObject(mat, sm, pi);
this.World.AddObject(obj3);
}
{
SimpleModel simpleModel = new SimpleModel(factory, "Model//cenario");
simpleModel.SetCubeTexture(factory.GetTextureCube("Textures//grassCUBE"), TextureType.AMBIENT_CUBE_MAP);
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
DeferredNormalShader shader = new DeferredNormalShader(0,0,true,0.05f);
DeferredMaterial fmaterial = new DeferredMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
{
SimpleModel simpleModel = new SimpleModel(factory, "Model//ball");
simpleModel.SetCubeTexture(factory.GetTextureCube("Textures//grassCUBE"), TextureType.AMBIENT_CUBE_MAP);
simpleModel.SetTexture(factory.CreateTexture2DColor(1,1,Color.White),TextureType.DIFFUSE);
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, new Vector3(50,50,-100), Matrix.Identity, Vector3.One * 20, MaterialDescription.DefaultBepuMaterial());
DeferredNormalShader shader = new DeferredNormalShader(0, 0, true, 0.2f);
DeferredMaterial fmaterial = new DeferredMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
#endregion
#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.2f;
ld1.LightIntensity = li;
ld2.LightIntensity = li;
ld3.LightIntensity = li;
ld4.LightIntensity = li;
ld5.LightIntensity = li;
this.World.AddLight(ld1);
this.World.AddLight(ld3);
this.World.AddLight(ld5);
#endregion
CameraFirstPerson cam = new CameraFirstPerson(MathHelper.ToRadians(10), MathHelper.ToRadians(-10), new Vector3(200, 150, 250), GraphicInfo);
this.World.CameraManager.AddCamera(cam);
new LightThrowBepu(this.World, GraphicFactory);
SkyBoxSetTextureCube stc = new SkyBoxSetTextureCube("Textures//grassCUBE");
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(stc);
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory ,IContentManager contentManager)
{
PhysxPhysicWorld PhysxPhysicWorld = World.PhysicWorld as PhysxPhysicWorld;
base.LoadContent(GraphicInfo, factory, contentManager);
const int maximumParticles = 1000;
var fluidEmitterDesc = new FluidEmitterDescription()
{
DimensionX = 0.5f,
DimensionY = 0.5f,
Rate = 15,
RelativePose =
Phyx.Matrix.RotationAxis(new Phyx.Vector3(0, 1, 0), (float)Math.PI) *
Phyx.Matrix.Translation(-40, 10, -50),
Shape = EmitterShape.Rectangular,
Type = EmitterType.ConstantFlowRate,
RandomAngle = 0.5f
};
fluidEmitterDesc.Flags |= (FluidEmitterFlag.Enabled | FluidEmitterFlag.Visualization);
var fluidDesc = new FluidDescription()
{
Emitters = { fluidEmitterDesc },
Flags = FluidFlag.Enabled | FluidFlag.Visualization | FluidFlag.Enabled,
MaximumParticles = maximumParticles,
};
fluidDesc.ParticleWriteData.AllocatePositionBuffer<Vector3>(maximumParticles);
fluidDesc.ParticleWriteData.NumberOfParticles = maximumParticles;
InstancedBilboardModel InstancedBilboardModel = new InstancedBilboardModel(factory, "teste", "Textures/Smoke", new BilboardInstance[] {new BilboardInstance() }, maximumParticles);
PhysxFluidObject PhysxFluidObject = new PloobsEngine.Physics.PhysxFluidObject(fluidDesc);
DeferredInstancedBilboardShader DeferredInstancedBilboardShader = new PloobsEngine.Material.DeferredInstancedBilboardShader(BilboardType.Spherical);
DeferredInstancedBilboardShader.AlphaTestLimit = 0.2f;
FluidMaterial DeferredMaterial = new FluidMaterial(DeferredInstancedBilboardShader,maximumParticles,new Vector2(0.2f));
IObject IObject = new IObject(DeferredMaterial, InstancedBilboardModel, PhysxFluidObject);
this.World.AddObject(IObject);
// Ledge
{
var boxShapeDesc = new BoxShapeDescription(5, 0.1f, 5);
SimpleModel SimpleModel = new PloobsEngine.Modelo.SimpleModel(factory, "Model/block");
SimpleModel.SetTexture(factory.CreateTexture2DColor(1, 1, Color.Red), TextureType.DIFFUSE);
PhysxPhysicObject PhysxPhysicObject = new PloobsEngine.Physics.PhysxPhysicObject(boxShapeDesc,
(Phyx.Matrix.RotationX(-0.5f) * Phyx.Matrix.Translation(-40, 5, -52)).AsXNA(),new Vector3(5,0.1f,5));
DeferredNormalShader shader = new DeferredNormalShader();
DeferredMaterial fmaterial = new DeferredMaterial(shader);
IObject obj = new IObject(fmaterial, SimpleModel, PhysxPhysicObject);
this.World.AddObject(obj);
}
// Drain
{
var boxShapeDesc = new BoxShapeDescription(5, 0.1f, 5);
boxShapeDesc.Flags |= ShapeFlag.FluidDrain;
var drainActorDesc = new ActorDescription()
{
GlobalPose = Phyx.Matrix.Translation(-40, 0, -55),
Shapes = { boxShapeDesc }
};
var drianActor = PhysxPhysicWorld.Scene.CreateActor(drainActorDesc);
}
#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);
#endregion
BallThrowPhysx28 BallThrowBullet = new BallThrowPhysx28(this.World, GraphicFactory,false);
this.AttachCleanUpAble(BallThrowBullet);
this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo));
}
protected override void LoadContent(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.GraphicFactory factory, IContentManager contentManager)
{
///Must be called before everything in the LoadContent
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());
pi.isMotionLess = true;
///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);
///Create the Physic Objects
{
for (int i = 0; i < 15; i++)
{
CreateThrash(new Vector3(-70 + i * 5, 50, 10));
}
for (int i = 0; i < 15; i++)
{
CreateBox(new Vector3(-70 + i * 7, 100, 50));
}
for (int i = 0; i < 15; i++)
{
CreateThrash(new Vector3(-70 + i * 5, 80, 50));
}
for (int i = 0; i < 15; i++)
{
CreateBall(new Vector3(-70 + i * 5, 50, 30));
}
for (int i = 0; i < 15; i++)
{
CreateBox(new Vector3(-70 + i * 7, 130, -20));
}
for (int i = 0; i < 15; i++)
{
CreateBox(new Vector3(-70 + i * 7, 60, -50));
}
///Create A Ghost Object (Do Not Collide)
{
///Create a Simple Model
SimpleModel model = new SimpleModel(factory, "..\\Content\\Model\\ball");
model.SetTexture(factory.CreateTexture2DColor(1,1,Color.Purple), TextureType.DIFFUSE);
///Create a Physic Object
IPhysicObject pobj = new GhostObject(new Vector3(50, 13f, 50), Matrix.Identity, Vector3.One * 5);
pobj.isMotionLess = true;
///Create a shader
IShader nd = new DeferredNormalShader();
///Create a Material
IMaterial material = new DeferredMaterial(shader);
///Create a an Object that englobs everything and add it to the world
IObject obj = new IObject(material, model, pobj);
this.World.AddObject(obj);
}
}
///Call the function releaseObjects when Space key is pressed
InputPlayableKeyBoard ip1 = new SimpleConcreteKeyboardInputPlayable(StateKey.PRESS, Microsoft.Xna.Framework.Input.Keys.Space, releaseObjects);
///Using the Global Method, need to release when screen is cleaned
///Check the KeyboardInputScreen for how to use it locally
mm = new BindKeyCommand(ip1, BindAction.ADD);
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(mm);
///Create a FirstPerson Camera
///This is a special camera, used in the development
///You can move around using wasd / qz / and the mouse
CameraFirstPerson cam = new CameraFirstPerson(GraphicInfo);
this.World.CameraManager.AddCamera(cam);
///Create some directionals lights and add to the world
DirectionalLightPE ld = new DirectionalLightPE(Vector3.Forward, Color.White);
DirectionalLightPE ld2 = new DirectionalLightPE(Vector3.Left, Color.White);
DirectionalLightPE ld3 = new DirectionalLightPE(Vector3.Down, Color.White);
ld.LightIntensity = 0.5f;
ld2.LightIntensity = 0.5f;
ld3.LightIntensity = 0.5f;
this.World.AddLight(ld);
this.World.AddLight(ld2);
this.World.AddLight(ld3);
lightThrow = new LightThrowBepu(this.World,factory);
this.RenderTechnic.AddPostEffect(new AntiAliasingPostEffect());
}
protected override void LoadContent(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.GraphicFactory factory, IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
#region Models
///Cria um modelo Controlavel pelo teclado
{
SimpleModel sm = new SimpleModel(factory,"..\\Content\\Model\\cubo");
sm.SetTexture(factory.CreateTexture2DColor(1,1,Color.Blue),TextureType.DIFFUSE);
DeferredNormalShader shader = new DeferredNormalShader();
IMaterial mat = new DeferredMaterial(shader);
CharacterControllerInput character = new CharacterControllerInput(this, new Vector3(100, 150, 1), 1, 1, 50, Vector3.One * 10, 0.5f);
character.AheadKey = Keys.G;
character.BackKey = Keys.T;
character.LeftKey = Keys.F;
character.RightKey = Keys.H;
character.JumpKey = Keys.R;
character.Characterobj.CharacterController.MaxSpeed = 35f;
character.Characterobj.CharacterController.JumpSpeed = 15f;
player = new IObject(mat, sm, character.Characterobj);
this.World.AddObject(player);
}
///Cria o cenario padrao de sempre ;)
{
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);
this.World.AddObject(obj3);
}
#endregion
#region Cameras
cam0 = new CameraFollowObject(player);
///Dando um nome a ela (para poder recupera-la depois)
cam0.Name = "follow";
cam0.FarPlane = 3000;
///Adiciona ao Manager (NAO ESTA SENDO ATIVADA, APENAS ADICIONADA)
this.World.CameraManager.AddCamera(cam0, cam0.Name);
///Ativa a camera atual (AO ADICIONAR UMA CAMERA AO WORLD USANDO mundo.AddCamera(cam) A CAMERA EH AUTOMATICAMENTE ATIVADA )
this.World.CameraManager.SetActiveCamera(cam0.Name);
///Adiciona na lista circular
camerasNames.Value = cam0.Name;
camerasNames.Next();
cam1 = new CameraFirstPerson(GraphicInfo);
///Dando um nome a ela (para poder recupera-la depois)
cam1.Name = "first person";
cam1.FarPlane = 3000;
///Adiciona ao Manager (NAO ESTA SENDO ATIVADA, APENAS ADICIONADA)
this.World.CameraManager.AddCamera(cam1, cam1.Name);
///Ativa a camera atual (AO ADICIONAR UMA CAMERA AO WORLD USANDO mundo.AddCamera(cam) A CAMERA EH AUTOMATICAMENTE ATIVADA )
this.World.CameraManager.SetActiveCamera(cam1.Name);
///Adiciona na lista circular
camerasNames.Value = cam1.Name;
//camerasNames.Next();
#endregion
///Objeto que permite atirar bolas de luzes na cena
lt = new LightThrowBepu(this.World, factory);
#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.4f;
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
{
SimpleConcreteKeyboardInputPlayable ik = new SimpleConcreteKeyboardInputPlayable(StateKey.PRESS, Keys.Space, ChangeCamera);
BindKeyCommand bk = new BindKeyCommand(ik, BindAction.ADD);
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(bk);
}
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory, IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
#region Models
{
SimpleModel simpleModel = new SimpleModel(factory, "..\\Content\\Model\\teapot");
simpleModel.SetTexture(factory.CreateTexture2DColor(1,1, Color.Red), TextureType.DIFFUSE);
//TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
GhostObject tmesh = new GhostObject(Vector3.Zero, Matrix.Identity, Vector3.One);
///Environment Map Shader, there are 2 options, the first is a fully reflective surface (dont use the object texture) and the second
///is a mix of the object texture and the environment texture
///Used to fake ambient reflection, give metal appearence to an object ....
DeferredEMReflectiveShader shader = new DeferredEMReflectiveShader("Textures\\grassCUBE", 0.9f);
DeferredMaterial fmaterial = new DeferredMaterial(shader);
tea = new IObject(fmaterial, simpleModel, tmesh);
tea.OnUpdate += new OnUpdate(tea_OnUpdate);
this.World.AddObject(tea);
}
//{
// SimpleModel simpleModel = new SimpleModel(factory, "Model//block");
// simpleModel.SetTexture(factory.CreateTexture2DColor(1, 1, Color.White), TextureType.DIFFUSE);
// BoxObject tmesh = new BoxObject(new Vector3(0,-20,0), 1, 1, 1, 10, new Vector3(200, 1, 200), Matrix.Identity, MaterialDescription.DefaultBepuMaterial());
// tmesh.isMotionLess = true;
// DeferredNormalShader shader = new DeferredNormalShader();
// DeferredMaterial fmaterial = new DeferredMaterial(shader);
// IObject obj = new IObject(fmaterial, simpleModel, tmesh);
// this.World.AddObject(obj);
//}
#endregion
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);
#endregion
SkyBoxSetTextureCube stc = new SkyBoxSetTextureCube("Textures//grassCUBE");
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(stc);
CameraFirstPerson cam = new CameraFirstPerson(MathHelper.ToRadians(30), MathHelper.ToRadians(-30), new Vector3(30, 30, 50), GraphicInfo);
cam.FarPlane = 500;
cam.NearPlane = 1;
this.World.CameraManager.AddCamera(cam);
//AntiAliasingPostEffectTabula aa = new AntiAliasingPostEffectTabula();
//aa.Weights = 2;
//this.RenderTechnic.AddPostEffect(aa);
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory ,IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
{
{
///Create the xml file model extractor
///Loads a XML file that was export by our 3DS MAX plugin
ExtractXmlModelLoader ext = new ExtractXmlModelLoader("Content//ModelInfos//", "Model//", "Textures//");
this.AttachCleanUpAble(ext);
///Extract all the XML info (Model,Cameras, ...)
ModelLoaderData data = ext.Load(factory, GraphicInfo, "ilha");
///Create the WOrld Loader
///Convert the ModelLoaderData in World Entities
WorldLoader wl = new WorldLoader(); ///all default
wl.LoadWorld(factory, GraphicInfo, World, data);
}
}
{
SimpleModel sm2 = new SimpleModel(factory, "Model\\ball");
sm2.SetTexture(factory.CreateTexture2DColor(1, 1, Color.Red, false), TextureType.DIFFUSE);
DeferredNormalShader nd = new DeferredNormalShader();
IMaterial m = new DeferredMaterial(nd);
SphereObject pi2 = new SphereObject(new Vector3(100,50,0), 1, 10, 10, MaterialDescription.DefaultBepuMaterial());
IObject o = new IObject(m, sm2, pi2);
this.World.AddObject(o);
sound2 = new ObjectFollower3DSound(factory, "Songs/pianosong", o);
this.World.AddSoundEmitter(sound2,true);
}
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);
#endregion
CameraFirstPerson cam = new CameraFirstPerson(MathHelper.ToRadians(30), MathHelper.ToRadians(-10), new Vector3(200, 150, 250), GraphicInfo);
this.World.CameraManager.AddCamera(cam);
SkyBoxSetTextureCube stc = new SkyBoxSetTextureCube("Textures//grassCube");
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(stc);
}
/// <summary>
/// Load content for the screen.
/// </summary>
/// <param name="GraphicInfo"></param>
/// <param name="factory"></param>
/// <param name="contentManager"></param>
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory, IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
///Classic Island
SimpleModel simpleModel = new SimpleModel(factory, "Model//cenario");
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
DeferredNormalShader shader = new DeferredNormalShader();
DeferredMaterial fmaterial = new DeferredMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
{
///Procedural yellow diffuse texture
SimpleModel sm = new SimpleModel(factory, "Model\\block");
sm.SetTexture(factory.CreateTexture2DColor(1, 1, Color.BlueViolet), TextureType.DIFFUSE);
///physic Ghost object(no collision)
GhostObject pi = new GhostObject(new Vector3(0, 0, 0), Matrix.Identity, new Vector3(500, 500, 500));
pi.isMotionLess = true;
///Transparency shader
///Transparent objects are NOT affected by lights
///It is a forward shader in the deferred engine (applied after all deferreed processing)
ForwardTransparenteShader s = new ForwardTransparenteShader();
///If the texture does not have Alpha, you can create an alpha for all the model
s.TransparencyLevel = 0.3f;
///THIS MODEL is DRAW AFTER all the Deferred ones (remember:light wont afect it)
///You can use all the forward material the same way we are using this
ForwardMaterial mat = new ForwardMaterial(s);
IObject obj4 = new IObject(mat, sm, pi);
this.World.AddObject(obj4);
}
///Transparent blocks
for (int k = 0; k < 5; k++)
{
for (int i = 0; i < 5; i++)
{
for (int j = 0; j < 5; j++)
{
///Procedural yellow diffuse texture
SimpleModel sm = new SimpleModel(factory, "Model\\block");
sm.SetTexture(factory.CreateTexture2DColor(1, 1, Color.Yellow), TextureType.DIFFUSE);
///physic Ghost object(no collision)
GhostObject pi = new GhostObject(new Vector3(i * 10, 50 + k * 10, j * 10), Matrix.Identity, new Vector3(5));
pi.isMotionLess = true;
///Transparency shader
///Transparent objects are NOT affected by lights
///It is a forward shader in the deferred engine (applied after all deferreed processing)
ForwardTransparenteShader s = new ForwardTransparenteShader();
///If the texture does not have Alpha, you can create an alpha for all the model
s.TransparencyLevel = 0.3f;
///THIS MODEL is DRAW AFTER all the Deferred ones (remember:light wont afect it)
///You can use all the forward material the same way we are using this
ForwardMaterial mat = new ForwardMaterial(s);
IObject obj4 = new IObject(mat, sm, pi);
this.World.AddObject(obj4);
}
}
}
#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);
#endregion
CameraFirstPerson cam = new CameraFirstPerson(MathHelper.ToRadians(30), MathHelper.ToRadians(-10), new Vector3(200, 150, 250), GraphicInfo);
this.World.CameraManager.AddCamera(cam);
SkyBoxSetTextureCube stc = new SkyBoxSetTextureCube("Textures//grassCUBE");
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(stc);
}
