Bubel/bubel-ecs
2
0
Fork 0
Code Issues 1 Pull requests 2 Projects Releases Packages Wiki Activity Actions

Demos #10

Merged
Mergul merged 39 commits from Demos into master 2020-05-28 18:48:45 +02:00
Conversation 4 Commits 39 Files changed 62 +366 -23
6 changed files with 366 additions and 23 deletions
Download patch file Download diff file Expand all files Collapse all files
Showing only changes of commit 50715fbc40 - Show all commits

BIN
demos/assets/textures/atlas.png
View file

Binary file not shown.
Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 24 KiB

After

Width:  |  Height:  |  Size: 24 KiB

Before After
Before After

2
demos/external/sources/mmutils/thread_pool.d vendored
View file

@ -12,6 +12,8 @@ import std.algorithm : map;
version = MM_NO_LOGS; // Disable log creation version = MM_NO_LOGS; // Disable log creation
//version = MM_USE_POSIX_THREADS; // Use posix threads insted of standard library, required for betterC //version = MM_USE_POSIX_THREADS; // Use posix threads insted of standard library, required for betterC
version (Posix)version = MM_USE_POSIX_THREADS;
version (WebAssembly) version (WebAssembly)
{ {
extern(C) struct FILE extern(C) struct FILE

335
demos/source/demos/snake.d
View file

@ -17,6 +17,10 @@ import ecs_utils.gfx.texture;
import ecs_utils.math.vector; import ecs_utils.math.vector;
import ecs_utils.utils; import ecs_utils.utils;
import std.array : staticArray;
enum float px = 1.0/512.0;
extern(C): extern(C):
struct MapElement struct MapElement
@ -24,9 +28,24 @@ struct MapElement
enum Type enum Type
{ {
empty = 0, empty = 0,
snake = 1, apple = 1,
apple = 2, wall = 2,
wall = 3
snake_head_up = 5,
snake_head_down = 6,
snake_head_left = 7,
snake_head_right = 8,
snake_tail_up = 9,
snake_tail_down = 10,
snake_tail_left = 11,
snake_tail_right = 12,
snake_turn_ld = 13,
snake_turn_lu = 14,
snake_turn_rd = 15,
snake_turn_ru = 16,
snake_vertical = 17,
snake_horizontal = 18
} }
Type type; Type type;
EntityID id; EntityID id;
@ -38,8 +57,13 @@ struct Snake
EntityTemplate* apple_tmpl; EntityTemplate* apple_tmpl;
EntityTemplate* snake_tmpl; EntityTemplate* snake_tmpl;
EntityTemplate* snake_destroy_particle;
Texture texture; Texture texture;
vec4[] snake_destroy_particle_frames;
vec4[] smoke_frames;
bool move_system = true; bool move_system = true;
bool draw_system = true; bool draw_system = true;
@ -83,7 +107,6 @@ struct Snake
void drawMap() void drawMap()
{ {
const float px = 1.0/512.0;
foreach(x; 0 .. map_size) foreach(x; 0 .. map_size)
{ {
foreach(y; 0 .. map_size) foreach(y; 0 .. map_size)
@ -91,7 +114,22 @@ struct Snake
switch(element(ivec2(x,y)).type) switch(element(ivec2(x,y)).type)
{ {
case MapElement.Type.apple:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(0,32*px,16*px,16*px), 0, 0 , 0);break; case MapElement.Type.apple:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(0,32*px,16*px,16*px), 0, 0 , 0);break;
case MapElement.Type.snake:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(0,48*px,16*px,16*px), 0, 0 , 0);break;
case MapElement.Type.snake_head_up:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(48*px,112*px,16*px,16*px), 0, 0 , 0);break;
case MapElement.Type.snake_head_down:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(48*px,144*px,16*px,16*px), 0, 0 , 0);break;
case MapElement.Type.snake_head_left:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(0,128*px,16*px,16*px), 0, 0 , 0);break;
case MapElement.Type.snake_head_right:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(32*px,128*px,16*px,16*px), 0, 0 , 0);break;
case MapElement.Type.snake_tail_up:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(16*px,112*px,16*px,16*px), 0, 0 , 0);break;
case MapElement.Type.snake_tail_down:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(0,112*px,16*px,16*px), 0, 0 , 0);break;
case MapElement.Type.snake_tail_left:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(32*px,112*px,16*px,16*px), 0, 0 , 0);break;
case MapElement.Type.snake_tail_right:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(0,144*px,16*px,16*px), 0, 0 , 0);break;
case MapElement.Type.snake_turn_ld:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(64*px,128*px,16*px,16*px), 0, 0 , 0);break;
case MapElement.Type.snake_turn_lu:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(32*px,144*px,16*px,16*px), 0, 0 , 0);break;
case MapElement.Type.snake_turn_rd:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(16*px,144*px,16*px,16*px), 0, 0 , 0);break;
case MapElement.Type.snake_turn_ru:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(64*px,112*px,16*px,16*px), 0, 0 , 0);break;
case MapElement.Type.snake_vertical:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(16*px,128*px,16*px,16*px), 0, 0 , 0);break;
case MapElement.Type.snake_horizontal:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(48*px,128*px,16*px,16*px), 0, 0 , 0);break;
case MapElement.Type.wall:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(0,0,1,1), 0, 0 , 0);break; case MapElement.Type.wall:launcher.renderer.draw(texture, vec2(x*16,y*16), vec2(16,16), vec4(0,0,1,1), 0, 0 , 0);break;
default:break; default:break;
} }
@ -101,6 +139,19 @@ struct Snake
} }
struct Animation
{
}
struct CAnimation
{
mixin ECS.Component;
vec4[] frames;
float time = 0;
}
struct CILocation struct CILocation
{ {
mixin ECS.Component; mixin ECS.Component;
@ -116,7 +167,7 @@ struct CLocation
alias location this; alias location this;
vec2 location; vec2 location = vec2(0,0);
} }
struct CSnake struct CSnake
@ -176,13 +227,15 @@ struct CApple
struct CParticle struct CParticle
{ {
mixin ECS.Component; mixin ECS.Component;
float life = 0;
} }
struct CParticleVector struct CParticleVector
{ {
mixin ECS.Component; mixin ECS.Component;
vec2 velocity; vec2 velocity = vec2(0,0);
} }
struct CMovement struct CMovement
@ -226,10 +279,98 @@ struct AppleSystem
} }
} }
struct ParticleSystem
{
mixin ECS.System!1;
struct EntitiesData
{
uint length;
@readonly Entity[] entities;
@readonly CParticle[] particle;
}
void onUpdate(EntitiesData data)
{
foreach(i;0..data.length)
{
data.particle[i].life -= launcher.delta_time;
if(data.particle[i].life < 0)launcher.manager.removeEntity(data.entities[i].id);
}
}
}
struct ParticleMovementSystem
{
mixin ECS.System!1;
struct EntitiesData
{
uint length;
@readonly Entity[] entities;
@readonly CParticleVector[] movement;
CLocation[] location;
}
void onUpdate(EntitiesData data)
{
foreach(i;0..data.length)
{
data.location[i].location -= data.movement[i].velocity;
}
}
}
struct AnimationSystem
{
mixin ECS.System!1;
struct EntitiesData
{
uint length;
CAnimation[] animation;
}
void onUpdate(EntitiesData data)
{
foreach(i;0..data.length)
{
data.animation[i].time += launcher.delta_time * 0.01;
while(data.animation[i].time >= data.animation[i].frames.length)data.animation[i].time -= cast(float)data.animation[i].frames.length;
}
}
}
struct AnimationRenderSystem
{
mixin ECS.System!1;
struct EntitiesData
{
uint length;
@readonly CAnimation[] animation;
@readonly CLocation[] location;
}
void onUpdate(EntitiesData data)
{
foreach(i;0..data.length)
{
launcher.renderer.draw(snake.texture, cast(vec2)cast(ivec2)data.location[i].location, vec2(16,16), data.animation[i].frames[cast(int)(data.animation[i].time)], 0, 0 , 0);
}
}
}
struct MoveSystem struct MoveSystem
{ {
mixin ECS.System!64; mixin ECS.System!64;
EntityTemplate* destroy_template;
CLocation* destroy_location;
CParticleVector* destroy_vector;
struct EntitiesData struct EntitiesData
{ {
uint length; uint length;
@ -239,6 +380,13 @@ struct MoveSystem
CILocation[] location; CILocation[] location;
} }
void setTemplates()
{
destroy_template = snake.snake_destroy_particle;
destroy_location = destroy_template.getComponent!CLocation;
destroy_vector = destroy_template.getComponent!CParticleVector;
}
void moveLocation(ref CILocation location, CMovement.Direction direction) void moveLocation(ref CILocation location, CMovement.Direction direction)
{ {
final switch(direction) final switch(direction)
@ -276,6 +424,56 @@ struct MoveSystem
else .snake.element(MapElement(),location); else .snake.element(MapElement(),location);
} }
static CMovement.Direction getDirection(ivec2 p1, ivec2 p2)
{
if(p1.x - p2.x == -1)return CMovement.direction.right;
else if(p1.x - p2.x == 1)return CMovement.direction.left;
else if(p1.y - p2.y == -1)return CMovement.direction.up;
else if(p1.y - p2.y == 1)return CMovement.direction.down;
else if(p1.x - p2.x > 1)return CMovement.direction.right;
else if(p1.x - p2.x < -1)return CMovement.direction.left;
else if(p1.y - p2.y > 1)return CMovement.direction.up;
else return CMovement.direction.down;
}
static MapElement.Type snakePart(ivec2 p1, ivec2 p2, ivec2 p3)
{
CMovement.Direction direction = getDirection(p1, p2);
CMovement.Direction direction2 = getDirection(p1, p3);
uint case_ = direction*4 + direction2;
final switch(case_)
{
case 0:return MapElement.Type.snake_horizontal;
case 1:return MapElement.Type.snake_horizontal;
case 2:return MapElement.Type.snake_turn_lu;
case 3:return MapElement.Type.snake_turn_ru;
case 4:return MapElement.Type.snake_horizontal;
case 5:return MapElement.Type.snake_horizontal;
case 6:return MapElement.Type.snake_turn_ld;
case 7:return MapElement.Type.snake_turn_rd;
case 8:return MapElement.Type.snake_turn_lu;
case 9:return MapElement.Type.snake_turn_ld;
case 10:return MapElement.Type.snake_vertical;
case 11:return MapElement.Type.snake_vertical;
case 12:return MapElement.Type.snake_turn_ru;
case 13:return MapElement.Type.snake_turn_rd;
case 14:return MapElement.Type.snake_vertical;
case 15:return MapElement.Type.snake_vertical;
}
}
static MapElement.Type snakeTail(ivec2 p1, ivec2 p2)
{
CMovement.Direction direction = getDirection(p1, p2);
final switch(direction)
{
case CMovement.Direction.up:return MapElement.Type.snake_tail_up;
case CMovement.Direction.down:return MapElement.Type.snake_tail_down;
case CMovement.Direction.left:return MapElement.Type.snake_tail_left;
case CMovement.Direction.right:return MapElement.Type.snake_tail_right;
}
}
void onUpdate(EntitiesData data) void onUpdate(EntitiesData data)
{ {
if(data.snakes) if(data.snakes)
@ -286,21 +484,104 @@ struct MoveSystem
moveLocation(data.location[i], data.movement[i].direction); moveLocation(data.location[i], data.movement[i].direction);
final switch(snake.element(data.location[i].location).type) final switch(snake.element(data.location[i].location).type)
{ {
case MapElement.Type.snake: case MapElement.Type.snake_head_up:goto case(MapElement.Type.snake_horizontal);
launcher.manager.removeEntity(data.entities[i].id); case MapElement.Type.snake_head_down:goto case(MapElement.Type.snake_horizontal);
break; case MapElement.Type.snake_head_left:goto case(MapElement.Type.snake_horizontal);
case MapElement.Type.wall: case MapElement.Type.snake_head_right:goto case(MapElement.Type.snake_horizontal);
case MapElement.Type.snake_tail_up:goto case(MapElement.Type.snake_horizontal);
case MapElement.Type.snake_tail_down:goto case(MapElement.Type.snake_horizontal);
case MapElement.Type.snake_tail_left:goto case(MapElement.Type.snake_horizontal);
case MapElement.Type.snake_tail_right:goto case(MapElement.Type.snake_horizontal);
case MapElement.Type.snake_turn_ld:goto case(MapElement.Type.snake_horizontal);
case MapElement.Type.snake_turn_lu:goto case(MapElement.Type.snake_horizontal);
case MapElement.Type.snake_turn_rd:goto case(MapElement.Type.snake_horizontal);
case MapElement.Type.snake_turn_ru:goto case(MapElement.Type.snake_horizontal);
case MapElement.Type.snake_vertical:goto case(MapElement.Type.snake_horizontal);
case MapElement.Type.snake_horizontal:
foreach(ivec2 loc; data.snakes[i].parts)
{
destroy_location.x = loc.x * 16;
destroy_location.y = loc.y * 16;
snake.element(MapElement(MapElement.Type.empty, EntityID()),loc);
launcher.manager.addEntity(snake.snake_destroy_particle);
foreach(j;0..10)
{
destroy_location.x = loc.x * 16 + randomf() * 8 - 4;
destroy_location.y = loc.y * 16 + randomf() * 8 - 4;
destroy_vector.velocity = vec2(randomf(),randomf())*0.4-0.2;
snake.element(MapElement(MapElement.Type.empty, EntityID()),loc);
launcher.manager.addEntity(snake.snake_destroy_particle);
}
}
destroy_location.x = new_location.x * 16;
destroy_location.y = new_location.y * 16;
snake.element(MapElement(MapElement.Type.empty, EntityID()),new_location);
launcher.manager.addEntity(snake.snake_destroy_particle);
launcher.manager.removeEntity(data.entities[i].id); launcher.manager.removeEntity(data.entities[i].id);
break; break;
case MapElement.Type.wall:break;
//launcher.manager.removeEntity(data.entities[i].id);
//break;
case MapElement.Type.empty: case MapElement.Type.empty:
moveSnake(data.snakes[i], new_location); moveSnake(data.snakes[i], new_location);
snake.element(MapElement(MapElement.Type.snake, data.entities[i].id),data.location[i].location); final switch(data.movement[i].direction)
{
case CMovement.Direction.up:
snake.element(MapElement(MapElement.Type.snake_head_up, data.entities[i].id),data.location[i].location);
break;
case CMovement.Direction.right:
snake.element(MapElement(MapElement.Type.snake_head_right, data.entities[i].id),data.location[i].location);
break;
case CMovement.Direction.down:
snake.element(MapElement(MapElement.Type.snake_head_down, data.entities[i].id),data.location[i].location);
break;
case CMovement.Direction.left:
snake.element(MapElement(MapElement.Type.snake_head_left, data.entities[i].id),data.location[i].location);
break;
}
if(data.snakes[i].parts.length > 1)
{
MapElement.Type elem_type = snakePart(data.snakes[i].parts[$-1],data.location[i],data.snakes[i].parts[$-2]);
snake.element(MapElement(elem_type, data.entities[i].id),data.snakes[i].parts[$-1]);
elem_type = snakeTail(data.snakes[i].parts[1], data.snakes[i].parts[0]);
snake.element(MapElement(elem_type, data.entities[i].id),data.snakes[i].parts[0]);
}
else if(data.snakes[i].parts.length == 1)
{
MapElement.Type elem_type = snakeTail(data.location[i], data.snakes[i].parts[0]);
snake.element(MapElement(elem_type, data.entities[i].id),data.snakes[i].parts[0]);
}
break; break;
case MapElement.Type.apple: case MapElement.Type.apple:
launcher.manager.removeEntity(snake.element(data.location[i].location).id); launcher.manager.removeEntity(snake.element(data.location[i].location).id);
data.snakes[i].parts.add(new_location); if(data.snakes[i].parts.length < 100)data.snakes[i].parts.add(new_location);
snake.element(MapElement(MapElement.Type.snake, data.entities[i].id),new_location);
snake.element(MapElement(MapElement.Type.snake, data.entities[i].id),data.location[i].location); if(data.snakes[i].parts.length > 1)
{
MapElement.Type elem_type = snakePart(data.snakes[i].parts[$-1],data.location[i],data.snakes[i].parts[$-2]);
snake.element(MapElement(elem_type, data.entities[i].id),data.snakes[i].parts[$-1]);
}
else if(data.snakes[i].parts.length == 1)
{
MapElement.Type elem_type = snakeTail(data.location[i], new_location);
snake.element(MapElement(elem_type, data.entities[i].id),new_location);
}
final switch(data.movement[i].direction)
{
case CMovement.Direction.up:
snake.element(MapElement(MapElement.Type.snake_head_up, data.entities[i].id),data.location[i].location);
break;
case CMovement.Direction.right:
snake.element(MapElement(MapElement.Type.snake_head_right, data.entities[i].id),data.location[i].location);
break;
case CMovement.Direction.down:
snake.element(MapElement(MapElement.Type.snake_head_down, data.entities[i].id),data.location[i].location);
break;
case CMovement.Direction.left:
snake.element(MapElement(MapElement.Type.snake_head_left, data.entities[i].id),data.location[i].location);
break;
}
snake.addApple(); snake.addApple();
break; break;
} }
@ -455,19 +736,31 @@ void snakeStart()
launcher.manager.registerComponent!CSnake; launcher.manager.registerComponent!CSnake;
launcher.manager.registerComponent!CApple; launcher.manager.registerComponent!CApple;
launcher.manager.registerComponent!CParticle; launcher.manager.registerComponent!CParticle;
launcher.manager.registerComponent!CParticleVector;
launcher.manager.registerComponent!CMovement; launcher.manager.registerComponent!CMovement;
launcher.manager.registerComponent!CInput; launcher.manager.registerComponent!CInput;
launcher.manager.registerComponent!CAnimation;
launcher.manager.registerSystem!MoveSystem(0,"fixed"); launcher.manager.registerSystem!MoveSystem(0,"fixed");
launcher.manager.registerSystem!InputSystem(-100); launcher.manager.registerSystem!InputSystem(-100);
launcher.manager.registerSystem!FixSnakeDirectionSystem(-1,"fixed"); launcher.manager.registerSystem!FixSnakeDirectionSystem(-1,"fixed");
launcher.manager.registerSystem!AppleSystem(-1,"fixed"); launcher.manager.registerSystem!AppleSystem(-1,"fixed");
launcher.manager.registerSystem!AnimationRenderSystem(100);
launcher.manager.registerSystem!AnimationSystem(-1);
launcher.manager.registerSystem!ParticleSystem(-1);
launcher.manager.registerSystem!ParticleMovementSystem(-1);
launcher.manager.endRegister(); launcher.manager.endRegister();
launcher.gui_manager.addSystem(MoveSystem.system_id,"Move System"); launcher.gui_manager.addSystem(MoveSystem.system_id,"Move System");
launcher.gui_manager.addSystem(InputSystem.system_id,"Input System"); launcher.gui_manager.addSystem(InputSystem.system_id,"Input System");
launcher.gui_manager.addSystem(FixSnakeDirectionSystem.system_id,"Fix Direction System"); launcher.gui_manager.addSystem(FixSnakeDirectionSystem.system_id,"Fix Direction System");
launcher.gui_manager.addSystem(AnimationRenderSystem.system_id,"Animation Render System");
launcher.gui_manager.addSystem(AnimationSystem.system_id,"Animation System");
launcher.gui_manager.addSystem(ParticleSystem.system_id,"Particle Life System");
launcher.gui_manager.addSystem(ParticleMovementSystem.system_id,"Particle Movement System");
snake.snake_destroy_particle_frames = Mallocator.makeArray([vec4(64,144,16,16)*px,vec4(80,144,16,16)*px,vec4(96,144,16,16)*px,vec4(112,144,16,16)*px].staticArray);
{ {
ushort[4] components = [CILocation.component_id, CSnake.component_id, CMovement.component_id, CInput.component_id]; ushort[4] components = [CILocation.component_id, CSnake.component_id, CMovement.component_id, CInput.component_id];
@ -477,6 +770,14 @@ void snakeStart()
launcher.manager.addEntity(snake.snake_tmpl); launcher.manager.addEntity(snake.snake_tmpl);
} }
{
snake.snake_destroy_particle = launcher.manager.allocateTemplate([CLocation.component_id, CParticle.component_id, CParticleVector.component_id, CAnimation.component_id].staticArray);
CAnimation* canim = snake.snake_destroy_particle.getComponent!CAnimation;
canim.frames = snake.snake_destroy_particle_frames;
CParticle* particle = snake.snake_destroy_particle.getComponent!CParticle;
particle.life = 400;
}
{ {
ushort[2] components = [CILocation.component_id, CApple.component_id]; ushort[2] components = [CILocation.component_id, CApple.component_id];
snake.apple_tmpl = launcher.manager.allocateTemplate(components); snake.apple_tmpl = launcher.manager.allocateTemplate(components);
@ -485,6 +786,10 @@ void snakeStart()
launcher.gui_manager.addTemplate(snake.snake_tmpl, "Snake"); launcher.gui_manager.addTemplate(snake.snake_tmpl, "Snake");
launcher.gui_manager.addTemplate(snake.apple_tmpl, "Apple"); launcher.gui_manager.addTemplate(snake.apple_tmpl, "Apple");
launcher.gui_manager.addTemplate(snake.snake_destroy_particle, "Particle");
MoveSystem* move_system = launcher.manager.getSystem!MoveSystem();
move_system.setTemplates();
/*foreach(i; 0..10) /*foreach(i; 0..10)
foreach(j; 0..10) foreach(j; 0..10)

24
demos/source/demos/space_invaders.d
View file

@ -16,6 +16,8 @@ import ecs_utils.gfx.texture;
import ecs_utils.math.vector; import ecs_utils.math.vector;
import ecs_utils.utils; import ecs_utils.utils;
enum float px = 1.0/512.0;
extern(C): extern(C):
/*####################################################################################################################### /*#######################################################################################################################
@ -587,6 +589,7 @@ struct InputMovementSystem
const (CInput)[] input; const (CInput)[] input;
//components are treated as required by default //components are treated as required by default
CLocation[] locations; CLocation[] locations;
CTexture[] textures;
} }
/** /**
@ -595,6 +598,7 @@ struct InputMovementSystem
*/ */
bool onBegin() bool onBegin()
{ {
move_vector = vec2(0,0);
if(launcher.getKeyState(SDL_SCANCODE_W)) if(launcher.getKeyState(SDL_SCANCODE_W))
{ {
move_vector = vec2(0,1); move_vector = vec2(0,1);
@ -616,7 +620,7 @@ struct InputMovementSystem
return true; return true;
} }
//don't call system update because no key pressed //don't call system update because no key pressed
return false; return true;
} }
/** /**
@ -627,11 +631,21 @@ struct InputMovementSystem
*/ */
void onUpdate(EntitiesData data) void onUpdate(EntitiesData data)
{ {
if(move_vector.x == 0)
{
foreach(i; 0..data.length)
{
data.textures[i].coords = vec4(0*px,80*px,48*px,32*px);
}
return;
}
//move every entity using movement vector //move every entity using movement vector
foreach(i; 0..data.length) foreach(i; 0..data.length)
{ {
data.locations[i].x += move_vector.x * launcher.delta_time * 0.25; data.locations[i].x += move_vector.x * launcher.delta_time * 0.25;
data.locations[i].y += move_vector.y * launcher.delta_time * 0.25; data.locations[i].y += move_vector.y * launcher.delta_time * 0.25;
if(move_vector.x > 0)data.textures[i].coords = vec4(48*px,80*px,48*px,32*px);
else data.textures[i].coords = vec4(0*px,80*px,48*px,32*px);
} }
} }
} }
@ -644,8 +658,6 @@ __gshared SpaceInvaders* space_invaders;
void spaceInvadersStart() void spaceInvadersStart()
{ {
const float px = 1.0/512.0;
space_invaders = Mallocator.make!SpaceInvaders; space_invaders = Mallocator.make!SpaceInvaders;
space_invaders.texture.create(); space_invaders.texture.create();
@ -690,9 +702,11 @@ void spaceInvadersStart()
ushort[7] components = [CLocation.component_id, CTexture.component_id, CInput.component_id, CShip.component_id, CScale.component_id, CLaserWeapon.component_id, CShootDirection.component_id]; ushort[7] components = [CLocation.component_id, CTexture.component_id, CInput.component_id, CShip.component_id, CScale.component_id, CLaserWeapon.component_id, CShootDirection.component_id];
space_invaders.ship_tmpl = launcher.manager.allocateTemplate(components); space_invaders.ship_tmpl = launcher.manager.allocateTemplate(components);
CScale* scale_comp = space_invaders.ship_tmpl.getComponent!CScale;
scale_comp.value = vec2(48,32);
CTexture* tex_comp = space_invaders.ship_tmpl.getComponent!CTexture; CTexture* tex_comp = space_invaders.ship_tmpl.getComponent!CTexture;
tex_comp.tex = space_invaders.texture;//ship_tex; tex_comp.tex = space_invaders.texture;//ship_tex;
tex_comp.coords = vec4(0*px,48*px,16*px,16*px); tex_comp.coords = vec4(0*px,80*px,48*px,32*px);
CLocation* loc_comp = space_invaders.ship_tmpl.getComponent!CLocation; CLocation* loc_comp = space_invaders.ship_tmpl.getComponent!CLocation;
loc_comp.value = vec2(64,64); loc_comp.value = vec2(64,64);
CLaserWeapon* weapon = space_invaders.ship_tmpl.getComponent!CLaserWeapon; CLaserWeapon* weapon = space_invaders.ship_tmpl.getComponent!CLaserWeapon;
@ -707,7 +721,7 @@ void spaceInvadersStart()
CTexture* tex_comp = space_invaders.laser_tmpl.getComponent!CTexture; CTexture* tex_comp = space_invaders.laser_tmpl.getComponent!CTexture;
tex_comp.tex = space_invaders.texture;//laser_tex; tex_comp.tex = space_invaders.texture;//laser_tex;
tex_comp.coords = vec4(0*px,48*px,16*px,16*px); tex_comp.coords = vec4(0*px,24*px,2*px,8*px);
CScale* scale_comp = space_invaders.laser_tmpl.getComponent!CScale; CScale* scale_comp = space_invaders.laser_tmpl.getComponent!CScale;
scale_comp.value = vec2(2,8); scale_comp.value = vec2(2,8);
CVelocity* vel_comp = space_invaders.laser_tmpl.getComponent!CVelocity; CVelocity* vel_comp = space_invaders.laser_tmpl.getComponent!CVelocity;

19
demos/utils/source/ecs_utils/math/vector.d
View file

@ -30,6 +30,11 @@ struct vec2
else static assert(0, "Operator "~op~" not implemented"); else static assert(0, "Operator "~op~" not implemented");
} }
ivec2 opCast()
{
return ivec2(cast(int)x,cast(int)y);
}
void opOpAssign(string op)(vec2 v) void opOpAssign(string op)(vec2 v)
{ {
static if (op == "+") static if (op == "+")
@ -69,6 +74,15 @@ struct vec4
} }
float[4] data; float[4] data;
} }
vec4 opBinary(string op)(float v)
{
static if (op == "+") return vec4(x + v, y + v, z + v, w + v);
else static if (op == "-") return vec4(x - v, y - v, z - v, w - v);
else static if (op == "*") return vec4(x * v, y * v, z * v, w * v);
else static if (op == "/") return vec4(x / v, y / v, z / v, w / v);
else static assert(0, "Operator "~op~" not implemented");
}
} }
struct ivec2 struct ivec2
@ -82,6 +96,11 @@ struct ivec2
} }
int[2] data; int[2] data;
} }
vec2 opCast()
{
return vec2(x,y);
}
} }
struct ivec4 struct ivec4

7
source/ecs/manager.d
View file

@ -1550,10 +1550,13 @@ export struct EntityManager
} }
/************************************************************************************************************************ /************************************************************************************************************************
*Allocate EntityTemplate with specifed components and returns pointer to it. *Allocate EntityTemplate from basic Template with modifications by adding and removing some components and returns pointer to it.
*Arrays of components needen't to be checked for repeated components, as function itself check if components exist in base template.
* *
*Params: *Params:
*components_ids = array of components allocated with template *base_tmpl = template from which components sould be copied
*components_ids = array of new components to add
*remove_components_ids = array of components to remove from base template
*/ */
export EntityTemplate* allocateTemplate(EntityTemplate* base_tmpl, export EntityTemplate* allocateTemplate(EntityTemplate* base_tmpl,
ushort[] components_ids, ushort[] remove_components_ids = null) ushort[] components_ids, ushort[] remove_components_ids = null)