Merge branch 'sandbox' into 'main'

Merge sandbox into main

See merge request sami.hatna/crowd-simulation!1

Author: Sami Hatna

include/Actor.cpp

@@ -1,11 +1,53 @@
 #include "Actor.hpp"
 #include <iostream>
 #include <array>
+#include <sycl/sycl.hpp>
 
-Actor::Actor(std::array<float, 2> pPos, std::array<float, 2> pVelocity, std::array<float, 2> pDesiredVelocity, float pMass, float pRadius) {
+Actor::Actor(std::array<float, 2> pPos, std::array<float, 2> pVelocity, std::array<float, 2> pDesiredVelocity, std::array<float, 2> pDestination, float pMass, float pRadius) {
     pos = pPos;
     velocity = pVelocity;
     desiredVelocity = pDesiredVelocity;
+    destination = pDestination;
     mass = pMass;
     radius = pRadius;
+}
+
+std::array<float, 2> Actor::getPos() {
+    return pos;
+}
+
+SYCL_EXTERNAL std::array<float, 2> Actor::getVelocity() {
+    return velocity;
+}
+
+std::array<float, 2> Actor::getDesiredVelocity() {
+    return desiredVelocity;
+}
+
+std::array<float, 2> Actor::getDestination() {
+    return destination;
+}
+
+float Actor::getMass() {
+    return mass;
+}
+
+float Actor::getRadius() {
+    return radius;
+}
+
+void Actor::setPos(std::array<float, 2> newPos) {
+    pos = newPos;
+}
+
+void Actor::setVelocity(std::array<float, 2> newVelocity) {
+    velocity = newVelocity;
+}
+
+void Actor::setDesiredVelocity(std::array<float, 2> newDesiredVelocity) {
+    desiredVelocity = newDesiredVelocity;
+}
+
+void Actor::setDestination(std::array<float, 2> newDestination) {
+    destination = newDestination;
 }

include/Actor.hpp

@@ -1,18 +1,32 @@
 #ifndef Actor_hpp
 #define Actor_hpp
 
-#include<iostream>
+#include <iostream>
 #include <array>
+#include <sycl/sycl.hpp>
 
 class Actor {
 private:
     std::array<float, 2> pos;
     std::array<float, 2> velocity;
     std::array<float, 2> desiredVelocity;
+    std::array<float, 2> destination;
     float mass;
     float radius;
 public:    
-    Actor(std::array<float, 2> pPos, std::array<float, 2> pVelocity, std::array<float, 2> pDesiredVelocity, float pMass, float pRadius);
+    Actor(std::array<float, 2> pPos, std::array<float, 2> pVelocity, std::array<float, 2> pDesiredVelocity, std::array<float, 2> pDestination, float pMass, float pRadius);
+    
+    SYCL_EXTERNAL std::array<float, 2> getPos();
+    SYCL_EXTERNAL std::array<float, 2> getVelocity();
+    std::array<float, 2> getDesiredVelocity();
+    std::array<float, 2> getDestination();
+    float getMass();
+    float getRadius();
+
+    SYCL_EXTERNAL void setPos(std::array<float, 2> newPos);
+    void setVelocity(std::array<float, 2> newVelocity);
+    void setDesiredVelocity(std::array<float, 2> newDesiredVelocity);
+    void setDestination(std::array<float, 2> newDestination);
 };
 
 #endif

include/CMakeLists.txt

@@ -1 +1 @@
-add_library(include Actor.cpp)
+add_library(include Actor.cpp Room.cpp MathHelper.cpp DifferentialEq.cpp)

include/DifferentialEq.cpp

@@ -0,0 +1,9 @@
+#include <iostream>
+#include <vector>
+#include <array>
+#include "DifferentialEq.hpp"
+#include "Actor.hpp"
+#include "Room.hpp"
+#include "MathHelper.hpp"
+
+void DifferentialEqu(Actor actor);

include/DifferentialEq.hpp

@@ -0,0 +1,19 @@
+#ifndef DifferentialEqu_hpp
+#define DifferentialEqu_hpp
+
+#include <iostream>
+#include <vector>
+#include <array>
+#include "Actor.hpp"
+#include "Room.hpp"
+#include "MathHelper.hpp"
+
+const float Ai = 2000;
+const float Bi = 0.08;
+const float k1 = 125000;
+const float k2 = 240000;
+const float ti = 0.5;
+
+void DifferentialEqu(Actor actor);
+
+#endif

include/MathHelper.cpp

@@ -0,0 +1,21 @@
+#include "MathHelper.hpp"
+#include <iostream>
+#include <vector>
+#include <array>
+#include <cmath>
+
+std::array<float, 2> getDirectionVector(std::array<float, 2> a, std::array<float, 2> b) {
+    return {float(b[0] - a[0]), float(b[1] - a[1])};
+}
+
+std::array<float, 2> velFromSpeedAndDir(float s, std::array<float, 2> d) {
+    return {(s / magnitude(d)) * d[0], (s / magnitude(d)) * d[1]};
+}
+
+std::array<float, 2> velToPoint(float s, std::array<float, 2> pos, std::array<float, 2> destination) {
+    return velFromSpeedAndDir(s, getDirectionVector(pos, destination));
+}
+
+float magnitude(std::array<float, 2> inp) {
+    return std::sqrt((inp[0] * inp[0]) + (inp[1] * inp[1]));
+}

include/MathHelper.hpp

@@ -0,0 +1,16 @@
+#ifndef MathHelper_hpp
+#define MathHelper_hpp
+
+#include <iostream>
+#include <vector>
+#include <array>
+
+std::array<float, 2> getDirectionVector(std::array<float, 2> a, std::array<float, 2> b);
+
+std::array<float, 2> velFromSpeedAndDir(float s, std::array<float, 2> d);
+
+std::array<float, 2> velToPoint(float s, std::array<float, 2> pos, std::array<float, 2> destination);
+
+float magnitude(std::array<float, 2> inp);
+
+#endif

include/Room.cpp

@@ -0,0 +1,12 @@
+#include "Room.hpp"
+#include <iostream>
+#include <vector>
+#include <array>
+
+Room::Room(std::vector<std::array<float, 4>> pWalls) {
+    walls = pWalls;
+}
+
+std::vector<std::array<float, 4>> Room::getWalls() {
+    return walls;
+}

include/Room.hpp

@@ -0,0 +1,17 @@
+#ifndef Room_hpp
+#define Room_hpp
+
+#include <iostream>
+#include <vector>
+#include <array>
+
+class Room {
+private:
+    std::vector<std::array<float, 4>> walls;
+public:    
+    Room(std::vector<std::array<float, 4>> pWalls);
+
+    std::vector<std::array<float, 4>> getWalls();
+};
+
+#endif

src/main.cpp

@@ -1,21 +1,27 @@
-#include <CL/sycl.hpp>
+#include <sycl/sycl.hpp>
 #include <SDL2/SDL.h>
-#include "Actor.hpp"
 #include <iostream>
 
+#include "Actor.hpp"
+#include "Room.hpp"
+#include "MathHelper.hpp"
+#include "DifferentialEq.hpp"
+
 const int WIDTH = 8; // metres
 const int HEIGHT = 6; // metres
 const int SCALE = 100;
+const int DELAY = 10000;
 
-void init(SDL_Window* win, SDL_Renderer* render, std::vector<Actor> &actors) {
+void init(SDL_Window* &win, SDL_Renderer* &render, std::vector<Actor> &actors) {
     SDL_Init(SDL_INIT_VIDEO);
     win = SDL_CreateWindow("SYCL Crowd Simulation", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, WIDTH * SCALE, HEIGHT * SCALE, SDL_WINDOW_SHOWN);
     render = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED);
 
-    actors.push_back(Actor{{1,2}, {3,4}, {5,6}, 3, 4});
+    actors.push_back(Actor{{4, 0}, {0.01, 0.01}, {0.02, 0.02}, {1, 2}, 50, 0.05});
+    actors.push_back(Actor{{8, 6}, {-0.02, -0.02}, {-0.03, -0.03}, {1, 2}, 60, 0.08});
 }
 
-void drawCircle(SDL_Renderer* render, SDL_Point center, int radius, SDL_Color color) {
+void drawCircle(SDL_Renderer* &render, SDL_Point center, int radius, SDL_Color color) {
     SDL_SetRenderDrawColor(render, color.r, color.g, color.b, color.a);
     for (int w = 0; w < radius * 2; w++) {
         for (int h = 0; h < radius * 2; h++) {
@@ -28,11 +34,36 @@ void drawCircle(SDL_Renderer* render, SDL_Point center, int radius, SDL_Color co
     }
 }
 
-void draw(SDL_Renderer* render, std::vector<Actor> &actors) {
+void update(std::vector<Actor> &actors) {
+    sycl::queue myQueue{sycl::gpu_selector()};
+
+    auto actorBuf = sycl::buffer<Actor>(actors.data(), actors.size());
+
+    myQueue.submit([&](sycl::handler& cgh) {
+        auto actorAcc = actorBuf.get_access<sycl::access::mode::read_write>(cgh);
+
+        cgh.parallel_for(sycl::range<1>{actors.size()}, [=](sycl::id<1> index) {
+            Actor current = actorAcc[index];
+            actorAcc[index].setPos({current.getPos()[0] + current.getVelocity()[0],
+                            current.getPos()[1] + current.getVelocity()[1]});
+        }); 
+    }).wait();
+}
+
+void draw(SDL_Renderer* &render, std::vector<Actor> actors, Room room) {
     SDL_SetRenderDrawColor(render, 255, 255, 255, 255);
     SDL_RenderClear(render);
 
+    SDL_Color red = {255, 0, 0, 255};
+    for (Actor actor : actors) {
+        SDL_Point pos = {int(actor.getPos()[0] * SCALE), int(actor.getPos()[1] * SCALE)};
+        drawCircle(render, pos, actor.getRadius() * SCALE, red);
+    }
 
+    SDL_SetRenderDrawColor(render, 0, 0, 0, 255);
+    for (std::array<float, 4> wall : room.getWalls()) {
+        SDL_RenderDrawLine(render, wall[0] * SCALE, wall[1] * SCALE, wall[2] * SCALE, wall[3] * SCALE);
+    }
 
     SDL_RenderPresent(render);
 }
@@ -48,13 +79,16 @@ int main() {
     SDL_Renderer* render = NULL;
 
     std::vector<Actor> actors;
+    Room room = Room({{0.5, 0.5, 0.5, 1.5}, {0.5, 2.5, 0.5, 5.5}, {0.5, 5.5, 7.5, 5.5}, {7.5, 5.5, 7.5, 0.5}, {7.5, 0.5, 0.5, 0.5}});
 
     init(win, render, actors);
 
-    draw(render, actors);
+    // Make actor move towards destination
+    actors[0].setVelocity(velToPoint(0.008, actors[0].getPos(), actors[0].getDestination()));
 
-    Actor test = Actor({0, 2}, {3, 4}, {5,6}, 12, 3);
+    draw(render, actors, room);
 
+    int delayCounter = 0;
     bool isQuit = false;
     SDL_Event event;
 
@@ -64,8 +98,14 @@ int main() {
                 isQuit = true;
             }
         }
-
-        draw(render, actors);
+        if (delayCounter >= DELAY) {
+            delayCounter = 0;
+            update(actors);
+            draw(render, actors, room);
+        }
+        else {
+            delayCounter++;
+        }
     }
 
     close(win);