Sprint3 physfs

CMakeLists.txt

@@ -14,6 +14,7 @@ set(Neko_Profile OFF CACHE BOOL "Activate Profiling with Easy Profile")
 set(Neko_GLES3 ON CACHE BOOL "Activate OpenGL ES 3.0")
 set(Neko_SDL2 ON CACHE BOOL "Activate SDL2")
 set(Neko_Box2D OFF CACHE BOOL "Activate Box2D")
+set(Neko_PhysFS ON CACHE BOOL "Activate PhysicsFS")
 set(Neko_Test ON CACHE BOOL "Activate Test")
 set(Neko_Assert ON CACHE BOOL "Activate Neko Assertion")
 set(Neko_Benchmark ON CACHE BOOL "Activate Benchmark")
@@ -27,6 +28,8 @@ if ("${CMAKE_SYSTEM_NAME}" STREQUAL "Emscripten")
     set(CMAKE_STATIC_LIBRARY_SUFFIX ".a")
     set(Neko_SameThread ON CACHE BOOL "Used for Emscripten and other system when render and engine has to be in the same thread")
     mark_as_advanced(Neko_SameThread)
+    set(Neko_PhysFS OFF CACHE BOOL "Disable PhysFS for Emscripten.")
+    mark_as_advanced(Neko_PhysFS)
 endif()
 
 if(UNIX)
@@ -59,6 +62,18 @@ if(Neko_Profile)
     add_subdirectory(${EASY_PROFILE_DIR})
 endif()
 
+if(Neko_PhysFS)
+    #physfs
+    add_compile_definitions("NEKO_PHYSFS=1")
+    set(PHYSFS_VERSION "3.0.2" CACHE INTERNAL "")
+    set(PHYSFS_ROOT "${EXTERNAL_DIR}/physfs-${PHYSFS_VERSION}" CACHE INTERNAL "")
+    add_subdirectory("${PHYSFS_ROOT}")
+    include_directories(${PHYSFS_ROOT}/src)
+
+    add_subdirectory("common/physfs_wrapper")
+
+endif()
+
 include("cmake/data.cmake")
 set(NEKO_CORE_DIR "${CMAKE_SOURCE_DIR}/core/" CACHE INTERNAL "")
 add_subdirectory(${NEKO_CORE_DIR})
@@ -115,7 +130,7 @@ if(Neko_Test)
     add_subdirectory("test/")
 endif()
 
-if(Neko_Benchmark)
+if(Neko_Benchmark AND NOT Emscripten)
     #Google benchmark
     set(GOOGLE_BENCH_DIR "${EXTERNAL_DIR}/benchmark-1.5.0" CACHE STRING "")
 
@@ -126,6 +141,7 @@ if(Neko_Benchmark)
 
 endif()
 
+
 set(main_project_dir "main/")
 file(GLOB main_projects "${main_project_dir}/*")
 

benchmark/bench_resource.cpp

@@ -0,0 +1,138 @@
+#include <iostream>
+#include <random>
+#include "random_fill.h"
+#include <benchmark/benchmark.h>
+
+
+#include "engine/assert.h"
+#include "engine/engine.h"
+#include "engine/resource.h"
+#include "utilities/file_utility.h"
+
+const int smallFromRange = 4;
+const int smallToRange = 512;
+
+const int bigFromRange = 2;
+const int bigToRange = 64;
+
+
+static void BM_SmallResourceThread(benchmark::State& state)
+{
+    neko::Configuration config;
+    std::string path = config.dataRootPath + "data/test/smallFile.txt";
+    neko::BufferFile fileContent;
+    fileContent.Load(path);
+    neko::ResourceManager resourceManager;
+    resourceManager.Init();
+    const size_t size = state.range(0);
+    std::vector<neko::ResourceId> resourcesId;
+    std::map<neko::ResourceId, neko::BufferFile> resources;
+    for (int i = 0; i < size; i++)
+    {
+        resourcesId.push_back(resourceManager.LoadResource(path));
+    }
+    for (auto _ : state)
+    {
+        while (resources.size()<resourcesId.size()) {
+            for (int n = 0; n < size; n++)
+            {
+                if (resources.find(resourcesId[n]) != resources.end())
+                {
+                    continue;
+                }
+                if (resourceManager.IsResourceReady(resourcesId[n]))
+                {
+                    resources[resourcesId[n]] = resourceManager.GetResource(resourcesId[n]);
+                    neko_assert(fileContent == resources[resourcesId[n]], "Error Loading");
+                }
+            }
+        }
+        resources.clear();
+    }
+    resourceManager.Destroy();
+}
+
+static void BM_BigResourceThread(benchmark::State& state)
+{
+    neko::Configuration config;
+    std::string path = config.dataRootPath + "data/test/bigFile.json";
+    neko::BufferFile fileContent;
+    fileContent.Load(path);
+    neko::ResourceManager resourceManager;
+    resourceManager.Init();
+    const size_t size = state.range(0);
+    std::vector<neko::ResourceId> resourcesId;
+    std::map<neko::ResourceId, neko::BufferFile> resources;
+    for (int i = 0; i < size; i++)
+    {
+        resourcesId.push_back(resourceManager.LoadResource(path));
+    }
+    for (auto _ : state)
+    {
+        while (resources.size() < resourcesId.size()) {
+            for (int n = 0; n < size; n++)
+            {
+                if (resources.find(resourcesId[n]) != resources.end())
+                {
+                    continue;
+                }
+                if (resourceManager.IsResourceReady(resourcesId[n]))
+                {
+                    resources[resourcesId[n]] = resourceManager.GetResource(resourcesId[n]);
+                    neko_assert(fileContent == resources[resourcesId[n]], "Error Loading");
+                }
+            }
+        }
+        resources.clear();
+
+    }
+    resourceManager.Destroy();
+}
+
+static void BM_SmallResourceNonThread(benchmark::State& state)
+{
+    neko::Configuration config;
+    std::string path = config.dataRootPath + "data/test/smallFile.txt";
+    neko::BufferFile fileContent;
+    fileContent.Load(path);
+    const size_t size = state.range(0);
+    std::vector<neko::BufferFile> resources;
+    for (auto _ : state)
+    {
+        resources.clear();
+        for (int i = 0; i < size; i++)
+        {
+            neko::BufferFile loadedFile;
+            loadedFile.Load(path);
+            resources.push_back(loadedFile);
+            neko_assert(fileContent == resources.back(), "Error Loading");
+        }
+    }
+}
+
+static void BM_BigResourceNonThread(benchmark::State& state)
+{
+    neko::Configuration config;
+    std::string path = config.dataRootPath + "data/test/bigFile.json";
+    neko::BufferFile fileContent;
+    fileContent.Load(path);
+    const size_t size = state.range(0);
+    std::vector<neko::BufferFile> resources;
+    for (auto _ : state)
+    {
+        resources.clear();
+        for (int i = 0; i < size; i++)
+        {
+            neko::BufferFile loadedFile;
+            loadedFile.Load(path);
+            resources.push_back(loadedFile);
+            neko_assert(fileContent == resources.back(), "Error Loading");
+        }
+    }
+}
+
+BENCHMARK(BM_SmallResourceThread)->Range(smallFromRange, smallToRange)->UseRealTime();
+BENCHMARK(BM_BigResourceThread)->Range(bigFromRange, bigToRange)->UseRealTime();
+
+BENCHMARK(BM_SmallResourceNonThread)->Range(smallFromRange, smallToRange)->UseRealTime();
+BENCHMARK(BM_BigResourceNonThread)->Range(bigFromRange, bigToRange)->UseRealTime();