public void Setup()
{
_defaultWorld = new DefaultWorld(EntityCount);
_defaultEntitySet = _defaultWorld.GetEntities().With <DefaultComponent>().AsSet();
_defaultRunner = new DefaultParallelRunner(Environment.ProcessorCount);
_defaultSystem = new DefaultEcsSystem(_defaultWorld);
_defaultMultiSystem = new DefaultEcsSystem(_defaultWorld, _defaultRunner);
_defaultEntityComponentSystem = new DefaultEcsEntityComponentSystem(_defaultWorld);
_defaultMultiEntityComponentSystem = new DefaultEcsEntityComponentSystem(_defaultWorld, _defaultRunner);
_defaultComponentSystem = new DefaultEcsComponentSystem(_defaultWorld);
_defaultComponentMultiSystem = new DefaultEcsComponentSystem(_defaultWorld, _defaultRunner);
_entitasWorld = new Context <EntitasEntity>(1, () => new EntitasEntity());
_entitasSystem = new EntitasSystem(_entitasWorld);
_entitasMultiSystem = new EntitasSystem(_entitasWorld, Environment.ProcessorCount);
for (int i = 0; i < EntityCount; ++i)
{
DefaultEntity defaultEntity = _defaultWorld.CreateEntity();
defaultEntity.Set <DefaultComponent>();
EntitasEntity entitasEntity = _entitasWorld.CreateEntity();
entitasEntity.AddComponent(0, new EntitasComponent());
}
}
public void Update_with_runner_Should_call_update()
{
using DefaultParallelRunner runner = new DefaultParallelRunner(2);
using World world = new World(3);
Entity entity1 = world.CreateEntity();
entity1.Set <bool>();
Entity entity2 = world.CreateEntity();
entity2.Set <bool>();
Entity entity3 = world.CreateEntity();
entity3.Set <bool>();
using (ISystem <int> system = new System(world, runner))
{
system.Update(0);
}
Check.That(entity1.Get <bool>()).IsTrue();
Check.That(entity2.Get <bool>()).IsTrue();
Check.That(entity3.Get <bool>()).IsTrue();
}
public void Optimize_Should_throw_When_action_is_null()
{
using World world = new World();
using DefaultParallelRunner runner = new DefaultParallelRunner(Environment.ProcessorCount);
Check.ThatCode(() => world.Optimize(runner, null)).Throws <ArgumentNullException>();
}
private void InitializeSystems(World world, out ISystem <float> systems)
{
var _runner = new DefaultParallelRunner(Environment.ProcessorCount);
systems = new SequentialSystem <float>(
new CounterSystem(world),
new TimerSystem(world),
new GenerationSystem(world, _cellPool, _gameState),
new SelectSystem(world, _game.Window, _gameState),
new SwapSystem(world),
new CancelSwapSystem(world),
new SwapFinishedSystem(world),
new FindMatchesSystem(world, _gameState),
new CombinationSystem(world, _gameState),
new DestroyersSystem(world, _gameState),
new LineBonusSystem(world),
new BombSystem(world),
new FallSystem(world, _gameState),
new TargetPositionSystem(world),
new WaitFallingSystem(world, _gameState),
new RotationSystem(world),
new TransformSystem(world, _runner),
new FrameAnimationUpdateSystem(world),
new SpriteRenderSystem(_batch, _backgroundLayer),
new FrameAnimationDrawSystem(_batch, world),
new SpriteRenderSystem(_batch, _cellsLayer),
new SpriteRenderSystem(_batch, _destroyersLayer),
new SpriteRenderSystem(_batch, _borderLayer),
new TextRenderSystem(_batch, world),
new DestroyersDyingSystem(world),
new DyingSystem(world, _gameState),
new DelayedDyingSystem(world)
);
}
public DefaultGame()
{
_deviceManager = new GraphicsDeviceManager(this);
IsFixedTimeStep = false;
_deviceManager.GraphicsProfile = GraphicsProfile.HiDef;
_deviceManager.IsFullScreen = true;
_deviceManager.PreferredBackBufferWidth = ResolutionWidth;
_deviceManager.PreferredBackBufferHeight = ResolutionHeight;
_deviceManager.SynchronizeWithVerticalRetrace = false;
_deviceManager.ApplyChanges();
GraphicsDevice.RasterizerState = RasterizerState.CullCounterClockwise;
GraphicsDevice.BlendState = BlendState.AlphaBlend;
Content.RootDirectory = "Content";
_batch = new SpriteBatch(GraphicsDevice);
using (Stream stream = File.OpenRead(@"Content\square.png"))
{
_square = Texture2D.FromStream(GraphicsDevice, stream);
}
_font = Content.Load <SpriteFont>("font");
_world = new World();
Grid grid = new Grid();
_runner = new DefaultParallelRunner(Environment.ProcessorCount);
_system = new SequentialSystem <float>(
new BoidsSystem(_world, _runner, grid),
new MoveSystem(_world, _runner, grid));
_drawSystem = new DrawSystem(_batch, _square, _world, _runner);
Random random = new Random();
for (int i = 0; i < BoidsCount; ++i)
{
Entity entity = _world.CreateEntity();
entity.Set(new DrawInfo
{
Color = new Color((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble(), 1f),
Position = new Vector2((float)random.NextDouble() * _deviceManager.PreferredBackBufferWidth, (float)random.NextDouble() * _deviceManager.PreferredBackBufferHeight),
Size = new Vector2(random.Next(3, 6), random.Next(10, 15)),
});
Vector2 velocity = new Vector2((float)random.NextDouble() - .5f, (float)random.NextDouble() - .5f);
if (velocity != Vector2.Zero)
{
velocity.Normalize();
}
entity.Set(new Velocity {
Value = velocity * (MinVelocity + ((float)random.NextDouble() * (MaxVelocity - MinVelocity)))
});
entity.Set <Acceleration>();
entity.Set(grid);
}
_watch = Stopwatch.StartNew();
}
private void InitializeSystems(World world, out ISystem <float> systems)
{
var _runner = new DefaultParallelRunner(Environment.ProcessorCount);
systems = new SequentialSystem <float>(
new SpriteRenderSystem(_batch, world.GetEntities().With <SpriteRenderer>().AsSet()),
new TransformSystem(world, _runner),
new ButtonSystem(world, _game.Window)
);
}
public void Setup()
{
_defaultWorld = new DefaultWorld(EntityCount);
_defaultEntitySet = _defaultWorld.GetEntities().With <DefaultComponent>().AsSet();
_defaultRunner = new DefaultParallelRunner(Environment.ProcessorCount);
_defaultSystem = new DefaultEcsSystem(_defaultWorld);
_defaultMultiSystem = new DefaultEcsSystem(_defaultWorld, _defaultRunner);
_defaultEntityComponentSystem = new DefaultEcsEntityComponentSystem(_defaultWorld);
_defaultMultiEntityComponentSystem = new DefaultEcsEntityComponentSystem(_defaultWorld, _defaultRunner);
_defaultComponentSystem = new DefaultEcsComponentSystem(_defaultWorld);
_defaultComponentMultiSystem = new DefaultEcsComponentSystem(_defaultWorld, _defaultRunner);
_defaultGeneratorSystem = new DefaultEcsGeneratorSystem(_defaultWorld);
_defaultGeneratorMultiSystem = new DefaultEcsGeneratorSystem(_defaultWorld, _defaultRunner);
_entitasWorld = new Context <EntitasEntity>(1, () => new EntitasEntity());
_entitasSystem = new EntitasSystem(_entitasWorld);
_entitasMultiSystem = new EntitasSystem(_entitasWorld, Environment.ProcessorCount);
_monoWorld = new WorldBuilder().AddSystem(new MonoSystem()).Build();
_time = new GameTime();
_leoWorld = new LeoWorld();
_leoSystem = new LeoSystem();
_leoSystems = new LeoSystems(_leoWorld).Add(_leoSystem);
_leoSystems.ProcessInjects().Init();
SimpleEntitiesSubmissionScheduler sveltoScheduler = new SimpleEntitiesSubmissionScheduler();
_sveltoWorld = new EnginesRoot(sveltoScheduler);
_sveltoSystem = new SveltoSystem();
_sveltoWorld.AddEngine(_sveltoSystem);
IEntityFactory sveltoFactory = _sveltoWorld.GenerateEntityFactory();
for (int i = 0; i < EntityCount; ++i)
{
DefaultEntity defaultEntity = _defaultWorld.CreateEntity();
defaultEntity.Set <DefaultComponent>();
EntitasEntity entitasEntity = _entitasWorld.CreateEntity();
entitasEntity.AddComponent(0, new EntitasComponent());
MonoEntity monoEntity = _monoWorld.CreateEntity();
monoEntity.Attach(new MonoComponent());
LeoEntity leoEntity = _leoWorld.NewEntity();
leoEntity.Get <LeoComponent>();
sveltoFactory.BuildEntity <SveltoEntity>((uint)i, _sveltoGroup);
}
sveltoScheduler.SubmitEntities();
}
public void Setup()
{
_defaultWorld = new World(EntityCount);
_defaultEntitySet = _defaultWorld.GetEntities().With <DefaultComponent>().AsSet();
_defaultRunner = new DefaultParallelRunner(Environment.ProcessorCount);
_defaultSystem = new DefaultEcsSystem(_defaultWorld);
_defaultMultiSystem = new DefaultEcsSystem(_defaultWorld, _defaultRunner);
_defaultEntityComponentSystem = new DefaultEcsEntityComponentSystem(_defaultWorld);
_defaultMultiEntityComponentSystem = new DefaultEcsEntityComponentSystem(_defaultWorld, _defaultRunner);
_defaultComponentSystem = new DefaultEcsComponentSystem(_defaultWorld);
_defaultComponentMultiSystem = new DefaultEcsComponentSystem(_defaultWorld, _defaultRunner);
_defaultGeneratorSystem = new DefaultEcsGeneratorSystem(_defaultWorld);
_defaultGeneratorMultiSystem = new DefaultEcsGeneratorSystem(_defaultWorld, _defaultRunner);
for (int i = 0; i < EntityCount; ++i)
{
Entity defaultEntity = _defaultWorld.CreateEntity();
defaultEntity.Set <DefaultComponent>();
}
}
public DefaultGame()
{
_deviceManager = new GraphicsDeviceManager(this);
IsFixedTimeStep = true;
_deviceManager.GraphicsProfile = GraphicsProfile.HiDef;
_deviceManager.IsFullScreen = false;
_deviceManager.PreferredBackBufferWidth = 800;
_deviceManager.PreferredBackBufferHeight = 600;
_deviceManager.ApplyChanges();
GraphicsDevice.RasterizerState = RasterizerState.CullCounterClockwise;
GraphicsDevice.BlendState = BlendState.AlphaBlend;
Content.RootDirectory = "Content";
_batch = new SpriteBatch(GraphicsDevice);
using (Stream stream = File.OpenRead(@"Content\square.png"))
{
_square = Texture2D.FromStream(GraphicsDevice, stream);
}
_breakSound = Content.Load <SoundEffect>("Slap");
_bounceSound = Content.Load <SoundEffect>("Jump");
_world = new World(1000);
_runner = new DefaultParallelRunner(Environment.ProcessorCount);
_system = new SequentialSystem <float>(
new GameSystem(_world),
new PlayerSystem(_world, Window),
new BallToBarSystem(_world, Window),
new VelocitySystem(_world, _runner),
new CollisionSystem(_world),
new BallBoundSystem(_world),
new PositionSystem(_world, _runner),
new DrawSystem(_batch, _square, _world));
_world.Subscribe <BrickBrokenMessage>(On);
_world.Subscribe <BarBounceMessage>(On);
Level1.CreatePlayer(_world);
}
public void Optimize_Should_return_When_mainAction_is_done()
{
using World world = new World();
using EntitySet set = world.GetEntities().With <int>().AsSet();
using DefaultParallelRunner runner = new DefaultParallelRunner(Environment.ProcessorCount);
List <Entity> entities = Enumerable.Repeat(world, 100000).Select(w => w.CreateEntity()).ToList();
int value = entities.Count;
foreach (Entity entity in entities.AsEnumerable().Reverse())
{
entity.Set(value--);
}
Check.That(set.GetEntities().ToArray()).ContainsExactly(entities.AsEnumerable().Reverse());
Check.That(world.Get <int>().ToArray()).ContainsExactly(Enumerable.Range(1, entities.Count).Reverse());
world.Optimize(runner, () => Thread.Sleep(1));
Check.That(set.GetEntities().ToArray().Select((e, i) => (i, e)).Any(t => entities[t.i] != t.e)).IsTrue();
Check.That(world.Get <int>().ToArray().Select((v, i) => (i, v)).Any(t => t.i != t.v)).IsTrue();
}
public void Update_with_runner_Should_call_update_on_all_systems()
{
bool done1 = false;
bool done2 = false;
bool done3 = false;
bool done4 = false;
using (DefaultParallelRunner runner = new DefaultParallelRunner(2))
using (ISystem <int> system = new ParallelSystem <int>(
runner,
new ActionSystem <int>(_ => done1 = true),
new ActionSystem <int>(_ => done2 = true),
new ActionSystem <int>(_ => done3 = true),
new ActionSystem <int>(_ => done4 = true)))
{
system.Update(0);
}
Check.That(done1).IsTrue();
Check.That(done2).IsTrue();
Check.That(done3).IsTrue();
Check.That(done4).IsTrue();
}
public DefaultGame()
{
_deviceManager = new GraphicsDeviceManager(this);
IsFixedTimeStep = true;
_deviceManager.GraphicsProfile = GraphicsProfile.HiDef;
_deviceManager.IsFullScreen = false;
_deviceManager.PreferredBackBufferWidth = 800;
_deviceManager.PreferredBackBufferHeight = 600;
_deviceManager.ApplyChanges();
GraphicsDevice.RasterizerState = RasterizerState.CullCounterClockwise;
GraphicsDevice.BlendState = BlendState.AlphaBlend;
Content.RootDirectory = "Content";
_batch = new SpriteBatch(GraphicsDevice);
using (Stream stream = File.OpenRead(@"Content\square.png"))
{
_square = Texture2D.FromStream(GraphicsDevice, stream);
}
_slapSound = Content.Load <SoundEffect>("Slap");
_bounceSound = Content.Load <SoundEffect>("Jump");
_world = new World(1000);
_world.SetMaxCapacity <PlayerState>(1);
_runner = new DefaultParallelRunner(Environment.ProcessorCount);
_system = new SequentialSystem <float>(
new PlayerSystem(_world, Window),
new HitSystem(_world),
new GameSystem(_world),
new AISystem(_world, _runner),
new PositionSystem(_world, _runner),
new DrawSystem(_world, _batch, _square));
Entity player = _world.CreateEntity();
player.Set <PlayerState>(default);
private static void _client_Started()
{
var world = new World();
var commandRecorder = new EntityCommandRecorder();
var scene = new Scene("Client", world, commandRecorder);
var factory = _client.GraphicsDevice.ResourceFactory;
var materialInputLayouts = new MaterialInputLayouts();
var textureLayout = factory.CreateResourceLayout(
new ResourceLayoutDescription(
new ResourceLayoutElementDescription("SurfaceTexture", ResourceKind.TextureReadOnly, ShaderStages.Fragment),
new ResourceLayoutElementDescription("SurfaceSampler", ResourceKind.Sampler, ShaderStages.Fragment),
new ResourceLayoutElementDescription("TextureColour", ResourceKind.UniformBuffer, ShaderStages.Fragment)));
materialInputLayouts.ResourceLayouts["Texture"] = textureLayout;
materialInputLayouts.ResourceLayouts["WorldTransform"] = factory.CreateResourceLayout(
new ResourceLayoutDescription(
new ResourceLayoutElementDescription("WorldBuffer", ResourceKind.UniformBuffer, ShaderStages.Vertex)));
materialInputLayouts.ResourceLayouts["SceneInputs"] = factory.CreateResourceLayout(
new ResourceLayoutDescription(
new ResourceLayoutElementDescription("ProjectionBuffer", ResourceKind.UniformBuffer, ShaderStages.Vertex),
new ResourceLayoutElementDescription("ViewBuffer", ResourceKind.UniformBuffer, ShaderStages.Vertex),
new ResourceLayoutElementDescription("SceneLighting", ResourceKind.UniformBuffer, ShaderStages.Fragment)));
materialInputLayouts.ResourceLayouts["CameraInputs"] = factory.CreateResourceLayout(
new ResourceLayoutDescription(
new ResourceLayoutElementDescription("CameraInfo", ResourceKind.UniformBuffer, ShaderStages.Vertex)));
materialInputLayouts.VertexLayouts["Model"] = new VertexLayoutDescription(
new VertexElementDescription("Position", VertexElementSemantic.Position, VertexElementFormat.Float3),
new VertexElementDescription("TexCoords", VertexElementSemantic.TextureCoordinate, VertexElementFormat.Float2),
new VertexElementDescription("Normal", VertexElementSemantic.Normal, VertexElementFormat.Float3));
materialInputLayouts.VertexLayouts["Lighting"] = new VertexLayoutDescription(
new VertexElementDescription("Light", VertexElementSemantic.Color, VertexElementFormat.Float1));
var mesh3dMaterial = new Material(_client.GraphicsDevice, _client.MainSceneFramebuffer, _client.Resources.LoadText("Shaders\\Mesh.vs"), _client.Resources.LoadText("Shaders\\Mesh.fg"),
new string[] { "Model" }, new string[] { "SceneInputs", "WorldTransform", "Texture" }, materialInputLayouts);
var lightMeshMaterial = new Material(_client.GraphicsDevice, _client.MainSceneFramebuffer, _client.Resources.LoadText("Shaders\\LightMesh.vs"), _client.Resources.LoadText("Shaders\\LightMesh.fg"),
new string[] { "Model", "Lighting" }, new string[] { "SceneInputs", "WorldTransform", "Texture", "CameraInputs" }, materialInputLayouts);
var voxelTexturesResource = _client.Resources.LoadImage("Textures\\spritesheet_tiles.png");
var voxelTexture = new MaterialTexture(_client.GraphicsDevice, textureLayout, voxelTexturesResource, RgbaFloat.White);
var redVoxelTexture = new MaterialTexture(_client.GraphicsDevice, textureLayout, voxelTexturesResource, RgbaFloat.Red);
var semiTransVoxelColour = new MaterialTexture(_client.GraphicsDevice, textureLayout, voxelTexturesResource, new RgbaFloat(1.0f, 1.0f, 1.0f, 0.8f));
Action <Entity> setVoxelRender = (Entity e) =>
{
e.Set(new LightVertexResources());
e.Set(lightMeshMaterial);
e.Set(voxelTexture);
};
var networkedEntities = new NetworkedEntities(world);
var clientSystem = new ClientSystem(world, _messageTargetMap, _clientMessagingChannel);
clientSystem.AddListener(new TransformMessageApplier(networkedEntities));
clientSystem.AddListener(new ClientEntityAssignmentApplier(networkedEntities));
clientSystem.AddListener(new VoxelSpaceMessageApplier(networkedEntities));
clientSystem.AddListener(new VoxelGridMessageApplier(setVoxelRender, networkedEntities));
clientSystem.AddListener(new VoxelGridChangeMessageApplier(networkedEntities));
clientSystem.AddListener(new EntityRemover(networkedEntities));
clientSystem.AddListener(new ComponentSyncMessageApplier <EntityMetaData>(networkedEntities));
scene.AddSystem(clientSystem);
var parallelRunner = new DefaultParallelRunner(8);
var px = Image.Load("Assets\\Textures\\cloudtop_rt.png");
var nx = Image.Load("Assets\\Textures\\cloudtop_lf.png");
var py = Image.Load("Assets\\Textures\\cloudtop_up.png");
var ny = Image.Load("Assets\\Textures\\cloudtop_dn.png");
var pz = Image.Load("Assets\\Textures\\cloudtop_bk.png");
var nz = Image.Load("Assets\\Textures\\cloudtop_ft.png");
scene.AddSystem(new SkyboxRenderer(_client.GraphicsDevice, _client.MainSceneFramebuffer, px, nx, py, ny, pz, nz));
scene.AddSystem(new MeshGeometryRenderer(_client.GraphicsDevice, materialInputLayouts, world));
scene.AddSystem(new LightMeshGeometryRenderer(_client.GraphicsDevice, materialInputLayouts, world));
var voxelTypes = LoadVoxelTypes();
var editors = new List <IEditor>()
{
new SelectedEntitySystem(world),
new EntityInspector(world),
new EntityList(world),
new SystemList(scene),
new VoxelEditor(_clientMessagingChannel, world, voxelTypes.Select((t, i) => (t.Name, new Voxel()
{
Exists = true, BlockType = (ushort)i
})).ToArray()),
new VoxelSpaceLoader(_clientMessagingChannel, world)
};
_editorMenu.AddEditorSet("Client", editors);
scene.AddSystem(_editorMenu);
scene.AddSystems(editors);
scene.AddSystem(new SunLightPropogationSystem(world, new VoxelTypes(voxelTypes)));
scene.AddSystem(new VoxelGridMesher(commandRecorder, world, new VoxelTypes(voxelTypes), _client.GraphicsDevice, parallelRunner));
scene.AddSystem(new MeshGeometryCleaner(world));
scene.AddSystem(new LightVertexCleaner(world));
scene.AddSystem(new TransformLerper(networkedEntities, world));
scene.AddSystem(new FlagClearingSystem <NeighbourMemberChanged>(world));
scene.AddSystem(new InputForceApplierInputSystem(_clientMessagingChannel, world));
scene.AddSystem(new SimpleCameraMoverInputSystem(_clientMessagingChannel, world));
world.SubscribeEntityDisposed((in Entity e) =>
{
if (e.Has <VoxelGrid>())
{
var voxelGrid = e.Get <VoxelGrid>();
voxelGrid.VoxelSpace.Remove(voxelGrid.MemberIndex);
}
});
private static void _server_Started()
{
var world = new World();
var commandRecorder = new EntityCommandRecorder();
var scene = new Scene("Server", world, commandRecorder);
var networkedEntities = new NetworkedEntities(world);
var physicsSystem = new PhysicsSystem();
var editors = new List <IEditor>()
{
//new EditorConsole(_client.Scene),
new SelectedEntitySystem(world),
new EntityInspector(world),
new EntityList(world),
new SystemList(scene),
new AverageMetricValue(),
new MetricGraph()
};
_editorMenu.AddEditorSet("Server", editors);
scene.AddSystems(editors);
var parallelRunner = new DefaultParallelRunner(4);
var serverSystem = new ServerSystem(world, _messageTargetMap);
serverSystem.AddListener(new TransformMessageApplier(networkedEntities));
serverSystem.AddListener(new InputForceApplier(physicsSystem, world));
serverSystem.AddListener(new SimpleCameraMover(physicsSystem, networkedEntities));
serverSystem.AddListener(new VoxelEditReceiver(physicsSystem));
serverSystem.AddListener(new VoxelSpaceLoadReciever(world));
scene.AddSystem(serverSystem);
var voxelTypes = LoadVoxelTypes();
var worldVoxelSpace = world.CreateEntity();
worldVoxelSpace.Set(new NetworkedEntity()
{
Id = Guid.NewGuid()
});
worldVoxelSpace.Set(new Transform(worldVoxelSpace));
worldVoxelSpace.Set(new VoxelSpace(32, 1, worldVoxelSpace));
worldVoxelSpace.Set(new EntityMetaData()
{
Name = "Voxel Space"
});
scene.AddSystem(new WorldSpaceLoader((e) => { }, world, worldVoxelSpace, 4, 3, 32));
scene.AddSystem(new ChunkGeneratorSystem(commandRecorder, parallelRunner, new ChunkGenerator(), world));
scene.AddSystem(new VoxelSpaceExpanderSystem((e) => { }, world));
scene.AddSystem(new PhysicsBlockFinder(world, parallelRunner));
scene.AddSystem(new VoxelSpaceChangePropogator(world));
scene.AddSystem(new VoxelStaticBodyGenerator(physicsSystem, world));
scene.AddSystem(new VoxelSpaceDynamicBodyGenerator(physicsSystem, world));
scene.AddSystem(physicsSystem);
scene.AddSystem(new DynamicBodyPositionSync(world));
scene.AddSystem(new CharacterInputSystem(physicsSystem, world));
scene.AddSystem(new EntityRemovalSync(world));
scene.AddSystem(new ClientEntityAssignmentSystem());
scene.AddSystem(new TransformChangeServerSystem(world));
scene.AddSystem(new VoxelSpaceAddedServerSystem(world));
scene.AddSystem(new VoxelGridExistenceServerSystem(world));
scene.AddSystem(new VoxelGridChangeServerSystem(world));
scene.AddSystem(new ComponentSyncServerSystem <EntityMetaData>(world));
scene.AddSystem(new FlagClearingSystem <NeighbourMemberChanged>(world));
_server.SetScene(scene);
}
protected override void Initialize()
{
var factory = GraphicsDevice.ResourceFactory;
var materialInputLayouts = new MaterialInputLayouts();
var textureLayout = factory.CreateResourceLayout(
new ResourceLayoutDescription(
new ResourceLayoutElementDescription("SurfaceTexture", ResourceKind.TextureReadOnly, ShaderStages.Fragment),
new ResourceLayoutElementDescription("SurfaceSampler", ResourceKind.Sampler, ShaderStages.Fragment),
new ResourceLayoutElementDescription("TextureColour", ResourceKind.UniformBuffer, ShaderStages.Fragment)));
materialInputLayouts.ResourceLayouts["Texture"] = textureLayout;
materialInputLayouts.ResourceLayouts["WorldTransform"] = factory.CreateResourceLayout(
new ResourceLayoutDescription(
new ResourceLayoutElementDescription("WorldBuffer", ResourceKind.UniformBuffer, ShaderStages.Vertex)));
materialInputLayouts.ResourceLayouts["SceneInputs"] = factory.CreateResourceLayout(
new ResourceLayoutDescription(
new ResourceLayoutElementDescription("ProjectionBuffer", ResourceKind.UniformBuffer, ShaderStages.Vertex),
new ResourceLayoutElementDescription("ViewBuffer", ResourceKind.UniformBuffer, ShaderStages.Vertex),
new ResourceLayoutElementDescription("SceneLighting", ResourceKind.UniformBuffer, ShaderStages.Fragment)));
materialInputLayouts.ResourceLayouts["CameraInputs"] = factory.CreateResourceLayout(
new ResourceLayoutDescription(
new ResourceLayoutElementDescription("CameraInfo", ResourceKind.UniformBuffer, ShaderStages.Vertex)));
materialInputLayouts.VertexLayouts["Model"] = new VertexLayoutDescription(
new VertexElementDescription("Position", VertexElementSemantic.Position, VertexElementFormat.Float3),
new VertexElementDescription("TexCoords", VertexElementSemantic.TextureCoordinate, VertexElementFormat.Float2),
new VertexElementDescription("Normal", VertexElementSemantic.Normal, VertexElementFormat.Float3));
materialInputLayouts.VertexLayouts["Lighting"] = new VertexLayoutDescription(
new VertexElementDescription("Light", VertexElementSemantic.Color, VertexElementFormat.Float1));
var mesh3dMaterial = new Material(GraphicsDevice, MainSceneFramebuffer, Resources.LoadText("Shaders\\Mesh.vs"), Resources.LoadText("Shaders\\Mesh.fg"),
new string[] { "Model" }, new string[] { "SceneInputs", "WorldTransform", "Texture" }, materialInputLayouts);
var lightMeshMaterial = new Material(GraphicsDevice, MainSceneFramebuffer, Resources.LoadText("Shaders\\LightMesh.vs"), Resources.LoadText("Shaders\\LightMesh.fg"),
new string[] { "Model", "Lighting" }, new string[] { "SceneInputs", "WorldTransform", "Texture", "CameraInputs" }, materialInputLayouts);
var voxelTexturesResource = Resources.LoadImage("Textures\\spritesheet_tiles.png");
var voxelTexture = new MaterialTexture(GraphicsDevice, textureLayout, voxelTexturesResource, RgbaFloat.White);
var redVoxelTexture = new MaterialTexture(GraphicsDevice, textureLayout, voxelTexturesResource, RgbaFloat.Red);
var semiTransVoxelColour = new MaterialTexture(GraphicsDevice, textureLayout, voxelTexturesResource, new RgbaFloat(1.0f, 1.0f, 1.0f, 0.8f));
Action <Entity> setVoxelRender = (Entity e) =>
{
e.Set(lightMeshMaterial);
e.Set(voxelTexture);
};
var parallelRunner = new DefaultParallelRunner(4);
var player = Scene.World.CreateEntity();
var playerTransform = new Transform();
playerTransform.Position = new Vector3(0, 40, 0);
player.Set(playerTransform);
player.Set(new Camera());
var worldVoxelSpace = Scene.World.CreateEntity();
worldVoxelSpace.Set(new Transform());
worldVoxelSpace.Set(new VoxelSpace(32, 1, worldVoxelSpace));
var px = Image.Load("Assets\\Textures\\cloudtop_rt.png");
var nx = Image.Load("Assets\\Textures\\cloudtop_lf.png");
var py = Image.Load("Assets\\Textures\\cloudtop_up.png");
var ny = Image.Load("Assets\\Textures\\cloudtop_dn.png");
var pz = Image.Load("Assets\\Textures\\cloudtop_bk.png");
var nz = Image.Load("Assets\\Textures\\cloudtop_ft.png");
Scene.RendererSystems.Add(new SkyboxRenderer(GraphicsDevice, MainSceneFramebuffer, px, nx, py, ny, pz, nz));
Scene.RendererSystems.Add(new MeshGeometryRenderer(GraphicsDevice, materialInputLayouts, Scene.World));
Scene.RendererSystems.Add(new LightMeshGeometryRenderer(GraphicsDevice, materialInputLayouts, Scene.World));
var physicsSystem = new PhysicsSystem();
var voxelTypes = LoadVoxelTypes();
var tools = new List <ITool>()
{
new RemoveVoxelEditingTool((e) => { e.Set(lightMeshMaterial); e.Set(redVoxelTexture); }, Scene.World, physicsSystem, player)
};
tools.AddRange(voxelTypes.Select((type, i) => new BasicVoxelAddingTool(type.Name, (ushort)i, (e) => { e.Set(lightMeshMaterial); e.Set(semiTransVoxelColour); }, Scene.World, physicsSystem, player)));
Scene.LogicSystems.Add(new EditorMenu(Scene, new List <IEditor>()
{
new EditorConsole(Scene),
new Toolbar(tools.ToArray()),
new SelectedEntitySystem(Scene.World),
new PhysicsEntitySelector(Scene.World, physicsSystem, playerTransform),
new EntityInspector(Scene.World),
new EntityList(Scene.World),
new SystemList(Scene),
new VoxelSpaceLoader(Scene.World, playerTransform, setVoxelRender)
}));
Scene.LogicSystems.Add(new SimpleCameraMover(player, physicsSystem, Scene.World));
Scene.LogicSystems.Add(new WorldSpaceLoader(setVoxelRender, Scene.World, playerTransform, worldVoxelSpace, 10, 3, 32));
Scene.LogicSystems.Add(new ChunkGeneratorSystem(Scene, parallelRunner, new ChunkGenerator()));
Scene.LogicSystems.Add(new VoxelSpaceExpanderSystem(setVoxelRender, Scene.World));
Scene.LogicSystems.Add(new InputForceApplier(physicsSystem, Scene.World));
Scene.LogicSystems.Add(new PhysicsBlockFinder(Scene.World, parallelRunner));
Scene.LogicSystems.Add(new ParallelSystem <double>(parallelRunner,
new SequentialSystem <double>(
new VoxelSpaceChangePropogator(Scene.World),
new VoxelStaticBodyGenerator(physicsSystem, Scene.World),
new VoxelSpaceDynamicBodyGenerator(physicsSystem, Scene.World),
physicsSystem,
new DynamicBodyPositionSync(Scene.World)),
new SunLightPropogationSystem(new VoxelTypes(voxelTypes), Scene)));
Scene.LogicSystems.Add(new VoxelGridMesher(Scene, new VoxelTypes(voxelTypes), GraphicsDevice, parallelRunner));
Scene.LogicSystems.Add(new CharacterInputSystem(physicsSystem, Scene.World));
Scene.LogicSystems.Add(new MeshGeometryCleaner(Scene.World));
Scene.LogicSystems.Add(new LightVertexCleaner(Scene.World));
Scene.LogicSystems.Add(new FlagClearingSystem <NeighbourMemberChanged>(Scene.World));
//var cylinder = Scene.World.CreateEntity();
//AddCylinder(cylinder, mesh3dMaterial, voxelTexture);
}
