Mirrors/openrw
1
0
Fork 0
mirror of https://github.com/rwengine/openrw.git synced 2024-11-25 20:02:40 +01:00
Code Issues Projects Releases Activity

rwlib: Use ClumpPtr instead of Clump*

Browse Source 
Should fix these memory leaks:
==22737== 14,598,040 (131,472 direct, 14,466,568 indirect) bytes in 2,739 blocks are definitely lost in loss record 3,124 of 3,126
==22737==    at 0x4C2F1CA: operator new(unsigned long) (vg_replace_malloc.c:334)
==22737==    by 0x90FE4B: LoaderDFF::loadFromMemory(std::shared_ptr<FileContentsInfo>) (LoaderDFF.cpp:443)
==22737==    by 0x7BCC86: GameData::loadModel(unsigned short) (GameData.cpp:474)
==22737==    by 0x7DF7BC: GameWorld::createInstance(unsigned short, glm::tvec3<float, (glm::precision)0> const&, glm::tquat<float, (glm::precision)0> const&) (GameWorld.cpp:144)
==22737==    by 0x7DF44C: GameWorld::placeItems(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) (GameWorld.cpp:120)
==22737==    by 0x758D38: RWGame::newGame() (RWGame.cpp:116)
==22737==    by 0x786389: LoadingState::enter() (LoadingState.cpp:9)
==22737==    by 0x75DC59: void StateManager::enter<LoadingState, RWGame*, RWGame::RWGame(Logger&, int, char**)::{lambda()#1}>(RWGame*&&, RWGame::RWGame(Logger&, int, char**)::{lambda()#1}&&) (StateManager.hpp:40)
==22737==    by 0x758484: RWGame::RWGame(Logger&, int, char**) (RWGame.cpp:81)
==22737==    by 0x747815: main (main.cpp:13)
This commit is contained in:
Anonymous Maarten 2017-09-13 00:47:22 +02:00 committed by Daniel Evans
parent bc8652baba
commit 7e4e1db85d
25 changed files with 85 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
rwengine/src/data/ModelData.hpp
View File

@ -135,14 +135,14 @@ public:
} }
/// @todo change with librw /// @todo change with librw
void setAtomic(Clump* model, int n, AtomicPtr atomic) { void setAtomic(ClumpPtr model, int n, AtomicPtr atomic) {
model_ = model; model_ = model;
/// @todo disassociated the Atomic from Clump /// @todo disassociated the Atomic from Clump
atomics_[n] = atomic; atomics_[n] = atomic;
} }
/// @todo remove this /// @todo remove this
Clump* getModel() const { ClumpPtr getModel() const {
return model_; return model_;
} }
@ -178,11 +178,10 @@ public:
} }
bool isLoaded() const override { bool isLoaded() const override {
return model_ != nullptr; return model_.get() != nullptr;
} }
void unload() override { void unload() override {
delete model_;
model_ = nullptr; model_ = nullptr;
} }
@ -249,7 +248,7 @@ public:
} }
private: private:
Clump* model_ = nullptr; ClumpPtr model_;
std::array<AtomicPtr, 3> atomics_; std::array<AtomicPtr, 3> atomics_;
float loddistances_[3] = {}; float loddistances_[3] = {};
uint8_t numatomics_ = 0; uint8_t numatomics_ = 0;
@ -280,25 +279,24 @@ public:
ClumpModelInfo(ModelDataType type) : BaseModelInfo(type) { ClumpModelInfo(ModelDataType type) : BaseModelInfo(type) {
} }
void setModel(Clump* model) { void setModel(ClumpPtr model) {
model_ = model; model_ = model;
} }
Clump* getModel() const { ClumpPtr getModel() const {
return model_; return model_;
} }
bool isLoaded() const override { bool isLoaded() const override {
return model_ != nullptr; return model_.get() != nullptr;
} }
void unload() override { void unload() override {
delete model_;
model_ = nullptr; model_ = nullptr;
} }
private: private:
Clump* model_ = nullptr; ClumpPtr model_ = nullptr;
}; };
/** /**

2
rwengine/src/engine/Animator.cpp
View File

@ -4,7 +4,7 @@
#include <loaders/LoaderDFF.hpp> #include <loaders/LoaderDFF.hpp>
#include <queue> #include <queue>
Animator::Animator(Clump* model) : model(model) { Animator::Animator(ClumpPtr model) : model(model) {
} }
void Animator::tick(float dt) { void Animator::tick(float dt) {

6
rwengine/src/engine/Animator.hpp
View File

@ -8,7 +8,7 @@
#include <map> #include <map>
#include <rw/defines.hpp> #include <rw/defines.hpp>
class Clump; #include <rw/forward.hpp>
class ModelFrame; class ModelFrame;
/** /**
@ -40,7 +40,7 @@ class Animator {
/** /**
* @brief model The model being animated. * @brief model The model being animated.
*/ */
Clump* model; ClumpPtr model;
/** /**
* @brief Currently playing animations * @brief Currently playing animations
@ -48,7 +48,7 @@ class Animator {
std::vector<AnimationState> animations; std::vector<AnimationState> animations;
public: public:
Animator(Clump* model); Animator(ClumpPtr model);
Animation* getAnimation(unsigned int slot) { Animation* getAnimation(unsigned int slot) {
if (slot < animations.size()) { if (slot < animations.size()) {

2
rwengine/src/engine/GameData.cpp
View File

@ -385,7 +385,7 @@ void GameData::getNameAndLod(std::string& name, int& lod) {
} }
} }
Clump* GameData::loadClump(const std::string& name) { ClumpPtr GameData::loadClump(const std::string& name) {
auto file = index.openFile(name); auto file = index.openFile(name);
if (!file) { if (!file) {
logger->error("Data", "Failed to load model " + name); logger->error("Data", "Failed to load model " + name);

2
rwengine/src/engine/GameData.hpp
View File

@ -133,7 +133,7 @@ public:
/** /**
* Loads an archived model and returns it directly * Loads an archived model and returns it directly
*/ */
Clump* loadClump(const std::string& name); ClumpPtr loadClump(const std::string& name);
/** /**
* Loads a DFF and associates its atomics with models. * Loads a DFF and associates its atomics with models.

4
rwengine/src/objects/CharacterObject.cpp
View File

@ -37,7 +37,7 @@ CharacterObject::CharacterObject(GameWorld* engine, const glm::vec3& pos,
setClump(ClumpPtr(info->getModel()->clone())); setClump(ClumpPtr(info->getModel()->clone()));
if (info->getModel()) { if (info->getModel()) {
setModel(info->getModel()); setModel(info->getModel());
animator = new Animator(getClump().get()); animator = new Animator(getClump());
createActor(); createActor();
} }
@ -279,7 +279,7 @@ void CharacterObject::changeCharacterModel(const std::string& name) {
setModel(newmodel); setModel(newmodel);
animator = new Animator(getClump().get()); animator = new Animator(getClump());
} }
void CharacterObject::updateCharacter(float dt) { void CharacterObject::updateCharacter(float dt) {

6
rwengine/src/objects/CutsceneObject.cpp
View File

@ -1,8 +1,8 @@
#include <engine/Animator.hpp>
#include <objects/CutsceneObject.hpp> #include <objects/CutsceneObject.hpp>
#include <engine/Animator.hpp>
CutsceneObject::CutsceneObject(GameWorld *engine, const glm::vec3 &pos, CutsceneObject::CutsceneObject(GameWorld *engine, const glm::vec3 &pos,
const glm::quat &rot, Clump *model, const glm::quat &rot, ClumpPtr model,
BaseModelInfo *modelinfo) BaseModelInfo *modelinfo)
: GameObject(engine, pos, rot, modelinfo) : GameObject(engine, pos, rot, modelinfo)
, _parent(nullptr) , _parent(nullptr)
@ -14,7 +14,7 @@ CutsceneObject::CutsceneObject(GameWorld *engine, const glm::vec3 &pos,
setModel(getModelInfo<ClumpModelInfo>()->getModel()); setModel(getModelInfo<ClumpModelInfo>()->getModel());
} }
setClump(ClumpPtr(getModel()->clone())); setClump(ClumpPtr(getModel()->clone()));
animator = new Animator(getClump().get()); animator = new Animator(getClump());
} }
CutsceneObject::~CutsceneObject() { CutsceneObject::~CutsceneObject() {

2
rwengine/src/objects/CutsceneObject.hpp
View File

@ -12,7 +12,7 @@ class CutsceneObject : public GameObject, public ClumpObject {
public: public:
CutsceneObject(GameWorld* engine, const glm::vec3& pos, CutsceneObject(GameWorld* engine, const glm::vec3& pos,
const glm::quat& rot, Clump* model, const glm::quat& rot, ClumpPtr model,
BaseModelInfo* modelinfo); BaseModelInfo* modelinfo);
~CutsceneObject(); ~CutsceneObject();

6
rwengine/src/objects/GameObject.hpp
View File

@ -31,7 +31,7 @@ class GameObject {
/** /**
* Model used for rendering * Model used for rendering
*/ */
Clump* model_; ClumpPtr model_;
protected: protected:
void changeModelInfo(BaseModelInfo* next) { void changeModelInfo(BaseModelInfo* next) {
@ -102,14 +102,14 @@ public:
/** /**
* @return The model used in rendering * @return The model used in rendering
*/ */
Clump* getModel() const { ClumpPtr getModel() const {
return model_; return model_;
} }
/** /**
* Changes the current model, used for re-dressing chars * Changes the current model, used for re-dressing chars
*/ */
void setModel(Clump* model) { void setModel(ClumpPtr model) {
model_ = model; model_ = model;
} }

4
rwengine/src/render/GameRenderer.cpp
View File

@ -317,7 +317,7 @@ void GameRenderer::renderWorld(GameWorld* world, const ViewCamera& camera,
m, glm::vec3(i.radius + m, glm::vec3(i.radius +
0.15f * glm::sin(_renderWorld->getGameTime() * 5.f))); 0.15f * glm::sin(_renderWorld->getGameTime() * 5.f)));
objectRenderer.renderClump(sphereModel, m, nullptr, renderList); objectRenderer.renderClump(sphereModel.get(), m, nullptr, renderList);
} }
// Render arrows above anything that isn't radar only (or hidden) // Render arrows above anything that isn't radar only (or hidden)
@ -344,7 +344,7 @@ void GameRenderer::renderWorld(GameWorld* world, const ViewCamera& camera,
glm::vec3(0.f, 0.f, 2.5f + glm::sin(a) * 0.5f)); glm::vec3(0.f, 0.f, 2.5f + glm::sin(a) * 0.5f));
model = glm::rotate(model, a, glm::vec3(0.f, 0.f, 1.f)); model = glm::rotate(model, a, glm::vec3(0.f, 0.f, 1.f));
model = glm::scale(model, glm::vec3(1.5f, 1.5f, 1.5f)); model = glm::scale(model, glm::vec3(1.5f, 1.5f, 1.5f));
objectRenderer.renderClump(arrowModel, model, nullptr, renderList); objectRenderer.renderClump(arrowModel.get(), model, nullptr, renderList);
} }
RW_PROFILE_END(); RW_PROFILE_END();

11
rwengine/src/render/GameRenderer.hpp
View File

@ -174,16 +174,15 @@ public:
* *
* GameRenderer will take ownership of the Model* pointer * GameRenderer will take ownership of the Model* pointer
*/ */
void setSpecialModel(SpecialModel usage, Clump* model) { void setSpecialModel(SpecialModel usage, ClumpPtr model) {
specialmodels_[usage].reset(model); specialmodels_[usage] = model;
} }
private: private:
/// Hard-coded models to use for each of the special models /// Hard-coded models to use for each of the special models
std::unique_ptr<Clump> ClumpPtr specialmodels_[SpecialModel::SpecialModelCount];
specialmodels_[SpecialModel::SpecialModelCount]; ClumpPtr getSpecialModel(SpecialModel usage) const {
Clump* getSpecialModel(SpecialModel usage) const { return specialmodels_[usage];
return specialmodels_[usage].get();
} }
}; };

1
rwlib/CMakeLists.txt
View File

@ -17,6 +17,7 @@ SET(RWLIB_SOURCES
"source/gl/TextureData.cpp" "source/gl/TextureData.cpp"
"source/rw/abort.cpp" "source/rw/abort.cpp"
"source/rw/forward.hpp"
"source/rw/types.hpp" "source/rw/types.hpp"
"source/rw/defines.hpp" "source/rw/defines.hpp"

13
rwlib/source/data/Clump.hpp
View File

@ -12,18 +12,7 @@
#include <gl/TextureData.hpp> #include <gl/TextureData.hpp>
#include <loaders/RWBinaryStream.hpp> #include <loaders/RWBinaryStream.hpp>
// Forward Declerations #include <rw/forward.hpp>
class ModelFrame;
struct Geometry;
class Atomic;
class Clump;
// Pointer types
using ModelFramePtr = std::shared_ptr<ModelFrame>;
using GeometryPtr = std::shared_ptr<Geometry>;
using AtomicPtr = std::shared_ptr<Atomic>;
using AtomicList = std::vector<AtomicPtr>;
using ClumpPtr = std::shared_ptr<Clump>;
/** /**
* ModelFrame stores transformation hierarchy * ModelFrame stores transformation hierarchy

4
rwlib/source/loaders/LoaderDFF.cpp
View File

@ -439,8 +439,8 @@ AtomicPtr LoaderDFF::readAtomic(FrameList &framelist,
return atomic; return atomic;
} }
Clump *LoaderDFF::loadFromMemory(FileHandle file) { ClumpPtr LoaderDFF::loadFromMemory(FileHandle file) {
auto model = new Clump; auto model = std::make_shared<Clump>();
RWBStream rootStream(file->data, file->length); RWBStream rootStream(file->data, file->length);

2
rwlib/source/loaders/LoaderDFF.hpp
View File

@ -29,7 +29,7 @@ public:
using GeometryList = std::vector<GeometryPtr>; using GeometryList = std::vector<GeometryPtr>;
using FrameList = std::vector<ModelFramePtr>; using FrameList = std::vector<ModelFramePtr>;
Clump* loadFromMemory(FileHandle file); ClumpPtr loadFromMemory(FileHandle file);
void setTextureLookupCallback(TextureLookupCallback tlc) { void setTextureLookupCallback(TextureLookupCallback tlc) {
texturelookup = tlc; texturelookup = tlc;

22
rwlib/source/rw/forward.hpp Normal file
View File

@ -0,0 +1,22 @@
#ifndef RWLIB_FORWARD_HPP
#define RWLIB_FORWARD_HPP
#include <memory>
#include <vector>
// Forward Declarations
class Clump;
class ModelFrame;
struct Geometry;
class Atomic;
class Clump;
// Pointer types
using ModelFramePtr = std::shared_ptr<ModelFrame>;
using GeometryPtr = std::shared_ptr<Geometry>;
using AtomicPtr = std::shared_ptr<Atomic>;
using AtomicList = std::vector<AtomicPtr>;
using ClumpPtr = std::shared_ptr<Clump>;
#endif /* FORWARD_HPP */

8
rwviewer/ViewerWidget.cpp
View File

@ -103,7 +103,7 @@ void ViewerWidget::paintGL() {
vc.frustum.fov = viewFov; vc.frustum.fov = viewFov;
vc.frustum.aspectRatio = width() / (height() * 1.f); vc.frustum.aspectRatio = width() / (height() * 1.f);
Clump* model = activeModel; ClumpPtr model = activeModel;
if (model != _lastModel) { if (model != _lastModel) {
_lastModel = model; _lastModel = model;
emit modelChanged(_lastModel); emit modelChanged(_lastModel);
@ -133,7 +133,7 @@ void ViewerWidget::paintGL() {
ObjectRenderer renderer(world(), vc, 1.f, 0); ObjectRenderer renderer(world(), vc, 1.f, 0);
RenderList renders; RenderList renders;
renderer.renderClump(model, glm::mat4(), nullptr, renders); renderer.renderClump(model.get(), glm::mat4(), nullptr, renders);
r.getRenderer()->drawBatched(renders); r.getRenderer()->drawBatched(renders);
drawFrameWidget(model->getFrame().get()); drawFrameWidget(model->getFrame().get());
@ -207,7 +207,7 @@ void ViewerWidget::showObject(qint16 item) {
} }
} }
void ViewerWidget::showModel(Clump* model) { void ViewerWidget::showModel(ClumpPtr model) {
if (dummyObject) gworld->destroyObject(dummyObject); if (dummyObject) gworld->destroyObject(dummyObject);
dummyObject = nullptr; dummyObject = nullptr;
activeModel = model; activeModel = model;
@ -269,7 +269,7 @@ void ViewerWidget::keyReleaseEvent(QKeyEvent* e) {
if (e->key() == Qt::Key_Shift) moveFast = false; if (e->key() == Qt::Key_Shift) moveFast = false;
} }
Clump* ViewerWidget::currentModel() const { ClumpPtr ViewerWidget::currentModel() const {
return activeModel; return activeModel;
} }

10
rwviewer/ViewerWidget.hpp
View File

@ -27,12 +27,12 @@ class ViewerWidget : public QGLWidget {
QTimer timer; QTimer timer;
GameWorld* gworld; GameWorld* gworld;
Clump* activeModel; ClumpPtr activeModel;
ModelFrame* selectedFrame; ModelFrame* selectedFrame;
GameObject* dummyObject; GameObject* dummyObject;
quint16 currentObjectID; quint16 currentObjectID;
Clump* _lastModel; ClumpPtr _lastModel;
Animation* canimation; Animation* canimation;
float viewDistance; float viewDistance;
@ -60,7 +60,7 @@ public:
virtual void paintGL(); virtual void paintGL();
Clump* currentModel() const; ClumpPtr currentModel() const;
GameObject* currentObject() const; GameObject* currentObject() const;
GameWorld* world(); GameWorld* world();
@ -68,7 +68,7 @@ public:
public slots: public slots:
void showObject(qint16 item); void showObject(qint16 item);
void showModel(Clump* model); void showModel(ClumpPtr model);
void selectFrame(ModelFrame* frame); void selectFrame(ModelFrame* frame);
void exportModel(); void exportModel();
@ -81,7 +81,7 @@ signals:
void fileOpened(const QString& file); void fileOpened(const QString& file);
void modelChanged(Clump* model); void modelChanged(ClumpPtr model);
protected: protected:
void keyPressEvent(QKeyEvent*) override; void keyPressEvent(QKeyEvent*) override;

2
rwviewer/models/DFFFramesTreeModel.cpp
View File

@ -1,7 +1,7 @@
#include "DFFFramesTreeModel.hpp" #include "DFFFramesTreeModel.hpp"
#include <data/Clump.hpp> #include <data/Clump.hpp>
DFFFramesTreeModel::DFFFramesTreeModel(Clump* m, DFFFramesTreeModel::DFFFramesTreeModel(ClumpPtr m,
QObject* parent) QObject* parent)
: QAbstractItemModel(parent), model(m) { : QAbstractItemModel(parent), model(m) {
} }

7
rwviewer/models/DFFFramesTreeModel.hpp
View File

@ -2,15 +2,14 @@
#ifndef _DFFFRAMESTREEMODEL_HPP_ #ifndef _DFFFRAMESTREEMODEL_HPP_
#define _DFFFRAMESTREEMODEL_HPP_ #define _DFFFRAMESTREEMODEL_HPP_
#include <QAbstractItemModel> #include <QAbstractItemModel>
#include <rw/forward.hpp>
#include <rw/types.hpp> #include <rw/types.hpp>
class Clump;
class DFFFramesTreeModel : public QAbstractItemModel { class DFFFramesTreeModel : public QAbstractItemModel {
Clump* model; ClumpPtr model;
public: public:
explicit DFFFramesTreeModel(Clump* m, QObject* parent = 0); explicit DFFFramesTreeModel(ClumpPtr m, QObject* parent = 0);
virtual int columnCount(const QModelIndex& parent = QModelIndex()) const; virtual int columnCount(const QModelIndex& parent = QModelIndex()) const;

2
rwviewer/views/ModelViewer.cpp
View File

@ -39,7 +39,7 @@ void ModelViewer::setViewerWidget(ViewerWidget* widget) {
showModel(viewing); showModel(viewing);
} }
void ModelViewer::showModel(Clump* model) { void ModelViewer::showModel(ClumpPtr model) {
viewing = model; viewing = model;
viewerWidget->showModel(model); viewerWidget->showModel(model);
frames->setModel(model); frames->setModel(model);

4
rwviewer/views/ModelViewer.hpp
View File

@ -21,7 +21,7 @@ class Animation;
class ModelViewer : public ViewerInterface { class ModelViewer : public ViewerInterface {
Q_OBJECT Q_OBJECT
Clump* viewing; ClumpPtr viewing;
QSplitter* mainSplit; QSplitter* mainSplit;
QVBoxLayout* mainLayout; QVBoxLayout* mainLayout;
@ -43,7 +43,7 @@ public slots:
/** /**
* Display a raw model * Display a raw model
*/ */
void showModel(Clump* model); void showModel(ClumpPtr model);
/** /**
* Display a game object's model * Display a game object's model

6
rwviewer/widgets/ModelFramesWidget.cpp
View File

@ -2,7 +2,7 @@
#include <data/Clump.hpp> #include <data/Clump.hpp>
#include <glm/gtx/string_cast.hpp> #include <glm/gtx/string_cast.hpp>
void ModelFramesWidget::updateInfoBox(Clump* model, ModelFrame* f) { void ModelFramesWidget::updateInfoBox(ClumpPtr model, ModelFrame* f) {
if (f == nullptr) { if (f == nullptr) {
_frameLabel->setText(""); _frameLabel->setText("");
} else { } else {
@ -33,14 +33,14 @@ ModelFramesWidget::ModelFramesWidget(QWidget* parent, Qt::WindowFlags flags)
setLayout(_layout); setLayout(_layout);
} }
void ModelFramesWidget::setModel(Clump* model) { void ModelFramesWidget::setModel(ClumpPtr model) {
if (framemodel) { if (framemodel) {
delete framemodel; delete framemodel;
framemodel = nullptr; framemodel = nullptr;
tree->setModel(nullptr); tree->setModel(nullptr);
} }
gmodel = model; gmodel = model;
if (model != nullptr) { if (model.get() != nullptr) {
framemodel = new DFFFramesTreeModel(model, this); framemodel = new DFFFramesTreeModel(model, this);
tree->setModel(framemodel); tree->setModel(framemodel);
tree->setDisabled(false); tree->setDisabled(false);

6
rwviewer/widgets/ModelFramesWidget.hpp
View File

@ -13,7 +13,7 @@ class ModelFrame;
class ModelFramesWidget : public QWidget { class ModelFramesWidget : public QWidget {
Q_OBJECT Q_OBJECT
Clump* gmodel; ClumpPtr gmodel;
DFFFramesTreeModel* framemodel; DFFFramesTreeModel* framemodel;
QTreeView* tree; QTreeView* tree;
QVBoxLayout* _layout; QVBoxLayout* _layout;
@ -21,7 +21,7 @@ class ModelFramesWidget : public QWidget {
private slots: private slots:
void updateInfoBox(Clump* model, ModelFrame* f); void updateInfoBox(ClumpPtr model, ModelFrame* f);
void selectedModelChanged(const QModelIndex&, const QModelIndex&); void selectedModelChanged(const QModelIndex&, const QModelIndex&);
@ -30,7 +30,7 @@ public:
public slots: public slots:
void setModel(Clump* model); void setModel(ClumpPtr model);
signals: signals:

6
tests/test_loaderdff.cpp
View File

@ -11,9 +11,9 @@ BOOST_AUTO_TEST_CASE(test_load_dff) {
LoaderDFF loader; LoaderDFF loader;
Clump* m = loader.loadFromMemory(d); auto m = loader.loadFromMemory(d);
BOOST_REQUIRE(m != nullptr); BOOST_REQUIRE(m.get() != nullptr);
BOOST_REQUIRE(m->getFrame()); BOOST_REQUIRE(m->getFrame());
@ -23,7 +23,7 @@ BOOST_AUTO_TEST_CASE(test_load_dff) {
BOOST_REQUIRE(atomic->getGeometry()); BOOST_REQUIRE(atomic->getGeometry());
BOOST_REQUIRE(atomic->getFrame()); BOOST_REQUIRE(atomic->getFrame());
delete m; m.reset();
} }
} }