Use shared_ptr in Game Engine layout? - c++

Question

I have written a little game engine in c++ and it works ok but is not the best performance wise. I also learned a lot and I want to redo it now. But last time I heavily used shared_ptr for classes like gui textures and model wrappers (that hold i.e. the 3d position and the opengl vao). I've heared that shared_ptr should not really be used, but I dont really know how to do it any other way. Here's the pseudo-code-like layout:
This code is not complete or working but I want to share the idea of my layout
// d3 stands for 3d
class D3Model {
VAO vao;
bool useBloom;
unsigned int texture;
// ... and so on
static std::vector<std::shared_ptr<D3Model>> models; // current idea, approach 1
static std::vector<D3Model> models1; // different approach (2)
D3Model() {
models.push_back(shared_from_this()); // app.1
models1.push_back(*this);
}
}
// main file
int main() {
std::shared_ptr<D3Model> model = std::make_shared<D3Model>();
model->setTexture(0); // ignore the non sense content
D3Model model1;
model1.setTexture(0); // would not get updated in the vector
while(true) {
model->increaseRotation(1);
model1.increaseRotation(1);
Renderer::render();
}
}
// different file
class Renderer {
static void render() {
for(const auto& all : D3Model::models) {
// render model
}
for(const auto& all : D3Model::models1) {
// render model1, would not have increased rotation
}
}
}
For more clarification, imagine the following use of the engine:
After hitting play on a start screen, the engine loads some 3d models from files and stores them. One of them gets rotated every frame and every one of them gets rendered. Maybe some other models must be loaded after because of a change in gameplay (Player joined...). Then they all get deleted when the user returns to the main menu. My problem with approach 2 is that I'd have to update the vector everytime the rotation of the model is increased, whereas that would automatically be handled with approach 1. However, I have heared that shared_ptr is bad for performance.
Is shared_ptr for this case the best solution or should I just use normal objects? But my problem with that is how would I apply changes to the object (the setTexture for example) without having to update the vector content. And raw pointers arent really good either. How is something like that done?
Thanks, unreal

Answer 1

Ok you can create yor own RefCouner class like me:
/// RefCounter.hpp
#pragma once
class RefCounter {
public:
RefCounter();
RefCounter(const RefCounter&);
RefCounter& operator=(const RefCounter&);
void grab();
usize reference() const;
bool release();
protected:
virtual void finalize();
virtual ~RefCounter();
private:
usize _reference;
};
template<typename T>
struct ref {
inline ref() : class_ptr (nullptr) {}
inline ref(T* obj) : class_ptr (obj) { if(class_ptr) class_ptr->grab(); }
inline ref(const ref& other) : class_ptr (other.class_ptr) { if(class_ptr) class_ptr->grab(); }
inline ref& operator=(T* obj) {
if(obj)
obj->grab();
if(class_ptr)
class_ptr->release();
class_ptr = obj;
return *this;
}
inline ref& operator=(const ref& other){
T* obj = other.class_ptr;
if(obj)
obj->grab();
if(class_ptr)
class_ptr->release();
class_ptr = obj;
return *this;
}
T* get() const {
return class_ptr;
}
operator T*() const {
return class_ptr;
}
T* operator->() const {
return class_ptr;
}
inline ~ref() {
if(class_ptr)
class_ptr->release();
}
private:
T* class_ptr;
};
/// RefCounter.cpp
RefCounter::RefCounter() : _reference(0){
}
RefCounter::RefCounter(const RefCounter&) : _reference(0) {
}
RefCounter& RefCounter::operator=(const RefCounter&) {
return *this;
}
void RefCounter::grab() {
_reference++;
}
usize RefCounter::reference() const {
return _reference;
}
bool RefCounter::release() {
if(_reference > 1) {
_reference--;
return false;
} else {
_reference = 0;
finalize();
return true;
}
}
void RefCounter::finalize() {
delete this;
}
RefCounter::~RefCounter() {
}