protected override void LoadContent(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.GraphicFactory factory, PloobsEngine.SceneControl.IContentManager contentManager)
{
tile = factory.GetTexture2D("Textures/tile");
FarseerWorld fworld = this.World.PhysicWorld as FarseerWorld;
///border
border = new Border(fworld, factory, GraphicInfo, factory.CreateTexture2DColor(1, 1, Color.Red));
///from texture
{
Texture2D tex = factory.GetTexture2D("Textures//goo");
tex = factory.GetScaledTexture(tex, new Vector2(4));
IModelo2D model = new SpriteFarseer(tex);
Basic2DTextureMaterial mat = new Basic2DTextureMaterial();
FarseerObject fs = new FarseerObject(fworld, model);
I2DObject o = new I2DObject(fs, mat, model);
o.OnHasMoved += new PloobsEngine.SceneControl._2DScene.OnHasMoved(o_OnHasMoved);
this.World.AddObject(o);
}
///camera
this.World.Camera2D = new Camera2D(GraphicInfo);
///Create the Particle System
DPFSParticleSystem ps = new DPFSParticleSystem("TESTE", new SpriteParticleSystem(null));
this.World.ParticleManager.AddAndInitializeParticleSystem(ps);
///updateable
JointUpdateable ju = new JointUpdateable(this, fworld, this.World.Camera2D);
base.LoadContent(GraphicInfo, factory, contentManager);
}
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());
ForwardXNABasicShader shader = new ForwardXNABasicShader(ForwardXNABasicShaderDescription.Default());
ForwardMaterial fmaterial = new ForwardMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
{
SimpleModel simpleModel = new SimpleModel(factory, "Model//uzi");
MobileMeshObject tmesh = new MobileMeshObject(simpleModel, new Vector3(100, 100, 10), Matrix.Identity, Vector3.One * 50, MaterialDescription.DefaultBepuMaterial(),BEPUphysics.CollisionShapes.MobileMeshSolidity.DoubleSided,10);
//TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, new Vector3(100, 100, 10), Matrix.Identity, Vector3.One * 50, MaterialDescription.DefaultBepuMaterial());
ForwardXNABasicShader shader = new ForwardXNABasicShader(ForwardXNABasicShaderDescription.Default());
ForwardMaterial fmaterial = new ForwardMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
new LightThrowBepu(this.World, factory);
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(GraphicInfo GraphicInfo, GraphicFactory factory, IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
///Uncoment to add your model
SimpleModel simpleModel = new SimpleModel(factory, "Model/cenario");
///Physic info (position, rotation and scale are set here)
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
///Forward Shader (look at this shader construction for more info)
ForwardXNABasicShader shader = new ForwardXNABasicShader();
///Deferred material
ForwardMaterial fmaterial = new ForwardMaterial(shader);
///The object itself
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
///Add to the world
this.World.AddObject(obj);
///add a camera
this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo));
///task sample
taskSample taskSample = new taskSample();
///when ended, call this (syncronous -- specified in the itask implementation) function
taskSample.Ended += new Action<ITask, IAsyncResult>(taskSample_Ended);
///create and send the task to the processor
TaskCommand TaskCommand = new TaskCommand(taskSample);
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(TaskCommand);
}
/// <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//cubemap"),TextureType.ENVIRONMENT);
BoxObject pi = new BoxObject(new Vector3(200, 110, 0), 1, 1, 1, 5, new Vector3(100, 100, 100), Matrix.Identity, MaterialDescription.DefaultBepuMaterial());
DeferredEnvironmentCustomShader DeferredEnvironmentCustomShader = new DeferredEnvironmentCustomShader(false, true, false);
DeferredEnvironmentCustomShader.SpecularIntensity = 0.2f;
DeferredEnvironmentCustomShader.SpecularPower = 30;
DeferredEnvironmentCustomShader.ShaderId = ShaderUtils.CreateSpecificBitField(true);
IMaterial mat = new DeferredMaterial(DeferredEnvironmentCustomShader);
IObject obj3 = new IObject(mat, sm, pi);
this.World.AddObject(obj3);
}
{
SimpleModel simpleModel = new SimpleModel(factory, "Model//cenario");
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
DeferredCustomShader shader = new DeferredCustomShader(false,false,false,false);
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.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(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//cubemap");
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(stc);
}
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(), 1, 1,10);
///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");
stm.SetTexture(factory.CreateTexture2DColor(1,1,Color.Green), TextureType.DIFFUSE);
///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
ForwardXNABasicShader shader = new ForwardXNABasicShader();
///Deferred material
ForwardMaterial fmaterial = new ForwardMaterial(shader);
///The object itself
IObject obj = new IObject(fmaterial, stm, to);
///Add to the world
this.World.AddObject(obj);
shader.BasicEffect.EnableDefaultLighting();
CameraFirstPerson cam = new CameraFirstPerson(GraphicInfo.Viewport);
this.World.CameraManager.AddCamera(cam);
}
/// <summary>
/// Initializes this instance.
/// </summary>
/// <param name="ginfo"></param>
/// <param name="factory"></param>
/// <param name="obj"></param>
public override void Initialize(GraphicInfo ginfo, GraphicFactory factory, IObject obj)
{
effect = factory.GetAlphaTestEffect();
effect.ReferenceAlpha = alphaToCut;
effect.AlphaFunction = CompareFunction;
base.Initialize(ginfo,factory,obj);
}
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());
ForwardXNABasicShader shader = new ForwardXNABasicShader(ForwardXNABasicShaderDescription.Default());
ForwardMaterial fmaterial = new ForwardMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
ConfigWriter cw = new ConfigWriter("teste.properties");
cw.AddKeyValue("teste", "value");
cw.Write();
ConfigReader cr = new ConfigReader("teste.properties");
cr.Read();
String v = cr.ReadValue("teste");
System.Diagnostics.Debug.Assert(v == "value");
this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo));
this.RenderTechnic.AddPostEffect(new BlackWhitePostEffect());
}
internal void FireEvent(GraphicInfo gi)
{
if (OnGraphicInfoChange != null)
{
OnGraphicInfoChange(gi, null);
}
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory ,IContentManager contentManager)
{
///cast to out world instance
PhysxPhysicWorld PhysxPhysicWorld = World.PhysicWorld as PhysxPhysicWorld;
base.LoadContent(GraphicInfo, factory, contentManager);
{
SimpleModel simpleModel = new SimpleModel(factory, "Model//cenario");
///Physic Triangle mesh (same as bepu)
PhysxTriangleMesh tmesh = new PhysxTriangleMesh(PhysxPhysicWorld,simpleModel,
Matrix.Identity, Vector3.One);
ForwardXNABasicShader shader = new ForwardXNABasicShader(ForwardXNABasicShaderDescription.Default());
ForwardMaterial fmaterial = new ForwardMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
///Ball Throw !!!
BallThrowPhysx28 BallThrowBullet = new BallThrowPhysx28(this.World, GraphicFactory);
this.AttachCleanUpAble(BallThrowBullet);
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, "leonScene");
WorldLoader wl = new WorldLoader();
wl.OnCreateIObject += new CreateIObject(wl_OnCreateIObject);
wl.OnCreateILight += new CreateILight(wl_OnCreateILight);
wl.LoadWorld(factory, GraphicInfo, World, data);
//IModelo model = new SimpleModel(factory, "Model/leonScene");
//IPhysicObject po = new TriangleMeshObject(model, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
//GhostObject po = new GhostObject();
//IShader shader = new ForwardXNABasicShader();
//ForwardMaterial dm = new ForwardMaterial(shader);
//this.World.AddObject(new IObject(dm, model, po));
CameraFirstPerson cam = new CameraFirstPerson(GraphicInfo);
cam.MoveSpeed *= 5;
this.World.CameraManager.AddCamera(cam);
this.RenderTechnic.AddPostEffect(new AntiAliasingPostEffectStalker());
}
void rt_RenderBackGround(GraphicInfo ginfo,RenderHelper render)
{
Rectangle source = new Rectangle(0, 0, ginfo.Viewport.Width, ginfo.Viewport.Height);
render.RenderBegin(Matrix.Identity, null, SpriteSortMode.Deferred, SamplerState.LinearWrap, BlendState.Opaque, RasterizerState.CullNone,DepthStencilState.Default);
render.RenderTexture(tile, Vector2.Zero, source, Color.White, 0, Vector2.Zero, 1.0f, SpriteEffects.None, 1.0f);
render.RenderEnd();
}
protected override void InitScreen(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.EngineStuff engine)
{
base.InitScreen(GraphicInfo, engine);
CPUSphericalBillboardComponent = new CPUSphericalBillboardComponent();
engine.AddComponent(CPUSphericalBillboardComponent);
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory, IContentManager contentManager)
{
RasterizerState = new Microsoft.Xna.Framework.Graphics.RasterizerState();
RasterizerState.FillMode = FillMode.WireFrame;
BloomPostEffect = new BloomPostEffect();
BloomPostEffect.Enabled = false;
this.RenderTechnic.AddPostEffect(BloomPostEffect);
base.LoadContent(GraphicInfo, factory, contentManager);
{
SimpleModel simpleModel = new SimpleModel(factory, "Model//cena");
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
ForwardXNABasicShaderDescription ForwardXNABasicShaderDescription = ForwardXNABasicShaderDescription.Default();
ForwardXNABasicShaderDescription.EnableTexture = true;
ForwardXNABasicShaderDescription.EnableLightning = true;
ForwardXNABasicShaderDescription.DefaultLightning = true;
shader = new ForwardXNABasicShader(ForwardXNABasicShaderDescription);
ForwardMaterial fmaterial = new ForwardMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
shader.Initialize(GraphicInfo, factory, obj);
this.World.AddObject(obj);
}
{
SimpleModel simpleModel = new SimpleModel(factory, "Model//cilos");
///tem mais de um cilo neste mesh, tem q setar as texturas de todo mundo ....
Texture2D tex = factory.CreateTexture2DColor(1, 1, Color.White);
for (int i = 0; i < simpleModel.MeshNumber; i++)
{
simpleModel.SetTexture(tex, TextureType.DIFFUSE,i,0);
}
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
shader2 = new ForwardEnvironmentShader(factory.GetTextureCube("Textures//cubeMap"),1,false);
ForwardMaterial fmaterial = new ForwardMaterial(shader2);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
shader.BasicEffect.FogEnabled = true;
shader.BasicEffect.FogColor = new Vector3(0.1f, 0.1f, 0.1f); // Dark grey
shader.BasicEffect.FogStart = 30;
shader.BasicEffect.FogEnd = 1000;
shader2.EnvironmentMapEffect.FogEnabled = true;
shader2.EnvironmentMapEffect.FogColor = new Vector3(0.1f, 0.1f, 0.1f); // Dark grey
shader2.EnvironmentMapEffect.FogStart = 30;
shader2.EnvironmentMapEffect.FogEnd = 1000;
cam = new RotatingCamera(this);
this.World.CameraManager.AddCamera(cam);
}
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.CreateTexture2DColor(1,1,Color.Gray), TextureType.MULTITEX1);
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
//ForwardDualTextureShader shader = new ForwardDualTextureShader();
ForwardEnvironmentShader shader = new ForwardEnvironmentShader(factory.GetTextureCube("Textures//grassCUBE"));
ForwardMaterial fmaterial = new ForwardMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
{
SimpleModel simpleModel = new SimpleModel(factory, "Model//uzi");
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, new Vector3(100,10,10), Matrix.Identity, Vector3.One * 10, MaterialDescription.DefaultBepuMaterial());
ForwardXNABasicShader shader = new ForwardXNABasicShader(ForwardXNABasicShaderDescription.Default());
ForwardMaterial fmaterial = new ForwardMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo));
this.RenderTechnic.AddPostEffect(new BlackWhitePostEffect());
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory ,IContentManager contentManager)
{
PhysxPhysicWorld PhysxPhysicWorld = World.PhysicWorld as PhysxPhysicWorld;
base.LoadContent(GraphicInfo, factory, contentManager);
var grid = VertexGrid.CreateGrid(100, 100, 0.3f, 100, 100);
ClothModel ClothModel = new PloobsEngine.Modelo.ClothModel(factory, PhysxPhysicWorld,
new ClothMeshDescription(), grid.Points,grid.TextCoords,grid.Indices, "Textures//meiofio");
var clothDesc = new ClothDescription()
{
Friction = 0.5f,
ClothMesh = ClothModel.ClothMesh,
Flags = ClothFlag.Bending | ClothFlag.CollisionTwoway | ClothFlag.Visualization ,
Thickness = 0.2f,
WindAcceleration = new StillDesign.PhysX.MathPrimitives.Vector3(10,0,10)
};
clothDesc.MeshData.AllocatePositions<Vector3>(grid.Points.Length );
clothDesc.MeshData.AllocateIndices<int>(grid.Indices.Length );
clothDesc.MeshData.AllocateNormals<Vector3>(grid.Points.Length );
clothDesc.MeshData.MaximumVertices = grid.Points.Length ;
clothDesc.MeshData.MaximumIndices = grid.Indices.Length ;
clothDesc.MeshData.NumberOfVertices = grid.Points.Length ;
clothDesc.MeshData.NumberOfIndices = grid.Indices.Length ;
PhysxClothObject PhysxClothObject = new PloobsEngine.Physics.PhysxClothObject(clothDesc,
Matrix.CreateRotationX((float)Math.PI / 2f) * Matrix.CreateTranslation(0,10,0));
ForwardXNABasicShader ForwardXNABasicShader = new PloobsEngine.Material.ForwardXNABasicShader();
ClothMaterial ClothMaterial = new ClothMaterial(ForwardXNABasicShader);
IObject IObject = new PloobsEngine.SceneControl.IObject(ClothMaterial, ClothModel, PhysxClothObject);
World.AddObject(IObject);
///pra preender
CapsuleShapeDescription CapsuleShapeDescription = new StillDesign.PhysX.CapsuleShapeDescription();
CapsuleShapeDescription.Height = 100;
CapsuleShapeDescription.Radius = 0.15f;
CapsuleShapeDescription.LocalPosition = new StillDesign.PhysX.MathPrimitives.Vector3(0, 0.15f + 0.5f * 10, 0);
var actorDesc = new ActorDescription()
{
GlobalPose = StillDesign.PhysX.MathPrimitives.Matrix.Translation(0,-0.2f,0),
Shapes = { CapsuleShapeDescription }
};
var actor = PhysxPhysicWorld.Scene.CreateActor(actorDesc);
PhysxClothObject.Cloth.AttachToShape(actor.Shapes.First(), (ClothAttachmentFlag)0);
BallThrowPhysx28 BallThrowBullet = new BallThrowPhysx28(this.World, GraphicFactory);
this.AttachCleanUpAble(BallThrowBullet);
this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo));
}
protected override void InitScreen(GraphicInfo GraphicInfo, EngineStuff engine)
{
engine.IsMouseVisible = true;
Primitive2DDraw = new Primitive2DDraw();
engine.AddComponent(Primitive2DDraw);
base.InitScreen(GraphicInfo, engine);
}
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());
}
/// <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);
{
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);
ForwardTreeShader ts = new ForwardTreeShader();
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 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);
{
///Uncoment to add your model
SimpleModel simpleModel = new SimpleModel(factory, "Model/cenario");
///Physic info (position, rotation and scale are set here)
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
///Forward Shader (look at this shader construction for more info)
ForwardXNABasicShader shader = new ForwardXNABasicShader();
///Deferred material
ForwardMaterial fmaterial = new ForwardMaterial(shader);
///The object itself
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
///Add to the world
this.World.AddObject(obj);
}
{
SnowParticleSystem snow = new SnowParticleSystem();
DPFSParticleSystem ps = new DPFSParticleSystem("snow", snow);
this.World.ParticleManager.AddAndInitializeParticleSystem(ps);
///cant set emiter position before adding the particle
///IF YOU DO SO, IT WILL NOT WORK
snow.Emitter.PositionData.Position = new Vector3(500, 0, 0);
}
CameraFirstPerson cam = new CameraFirstPerson(MathHelper.ToRadians(-50), MathHelper.ToRadians(-10), new Vector3(-150, 150, 150), GraphicInfo);
this.World.CameraManager.AddCamera(cam);
}
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());
ForwardXNABasicShader shader = new ForwardXNABasicShader(ForwardXNABasicShaderDescription.Default());
ForwardMaterial fmaterial = new ForwardMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
var newCameraFirstPerson = new CameraStatic(new Vector3(100,100,100), - new Vector3(100,100,100) );
this.World.CameraManager.AddCamera(newCameraFirstPerson);
SimpleConcreteGestureInputPlayable SimpleConcreteGestureInputPlayable = new SimpleConcreteGestureInputPlayable(Microsoft.Xna.Framework.Input.Touch.GestureType.DoubleTap, (sample) => doubleTapCount++);
this.BindInput(SimpleConcreteGestureInputPlayable);
this.BindInput(new SimpleConcreteGestureInputPlayable(Microsoft.Xna.Framework.Input.Touch.GestureType.Hold,
(sample) =>
{
this.RemoveInputBinding(SimpleConcreteGestureInputPlayable);
doubleTapDisabled = true;
}
));
}
public void PreDrawScene(GameTime gameTime, IWorld world, RenderHelper render, GraphicInfo ginfo,List<IObject> objs)
{
foreach (IObject item in objs)
{
item.Material.PreDrawnPhase(gameTime,world, item,world.CameraManager.ActiveCamera, world.Lights, render);
}
}
/// <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);
///Uncoment to add your model
SimpleModel simpleModel = new SimpleModel(factory, "Model/cenario");
///Physic info (position, rotation and scale are set here)
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
///Forward Shader (look at this shader construction for more info)
ForwardXNABasicShader shader = new ForwardXNABasicShader();
///Forward material
ForwardMaterial fmaterial = new ForwardMaterial(shader);
///The object itself
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
///Add to the world
this.World.AddObject(obj);
this.RenderTechnic.AddPostEffect(MotionBlurPostEffect);
this.RenderTechnic.AddPostEffect(BloomPostEffect);
BloomPostEffect.Enabled = false;
MotionBlurPostEffect.Enabled = false;
blurdefault = MotionBlurPostEffect.Amount;
RotatingCamera cam = new RotatingCamera(this, new Vector3(0,-100,-400));
this.World.CameraManager.AddCamera(cam);
RasterizerState = new RasterizerState();
RasterizerState.CullMode = CullMode.None;
}
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());
ForwardXNABasicShader shader = new ForwardXNABasicShader(ForwardXNABasicShaderDescription.Default());
ForwardMaterial fmaterial = new ForwardMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
SimpleModel simpleModel = new SimpleModel(factory, "Model//uzi");
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, new Vector3(18 * j, 10, 8 * i), Matrix.Identity, Vector3.One * 10, MaterialDescription.DefaultBepuMaterial());
ForwardXNABasicShader shader = new ForwardXNABasicShader(ForwardXNABasicShaderDescription.Default());
ForwardMaterial fmaterial = new ForwardMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
obj.OnUpdate += new OnUpdate(obj_OnUpdate);
this.World.AddObject(obj);
}
}
this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo));
}
public override void Initialize(GraphicInfo ginfo, GraphicFactory factory, IObject obj)
{
effect = factory.GetBasicEffect();
base.Initialize(ginfo,factory,obj);
effect.PreferPerPixelLighting = true;
SetDescription(desc);
}
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());
ForwardXNABasicShader shader = new ForwardXNABasicShader(ForwardXNABasicShaderDescription.Default());
ForwardMaterial fmaterial = new ForwardMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
///using component
Billboard3D Billboard3D = new Billboard3D(factory.GetTexture2D("Textures\\grama1"), new Vector3(100, 20, 100), Vector2.One * 0.2f);
BillboardComponent.Billboards.Add(Billboard3D);
///using old mode (IObject billboard)
{
List<Billboard> poss = new List<Billboard>();
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
float x, y;
x = i * 10;
y = j * 10;
poss.Add(
new Billboard()
{
Position = new Vector3(x, 50 , y),
Scale = Vector2.One * 0.01f,
Enabled = true
}
);
}
}
CPUBillboardModel bm = new CPUBillboardModel(factory, "Bilbs", "..\\Content\\Textures\\tree", poss.ToArray());
ForwardAlphaTestShader cb = new ForwardAlphaTestShader(128,CompareFunction.GreaterEqual);
ForwardMaterial matfor = new ForwardMaterial(cb);
matfor.RasterizerState = RasterizerState.CullNone;
GhostObject go = new GhostObject();
IObject obj2 = new IObject(matfor, bm, go);
this.World.AddObject(obj2);
//Text Billboards
TextBillboard3D TextBillboard3D = new TextBillboard3D("TEST 123 SPHERICAL", Color.Black, new Vector3(100), 0.5f);
sBillboardComponent.Billboards.Add(TextBillboard3D);
TextBillboard3D = new TextBillboard3D("TEST 123 Cylinder", Color.Black, new Vector3(200, 50, 200), 0.5f);
cBillboardComponent.Billboards.Add(TextBillboard3D);
}
this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo));
}
internal void iInit(GraphicInfo ginfo, GraphicFactory factory)
{
this.graphicFactory = factory;
this.graphicInfo = ginfo;
isEnabled = true;
Init(ginfo,factory);
}
/// <summary>
/// Init Screen
/// </summary>
/// <param name="GraphicInfo">The graphic info.</param>
/// <param name="engine"></param>
protected override void InitScreen(GraphicInfo GraphicInfo, EngineStuff engine)
{
base.InitScreen(GraphicInfo, engine);
SkyBox skybox = new SkyBox();
engine.AddComponent(skybox);
}
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());
ForwardXNABasicShader shader = new ForwardXNABasicShader(ForwardXNABasicShaderDescription.Default());
ForwardMaterial fmaterial = new ForwardMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
{
SimpleModel simpleModel = new SimpleModel(factory, "Model//uzi");
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, new Vector3(100,10,10), Matrix.Identity, Vector3.One * 10, MaterialDescription.DefaultBepuMaterial());
ForwardXNABasicShader shader = new ForwardXNABasicShader(ForwardXNABasicShaderDescription.Default());
ForwardMaterial fmaterial = new ForwardMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo));
this.RenderTechnic.AddPostEffect(new BlackWhitePostEffect());
}
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory ,IContentManager contentManager)
{
PhysxPhysicWorld PhysxPhysicWorld = World.PhysicWorld as PhysxPhysicWorld;
base.LoadContent(GraphicInfo, factory, contentManager);
{
SimpleModel simpleModel = new SimpleModel(factory, "Model//cenario");
StillDesign.PhysX.Material material1 = PhysxPhysicWorld.CreatePhysicMaterial(
new StillDesign.PhysX.MaterialDescription()
{
Restitution = 0.3f,
DynamicFriction = 0.5f,
StaticFriction = 1,
}
);
PhysxTriangleMesh tmesh = new PhysxTriangleMesh(PhysxPhysicWorld, simpleModel,
Matrix.Identity, Vector3.One, 1, material1);
ForwardXNABasicShader shader = new ForwardXNABasicShader(ForwardXNABasicShaderDescription.Default());
ForwardMaterial fmaterial = new ForwardMaterial(shader);
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
this.World.AddObject(obj);
}
BallThrowPhysx28 BallThrowBullet = new BallThrowPhysx28(this.World, GraphicFactory);
this.AttachCleanUpAble(BallThrowBullet);
for (int i = 0; i < 10; i++)
{
StillDesign.PhysX.Material material2 = PhysxPhysicWorld.CreatePhysicMaterial(
new StillDesign.PhysX.MaterialDescription()
{
Restitution = PloobsEngine.Utils.StaticRandom.RandomBetween(0,1),
DynamicFriction = PloobsEngine.Utils.StaticRandom.RandomBetween(0, 1),
StaticFriction = PloobsEngine.Utils.StaticRandom.RandomBetween(0, 1),
RestitutionCombineMode = CombineMode.Max,
}
);
///Load a Model with a custom texture
SimpleModel sm2 = new SimpleModel(factory, "Model\\ball");
sm2.SetTexture(factory.CreateTexture2DColor(1, 1, Color.Green, false), TextureType.DIFFUSE);
ForwardXNABasicShader nd = new ForwardXNABasicShader();
IMaterial m = new ForwardMaterial(nd);
SphereShapeDescription SphereGeometry = new SphereShapeDescription(5f);
SphereGeometry.Material = material2;
PhysxPhysicObject PhysxPhysicObject = new PhysxPhysicObject(SphereGeometry,
0.5f, Matrix.CreateTranslation(new Vector3(100,100,50 * i)), Vector3.One * 5f);
IObject o = new IObject(m, sm2, PhysxPhysicObject);
this.World.AddObject(o);
}
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(GraphicInfo GraphicInfo, GraphicFactory factory, IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
RegisterDebugDrawCommand rc = new RegisterDebugDrawCommand(ddrawer);
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(rc);
dlines = new DebugLines();
ddrawer.AddShape(dlines);
Picking pick = new Picking(this,2000);
pick.OnPickedLeftButton += new OnPicked(pick_OnPickedLeftButton);
{
SimpleModel simpleModel = new SimpleModel(factory, "Model//block");
simpleModel.SetTexture(factory.CreateTexture2DColor(1, 1, Color.White), TextureType.DIFFUSE);
///Physic info (position, rotation and scale are set here)
BoxObject tmesh = new BoxObject(Vector3.Zero, 1, 1, 1, 10, new Vector3(1000, 1, 1000), Matrix.Identity, MaterialDescription.DefaultBepuMaterial());
tmesh.isMotionLess = true;
///Forward Shader (look at this shader construction for more info)
ForwardXNABasicShader shader = new ForwardXNABasicShader();
///Deferred material
ForwardMaterial fmaterial = new ForwardMaterial(shader);
///The object itself
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
///Add to the world
this.World.AddObject(obj);
}
wh = new WaypointHandler();
wh.LoadConnectedWaypoints("waypoints.xml");
start = wh.CurrentWaypointsCollection.GetWaypointsList()[0];
{
///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(start.WorldPos, Matrix.Identity, new Vector3(5));
ForwardXNABasicShader s = new ForwardXNABasicShader();
ForwardMaterial mat = new ForwardMaterial(s);
IObject obj4 = new IObject(mat, sm, pi);
this.World.AddObject(obj4);
}
///add a camera
this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo));
{
SimpleModel sm = new SimpleModel(factory, "Model\\block");
sm.SetTexture(factory.CreateTexture2DColor(1, 1, Color.Blue), TextureType.DIFFUSE);
GhostObject pi = new GhostObject(start.WorldPos, Matrix.Identity, new Vector3(5));
ForwardXNABasicShader s = new ForwardXNABasicShader();
ForwardMaterial mat = new ForwardMaterial(s);
IObject obj4 = new IObject(mat, sm, pi);
obj4.OnUpdate += new OnUpdate(obj4_OnUpdate);
this.World.AddObject(obj4);
}
}
/// <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);
{
///Create a simple object
///Geomtric Info and textures (this model automaticaly loads the texture)
SimpleModel simpleModel = new SimpleModel(factory, "model/dude");
for (int i = 0; i < simpleModel.GetTextureInformation(0).Count(); i++)
{
simpleModel.GetTextureInformation(0)[i].SetTexture(factory.CreateTexture2DColor(1, 1, Color.White), TextureType.DIFFUSE);
}
///Physic info (position, rotation and scale are set here)
GhostObject pi = new GhostObject(new Vector3(200, 10, 0), Matrix.Identity, new Vector3(4));
///Shader info (must be a deferred type)
ForwardGradativeAlphaShader shader = new ForwardGradativeAlphaShader();
///Material info (must be a deferred type also)
ForwardMaterial fmaterial = new ForwardMaterial(shader);
///The object itself
IObject obj = new IObject(fmaterial, simpleModel, pi);
///Add to the world
this.World.AddObject(obj);
}
{
///Create a simple object
///Geomtric Info and textures (this model automaticaly loads the texture)
SimpleModel simpleModel = new SimpleModel(factory, "model/dude");
//simpleModel.SetTexture(factory.CreateTexture2DColor(1,1,Color.Red), TextureType.DIFFUSE);
///Physic info (position, rotation and scale are set here)
GhostObject pi = new GhostObject(new Vector3(200, 10, 0), Matrix.Identity, new Vector3(4));
///Shader info (must be a deferred type)
ForwardEMTransparentShader shader = new ForwardEMTransparentShader("Textures/Cubemap");
///Material info (must be a deferred type also)
ForwardMaterial fmaterial = new ForwardMaterial(shader);
///The object itself
IObject obj = new IObject(fmaterial, simpleModel, pi);
///Add to the world
this.World.AddObject(obj);
}
{
SimpleModel simpleModel = new SimpleModel(factory, "model/cenario");
///Physic info (position, rotation and scale are set here)
TriangleMeshObject tmesh = new TriangleMeshObject(simpleModel, Vector3.Zero, Matrix.Identity, Vector3.One, MaterialDescription.DefaultBepuMaterial());
///Forward Shader (look at this shader construction for more info)
ForwardXNABasicShader shader = new ForwardXNABasicShader();
///Deferred material
ForwardMaterial fmaterial = new ForwardMaterial(shader);
///The object itself
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
///Add to the world
//this.World.AddObject(obj);
}
///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(GraphicInfo GraphicInfo, GraphicFactory factory, IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
RegisterDebugDrawCommand rc = new RegisterDebugDrawCommand(ddrawer);
CommandProcessor.getCommandProcessor().SendCommandAssyncronous(rc);
foreach (var item in path.Obstacles)
{
SphericalObstacle SphericalObstacle = item as SphericalObstacle;
DebugSphere s = new DebugSphere(SphericalObstacle.Center, SphericalObstacle.Radius,Color.Blue);
ddrawer.AddShape(s);
}
DebugLines dls = new DebugLines();
ddrawer.AddShape(dls);
for (int i = 0; i < path.PolyPath.pointCount - 1; i++)
{
dls.AddLine(path.PolyPath.points[i], path.PolyPath.points[i ] + Vector3.Up * 200, Color.Brown);
dls.AddLine(path.PolyPath.points[i], path.PolyPath.points[i + 1], Color.Red);
}
dls.AddLine(path.PolyPath.points[path.PolyPath.pointCount - 1], path.PolyPath.points[path.PolyPath.pointCount - 1] + Vector3.Up * 200, Color.Brown);
PlugIn = new PedestrianPlugIn(this.World, path,
(pd) =>
{
SimpleModel simpleModel = new SimpleModel(factory, "Model//block");
simpleModel.SetTexture(factory.CreateTexture2DColor(1, 1, Color.Green), TextureType.DIFFUSE);
///Physic info (position, rotation and scale are set here)
GhostObject tmesh = new GhostObject();
///Forward Shader (look at this shader construction for more info)
ForwardXNABasicShader shader = new ForwardXNABasicShader();
///Deferred material
ForwardMaterial fmaterial = new ForwardMaterial(shader);
///The object itself
IObject obj = new IObject(fmaterial, simpleModel, tmesh);
obj.IObjectAttachment.Add(new SteerAtachment(pd));
return obj;
});
PlugIn.Init();
{
SimpleModel simpleModel = new SimpleModel(factory, "Model//block");
simpleModel.SetTexture(factory.CreateTexture2DColor(1, 1, Color.White), TextureType.DIFFUSE);
///Physic info (position, rotation and scale are set here)
BoxObject tmesh = new BoxObject(Vector3.Zero, 1, 1, 1, 10, new Vector3(1000, 1, 1000), Matrix.Identity, MaterialDescription.DefaultBepuMaterial());
tmesh.isMotionLess = true;
///Forward Shader (look at this shader construction for more info)
ForwardXNABasicShader shader = new ForwardXNABasicShader();
///Deferred material
ForwardMaterial fmaterial = new ForwardMaterial(shader);
///The object itself
this.World.AddObject(new IObject(fmaterial, simpleModel, tmesh));
}
///add a camera
this.World.CameraManager.AddCamera(new CameraFirstPerson(GraphicInfo));
}
protected override void LoadContent(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.GraphicFactory factory)
{
this.GraphicInfo = GraphicInfo;
basicEffect = factory.GetBasicEffect();
basicEffect.TextureEnabled = true;
spriteBatch = factory.GetSpriteBatch();
base.LoadContent(GraphicInfo, factory);
}
internal GraphicFactory(GraphicInfo ginfo, GraphicsDevice device, IContentManager contentManager)
{
this.device = device;
this.ginfo = ginfo;
this.contentManager = contentManager;
SpriteBatch = new SpriteBatch(device);
RenderTargetPool = new RenderTargetPool(device);
texCreator = new TextureCreator(ginfo, this);
}
protected override void LoadContent(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.GraphicFactory factory)
{
this.GraphicInfo = GraphicInfo;
basicEffect = factory.GetBasicEffect();
basicEffect.TextureEnabled = true;
basicEffect.VertexColorEnabled = true;
spriteBatch = factory.GetSpriteBatch();
SpriteFont = factory.GetAsset <SpriteFont>("ConsoleFont", true);
base.LoadContent(GraphicInfo, factory);
}
protected override void InitScreen(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.EngineStuff engine)
{
base.InitScreen(GraphicInfo, engine);
engine.AddComponent(new FPSCounter());
///IF the component already exist, it wont be added, the safest way is to get if from here
FPSCounter fpsCounter = engine.GetComponent <FPSCounter>("FPSCounter");
fpsCounter.DrawFps += new FpsEvent(fpsCounter_DrawFps);
}
protected override void LoadContent(PloobsEngine.Engine.GraphicInfo GraphicInfo, PloobsEngine.Engine.GraphicFactory factory, IContentManager contentManager)
{
base.LoadContent(GraphicInfo, factory, contentManager);
#region Models
createobjs();
///Some Physic World Parameters
///No accuracy (speed up the simulation) and no gravity
BepuPhysicWorld physicWorld = this.World.PhysicWorld as BepuPhysicWorld;
physicWorld.Space.Solver.IterationLimit = 1; //Essentially no sustained contacts, so don't need to worry about accuracy.
{
SimpleModel sm = new SimpleModel(factory, "..\\Content\\Model\\cubo");
sm.SetTexture(factory.CreateTexture2DColor(1, 1, Color.Blue), TextureType.DIFFUSE);
MaterialDescription md = MaterialDescription.DefaultBepuMaterial();
md.Bounciness = 1;
BoxObject pi = new BoxObject(new Vector3(0, -30, 0), 1, 1, 1, 1, new Vector3(50, 1, 50), Matrix.Identity, md);
pi.isMotionLess = true;
pi.Entity.AngularDamping = 0f;
ForwardXNABasicShader shader = new ForwardXNABasicShader();
IMaterial mat = new ForwardMaterial(shader);
IObject obj5 = new IObject(mat, sm, pi);
this.World.AddObject(obj5);
shader.BasicEffect.EnableDefaultLighting();
}
#endregion
cam = new RotatingCamera(this);
this.World.CameraManager.AddCamera(cam);
}
