cbuild 2.3.5

src/Engine.cpp

@@ -7,8 +7,8 @@
 
 namespace ougge {
 
-IEngineModule::IEngineModule(Engine& engine)
-    : engine(engine)
+IEngineModule::IEngineModule(Engine& _engine)
+    : engine(_engine)
 {}
 
 void IEngineModule::beginFrame() {}

src/game/GameObjectPool.cpp

@@ -4,15 +4,15 @@
 
 namespace ougge::game {
 
-GameObjectPool::GameObjectPool(u32 size)
+GameObjectPool::GameObjectPool(u32 _size)
+    : size(_size)
 {
-    useful_assert(size % 64 == 0, "size of GameObjectPool must be a multiple of 64");
-    this->size = size; 
+    useful_assert(_size % 64 == 0, "size of GameObjectPool must be a multiple of 64");
     first_unused_index = 0;
-    buffer = new GameObject[size];
-    used_indices = new u64[size/64];
+    buffer = new GameObject[_size];
+    used_indices = new u64[_size/64];
     // std::memset(buffer, 0, size*sizeof(GameObject));
-    std::memset(used_indices, 0, size/8);
+    std::memset(used_indices, 0, _size/8);
 }
 
 GameObjectPool::~GameObjectPool()
@@ -110,8 +110,8 @@ bool GameObjectPool::erase(u32 index)
     return true;
 }
 
-GameObjectPool::iterator::iterator(GameObjectPool* pool, u32 index)
-    : pool(pool), index(index)
+GameObjectPool::iterator::iterator(GameObjectPool* _pool, u32 _index)
+    : pool(_pool), index(_index)
 {
 }
 

src/main.cpp

@@ -11,8 +11,8 @@ using namespace ougge;
 class TutelModule : public IEngineModule {
     resources::CacheStorage<resources::Texture> textures;
 public:
-    TutelModule(Engine& engine, resources::ResourceManager& resourceManager) :
-        IEngineModule(engine),
+    TutelModule(Engine& _engine, resources::ResourceManager& resourceManager) :
+        IEngineModule(_engine),
         textures(&resourceManager)
     {
         //TODO: add something like `assert(requireModule(MainWindow))`

src/modules/MainWindowSDL2.cpp

@@ -25,10 +25,10 @@ f32 MainWindowSDL2::getDPI(){
     return dpi;
 }
 
-MainWindowSDL2::MainWindowSDL2(Engine& engine,
+MainWindowSDL2::MainWindowSDL2(Engine& _engine,
         const std::string& window_title,
         resources::ResourceManager& resourceManager)
-    : IEngineModule(engine)
+    : IEngineModule(_engine)
 {
     SDL_TRY(SDL_Init(SDL_INIT_EVERYTHING));
     SDL_version v;

src/modules/MonoGameObjectSystem.cpp

@@ -6,8 +6,8 @@ const std::string& MonoGameObjectSystem::getName() {
     return ougge_type_name<MonoGameObjectSystem>();
 }
 
-MonoGameObjectSystem::MonoGameObjectSystem(Engine& engine, u32 max_game_objects) :
-    IEngineModule(engine), 
+MonoGameObjectSystem::MonoGameObjectSystem(Engine& _engine, u32 max_game_objects) :
+    IEngineModule(_engine), 
     gameObjectPool(max_game_objects)
 {
     engineManagedAssembly = mono.loadAssembly("Ougge.dll");
@@ -53,7 +53,7 @@ void MonoGameObjectSystem::beginFrame(){
 // is used in NativeFunctions.cs
 game::GameObject& MonoGameObjectSystem::createGameObjectInPool(u64* id_out, u32* index_out){
     auto pair = gameObjectPool.emplace(game::GameObject(mono.createObject(gameObjectClass)));
-    *id_out = ++obj_id;
+    *id_out = ++last_obj_id;
     *index_out = pair.first;
     game::GameObject& obj = pair.second;
     return obj;

src/modules/MonoGameObjectSystem.hpp

@@ -10,7 +10,7 @@ namespace ougge::modules {
 class MonoGameObjectSystem : public IEngineModule {
     Mono::RuntimeJIT mono;
     game::GameObjectPool gameObjectPool;
-    u64 obj_id = 0;
+    u64 last_obj_id = 0;
     MonoClass* gameObjectClass;
     Mono::Method<void(u64, u32)> gameObjectCtor;
     Mono::Method<void(f64)> gameObjectInvokeUpdate;

src/mono/Assembly.cpp

@@ -2,8 +2,8 @@
 
 namespace Mono {
 
-Assembly::Assembly(MonoAssembly *ptr)
-    : ptr(ptr), image(mono_assembly_get_image(ptr))
+Assembly::Assembly(MonoAssembly *_ptr)
+    : ptr(_ptr), image(mono_assembly_get_image(_ptr))
 {
 }
 

src/resources/resources.cpp

@@ -8,8 +8,8 @@
 
 namespace ougge::resources {
 
-ResourceFactory::ResourceFactory(const std::string& path, const std::size_t size, StreamFactoryMethod open_read_steam_func)
-  : path(path), size(size), openStream(open_read_steam_func)
+ResourceFactory::ResourceFactory(const std::string& _path, const std::size_t _size, StreamFactoryMethod _open_read_steam_func)
+  : path(_path), size(_size), openStream(_open_read_steam_func)
 {}
 
 

src/resources/textures.cpp

@@ -4,12 +4,12 @@
 
 namespace ougge::resources {
 
-Texture::Texture(ResourceFactory* r, SDL_Renderer* renderer) 
-    : Texture(*r->openStream(), r->size, renderer)
+Texture::Texture(ResourceFactory* r, SDL_Renderer* _renderer) 
+    : Texture(*r->openStream(), r->size, _renderer)
 {}
 
-Texture::Texture(std::istream& s, size_t size, SDL_Renderer* renderer)
-    : renderer(renderer), texture(nullptr), w(0), h(0)
+Texture::Texture(std::istream& s, size_t size, SDL_Renderer* _renderer)
+    : renderer(_renderer), texture(nullptr), w(0), h(0)
 {
     SDL_RWops* sdl_stream = SDL_RWFromIStream(s, size);
     if(!sdl_stream)