diff --git a/demos/assets/textures/atlas.png b/demos/assets/textures/atlas.png
index 498f34d..c628969 100644
Binary files a/demos/assets/textures/atlas.png and b/demos/assets/textures/atlas.png differ
diff --git a/demos/external/sources/mmutils/thread_pool.d b/demos/external/sources/mmutils/thread_pool.d
index a5fbf91..445cd19 100644
--- a/demos/external/sources/mmutils/thread_pool.d
+++ b/demos/external/sources/mmutils/thread_pool.d
@@ -12,6 +12,8 @@ import std.algorithm : map;
 version = MM_NO_LOGS; // Disable log creation
 //version = MM_USE_POSIX_THREADS; // Use posix threads insted of standard library, required for betterC
 
+version (Posix)version = MM_USE_POSIX_THREADS;
+
 version (WebAssembly)
 {
 	extern(C) struct FILE
diff --git a/demos/source/demos/snake.d b/demos/source/demos/snake.d
index 19d0e31..6bb8cef 100644
--- a/demos/source/demos/snake.d
+++ b/demos/source/demos/snake.d
@@ -17,6 +17,10 @@ import ecs_utils.gfx.texture;
 import ecs_utils.math.vector;
 import ecs_utils.utils;
 
+import std.array : staticArray;
+
+enum float px = 1.0/512.0;
+
 extern(C):
 
 struct MapElement
@@ -24,9 +28,24 @@ struct MapElement
     enum Type
     {
         empty = 0,
-        snake = 1,
-        apple = 2,
-        wall = 3    
+        apple = 1,
+        wall = 2,
+        
+        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;
     EntityID id;
@@ -38,8 +57,13 @@ struct Snake
 
     EntityTemplate* apple_tmpl;
     EntityTemplate* snake_tmpl;
+    EntityTemplate* snake_destroy_particle;
     Texture texture;
 
+    vec4[] snake_destroy_particle_frames;
+    vec4[] smoke_frames;
+
+
     bool move_system = true;
     bool draw_system = true;
 
@@ -83,7 +107,6 @@ struct Snake
 
     void drawMap()
     {
-        const float px = 1.0/512.0;
         foreach(x; 0 .. map_size)
         {
             foreach(y; 0 .. map_size)
@@ -91,7 +114,22 @@ struct Snake
                 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.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;
                     default:break;
                 }
@@ -101,6 +139,19 @@ struct Snake
 
 }
 
+struct Animation
+{
+
+}
+
+struct CAnimation
+{
+    mixin ECS.Component;
+    
+    vec4[] frames;
+    float time = 0;
+}
+
 struct CILocation
 {
     mixin ECS.Component;
@@ -116,7 +167,7 @@ struct CLocation
 
     alias location this;
 
-    vec2 location;
+    vec2 location = vec2(0,0);
 }
 
 struct CSnake
@@ -176,13 +227,15 @@ struct CApple
 struct CParticle
 {
     mixin ECS.Component;
+
+    float life = 0;
 }
 
 struct CParticleVector
 {
     mixin ECS.Component;
 
-    vec2 velocity;
+    vec2 velocity = vec2(0,0);
 }
 
 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
 {
     mixin ECS.System!64;
 
+    EntityTemplate* destroy_template;
+    CLocation* destroy_location;
+    CParticleVector* destroy_vector;
+
     struct EntitiesData
     {
         uint length;
@@ -239,6 +380,13 @@ struct MoveSystem
         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)
     {
         final switch(direction)
@@ -276,6 +424,56 @@ struct MoveSystem
         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)
     {
         if(data.snakes)
@@ -286,21 +484,104 @@ struct MoveSystem
                 moveLocation(data.location[i], data.movement[i].direction);
                 final switch(snake.element(data.location[i].location).type)
                 {
-                    case MapElement.Type.snake:
-                        launcher.manager.removeEntity(data.entities[i].id);
-                        break;
-                    case MapElement.Type.wall:
+                    case MapElement.Type.snake_head_up:goto case(MapElement.Type.snake_horizontal);
+                    case MapElement.Type.snake_head_down:goto case(MapElement.Type.snake_horizontal);
+                    case MapElement.Type.snake_head_left:goto case(MapElement.Type.snake_horizontal);
+                    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);
                         break;
+                    case MapElement.Type.wall:break;
+                        //launcher.manager.removeEntity(data.entities[i].id);
+                        //break;
                     case MapElement.Type.empty:
                         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;
                     case MapElement.Type.apple:
                         launcher.manager.removeEntity(snake.element(data.location[i].location).id);
-                        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 < 100)data.snakes[i].parts.add(new_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();
                         break;
                 }
@@ -455,19 +736,31 @@ void snakeStart()
     launcher.manager.registerComponent!CSnake;
     launcher.manager.registerComponent!CApple;
     launcher.manager.registerComponent!CParticle;
+    launcher.manager.registerComponent!CParticleVector;
     launcher.manager.registerComponent!CMovement;
     launcher.manager.registerComponent!CInput;
+    launcher.manager.registerComponent!CAnimation;
 
     launcher.manager.registerSystem!MoveSystem(0,"fixed");
     launcher.manager.registerSystem!InputSystem(-100);
     launcher.manager.registerSystem!FixSnakeDirectionSystem(-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.gui_manager.addSystem(MoveSystem.system_id,"Move System");
     launcher.gui_manager.addSystem(InputSystem.system_id,"Input 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];
@@ -477,14 +770,26 @@ void snakeStart()
         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];
         snake.apple_tmpl = launcher.manager.allocateTemplate(components);
         snake.addApple();
     }
-
+    
     launcher.gui_manager.addTemplate(snake.snake_tmpl, "Snake");
     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(j; 0..10)
diff --git a/demos/source/demos/space_invaders.d b/demos/source/demos/space_invaders.d
index 7058b59..bddf53c 100644
--- a/demos/source/demos/space_invaders.d
+++ b/demos/source/demos/space_invaders.d
@@ -16,6 +16,8 @@ import ecs_utils.gfx.texture;
 import ecs_utils.math.vector;
 import ecs_utils.utils;
 
+enum float px = 1.0/512.0;
+
 extern(C):
 
 /*#######################################################################################################################
@@ -587,6 +589,7 @@ struct InputMovementSystem
         const (CInput)[] input;
         //components are treated as required by default
         CLocation[] locations;
+        CTexture[] textures;
     }
 
     /**
@@ -595,6 +598,7 @@ struct InputMovementSystem
     */
     bool onBegin()
     {
+        move_vector = vec2(0,0);
         if(launcher.getKeyState(SDL_SCANCODE_W))
         {
             move_vector = vec2(0,1);
@@ -616,7 +620,7 @@ struct InputMovementSystem
             return true;
         }
         //don't call system update because no key pressed 
-        return false;
+        return true;
     }
 
     /**
@@ -627,11 +631,21 @@ struct InputMovementSystem
     */
     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
         foreach(i; 0..data.length)
         {
             data.locations[i].x += move_vector.x * 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()
 {
-    const float px = 1.0/512.0;
-
     space_invaders = Mallocator.make!SpaceInvaders;
 
     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];
         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;
         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;
         loc_comp.value = vec2(64,64);
         CLaserWeapon* weapon = space_invaders.ship_tmpl.getComponent!CLaserWeapon;
@@ -707,7 +721,7 @@ void spaceInvadersStart()
 
         CTexture* tex_comp = space_invaders.laser_tmpl.getComponent!CTexture;
         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;
         scale_comp.value = vec2(2,8);
         CVelocity* vel_comp = space_invaders.laser_tmpl.getComponent!CVelocity;
diff --git a/demos/utils/source/ecs_utils/math/vector.d b/demos/utils/source/ecs_utils/math/vector.d
index 10b4de5..4b9f3af 100644
--- a/demos/utils/source/ecs_utils/math/vector.d
+++ b/demos/utils/source/ecs_utils/math/vector.d
@@ -30,6 +30,11 @@ struct vec2
         else static assert(0, "Operator "~op~" not implemented");
     }
 
+    ivec2 opCast()
+    {
+        return ivec2(cast(int)x,cast(int)y);
+    }
+
     void opOpAssign(string op)(vec2 v)
     {
         static if (op == "+")
@@ -69,6 +74,15 @@ struct vec4
         }
         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
@@ -82,6 +96,11 @@ struct ivec2
         }
         int[2] data;
     }
+
+    vec2 opCast()
+    {
+        return vec2(x,y);
+    }
 }
 
 struct ivec4
diff --git a/source/ecs/manager.d b/source/ecs/manager.d
index 1b9b959..9f5dceb 100644
--- a/source/ecs/manager.d
+++ b/source/ecs/manager.d
@@ -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:
-    *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,
             ushort[] components_ids, ushort[] remove_components_ids = null)