Track::~Track() {
setLoader(nullptr);
// clean up vertex array, which is generated in the constructor
glDeleteVertexArraysAPPLE(1, &vertexArrayObjectHandle);
glDeleteBuffers(1, &vertexBuffer);
glDeleteBuffers(1, &normalBuffer);
glDeleteBuffers(1, &indexBuffer);
}
std::shared_ptr<Layer> CImgLayerReader::readData(std::string filePath) {
if (!filesystem::fileExists(filePath)) {
std::string newPath = filesystem::addBasePath(filePath);
if (filesystem::fileExists(newPath)) {
filePath = newPath;
} else {
throw DataReaderException("Error could not find input file: " + filePath, IvwContext);
}
}
auto layer = std::make_shared<Layer>();
auto layerDisk = std::make_shared<LayerDisk>(filePath);
layerDisk->setLoader(new CImgLayerRAMLoader(layerDisk.get()));
layer->addRepresentation(layerDisk);
return layer;
}
std::shared_ptr<Volume> CImgVolumeReader::readData(std::string filePath) {
if (!filesystem::fileExists(filePath)) {
std::string newPath = filesystem::addBasePath(filePath);
if (filesystem::fileExists(newPath)) {
filePath = newPath;
}
else {
throw DataReaderException("Error could not find input file: " + filePath, IvwContext);
}
}
auto volume = std::make_shared<Volume>();
auto volumeDisk = std::make_shared<VolumeDisk>(filePath);
volumeDisk->setLoader(new CImgVolumeRAMLoader(volumeDisk.get()));
volume->addRepresentation(volumeDisk);
return volume;
}
std::shared_ptr<Volume> IvfVolumeReader::readData(std::string filePath) {
if (!filesystem::fileExists(filePath)) {
std::string newPath = filesystem::addBasePath(filePath);
if (filesystem::fileExists(newPath)) {
filePath = newPath;
} else {
throw DataReaderException("Error could not find input file: " + filePath, IvwContext);
}
}
std::string fileDirectory = filesystem::getFileDirectory(filePath);
auto volume = std::make_shared<Volume>();
Deserializer d(InviwoApplication::getPtr(), filePath);
d.deserialize("RawFile", rawFile_);
rawFile_ = fileDirectory + "/" + rawFile_;
std::string formatFlag("");
d.deserialize("Format", formatFlag);
format_ = DataFormatBase::get(formatFlag);
mat4 basisAndOffset;
d.deserialize("BasisAndOffset", basisAndOffset);
volume->setModelMatrix(basisAndOffset);
mat4 worldTransform;
d.deserialize("WorldTransform", worldTransform);
volume->setWorldMatrix(worldTransform);
d.deserialize("Dimension", dimensions_);
volume->setDimensions(dimensions_);
d.deserialize("DataRange", volume->dataMap_.dataRange);
d.deserialize("ValueRange", volume->dataMap_.valueRange);
d.deserialize("Unit", volume->dataMap_.valueUnit);
volume->getMetaDataMap()->deserialize(d);
littleEndian_ = volume->getMetaData<BoolMetaData>("LittleEndian", littleEndian_);
auto vd = std::make_shared<VolumeDisk>(filePath, dimensions_, format_);
auto loader = util::make_unique<RawVolumeRAMLoader>(rawFile_, filePos_, dimensions_,
littleEndian_, format_);
vd->setLoader(loader.release());
volume->addRepresentation(vd);
return volume;
}
Track::Track(GLint givenVertexBufferLoc,
GLint givenNormalBufferLoc) {
setLoader(new ObjLoader());
ObjLoader * myLoaderRef = getLoader();
myLoaderRef -> loadObj(TRACK_PATH, MTL_BASEPATH);
// In this OpenGL program, x-z is the horizontal plane.
// The following code snippet grabs the x and z coordinates of all the
// vertices that are at the bottom of the inner walls of the track.
//std::cout << "ListPlot[ { " << std::endl;
std::vector<GLfloat> vertices = myLoaderRef->getVertices();
for (int i = 0; i < vertices.size(); i += 3) {
if (vertices[i + 1] > 1) continue;
//if (i) std::cout << ", ";
//std::cout << "{" << vertices[i] << ", " << vertices[i + 2] << "}";
walls.push_back(glm::vec2(vertices[i], vertices[i+2]));
}
//std::cout << " } ]" << std::endl;
glGenBuffers(1, &vertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glBufferData(GL_ARRAY_BUFFER,
myLoaderRef -> getVertices().size() * sizeof(GLfloat),
myLoaderRef -> getVertices().data(),
GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &normalBuffer);
glBindBuffer(GL_ARRAY_BUFFER, normalBuffer);
glBufferData(GL_ARRAY_BUFFER,
myLoaderRef -> getNormals().size() * sizeof(GLfloat),
myLoaderRef -> getNormals().data(),
GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &indexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
myLoaderRef -> getIndices().size() * sizeof(GLuint),
myLoaderRef -> getIndices().data(),
GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
vertexCount = (unsigned int) myLoaderRef -> getIndices().size();
// setup initial model matrix
scaleMatrix = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, -1.0f, 0.0f)) * glm::mat4(1.0f);
setModelMatrix(scaleMatrix);
// wrap states using vao
glGenVertexArraysAPPLE(1, &vertexArrayObjectHandle);
glBindVertexArrayAPPLE(vertexArrayObjectHandle);
// bind vertex array
glEnableVertexAttribArray(givenVertexBufferLoc);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glVertexAttribPointer(givenVertexBufferLoc,
3, // to simplify program, we always use triangles
GL_FLOAT, // type of elements in vertex buffer is GLfloat
GL_FALSE, // not normalized
0, // to simplify program, we keep each object in a homogeneous buffer
0);
glEnableVertexAttribArray(givenNormalBufferLoc);
glBindBuffer(GL_ARRAY_BUFFER, normalBuffer);
glVertexAttribPointer(givenNormalBufferLoc,
3,
GL_FLOAT,
GL_FALSE,
0,
0);
// bind index array
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
// finished: unbind vao to clear state
glBindVertexArrayAPPLE(0);
}
namespace Magnum { namespace Test {
struct ResourceManagerTest: TestSuite::Tester {
explicit ResourceManagerTest();
void state();
void stateFallback();
void stateDisallowed();
void basic();
void residentPolicy();
void referenceCountedPolicy();
void manualPolicy();
void defaults();
void clear();
void clearWhileReferenced();
void loader();
};
struct Data {
static std::size_t count;
explicit Data() { ++count; }
~Data() { --count; }
};
typedef Magnum::ResourceManager<Int, Data> ResourceManager;
size_t Data::count = 0;
ResourceManagerTest::ResourceManagerTest() {
addTests({&ResourceManagerTest::state,
&ResourceManagerTest::stateFallback,
&ResourceManagerTest::stateDisallowed,
&ResourceManagerTest::basic,
&ResourceManagerTest::residentPolicy,
&ResourceManagerTest::referenceCountedPolicy,
&ResourceManagerTest::manualPolicy,
&ResourceManagerTest::defaults,
&ResourceManagerTest::clear,
&ResourceManagerTest::clearWhileReferenced,
&ResourceManagerTest::loader});
}
void ResourceManagerTest::state() {
ResourceManager rm;
Resource<Data> data = rm.get<Data>("data");
CORRADE_VERIFY(!data);
CORRADE_COMPARE(data.state(), ResourceState::NotLoaded);
CORRADE_COMPARE(rm.state<Data>("data"), ResourceState::NotLoaded);
rm.set<Data>("data", nullptr, ResourceDataState::Loading, ResourcePolicy::Resident);
CORRADE_VERIFY(!data);
CORRADE_COMPARE(data.state(), ResourceState::Loading);
CORRADE_COMPARE(rm.state<Data>("data"), ResourceState::Loading);
rm.set<Data>("data", nullptr, ResourceDataState::NotFound, ResourcePolicy::Resident);
CORRADE_VERIFY(!data);
CORRADE_COMPARE(data.state(), ResourceState::NotFound);
CORRADE_COMPARE(rm.state<Data>("data"), ResourceState::NotFound);
/* Nothing happened at all */
CORRADE_COMPARE(Data::count, 0);
}
void ResourceManagerTest::stateFallback() {
{
ResourceManager rm;
rm.setFallback(new Data);
Resource<Data> data = rm.get<Data>("data");
CORRADE_VERIFY(data);
CORRADE_COMPARE(data.state(), ResourceState::NotLoadedFallback);
CORRADE_COMPARE(rm.state<Data>("data"), ResourceState::NotLoadedFallback);
rm.set<Data>("data", nullptr, ResourceDataState::Loading, ResourcePolicy::Resident);
CORRADE_VERIFY(data);
CORRADE_COMPARE(data.state(), ResourceState::LoadingFallback);
CORRADE_COMPARE(rm.state<Data>("data"), ResourceState::LoadingFallback);
rm.set<Data>("data", nullptr, ResourceDataState::NotFound, ResourcePolicy::Resident);
CORRADE_VERIFY(data);
CORRADE_COMPARE(data.state(), ResourceState::NotFoundFallback);
CORRADE_COMPARE(rm.state<Data>("data"), ResourceState::NotFoundFallback);
/* Only fallback is here */
CORRADE_COMPARE(Data::count, 1);
}
/* Fallback gets destroyed */
CORRADE_COMPARE(Data::count, 0);
}
void ResourceManagerTest::stateDisallowed() {
ResourceManager rm;
std::ostringstream out;
Error::setOutput(&out);
rm.set("data", Data(), ResourceDataState::Loading, ResourcePolicy::Resident);
CORRADE_COMPARE(out.str(), "ResourceManager::set(): data should be null if and only if state is NotFound or Loading\n");
out.str({});
rm.set<Data>("data", nullptr, ResourceDataState::Final, ResourcePolicy::Resident);
CORRADE_COMPARE(out.str(), "ResourceManager::set(): data should be null if and only if state is NotFound or Loading\n");
}
void ResourceManagerTest::basic() {
ResourceManager rm;
/* One mutable, one final */
ResourceKey questionKey("the-question");
ResourceKey answerKey("the-answer");
rm.set(questionKey, 10, ResourceDataState::Mutable, ResourcePolicy::Resident);
rm.set(answerKey, 42, ResourceDataState::Final, ResourcePolicy::Resident);
Resource<Int> theQuestion = rm.get<Int>(questionKey);
Resource<Int> theAnswer = rm.get<Int>(answerKey);
/* Check basic functionality */
CORRADE_COMPARE(theQuestion.state(), ResourceState::Mutable);
CORRADE_COMPARE(theAnswer.state(), ResourceState::Final);
CORRADE_COMPARE(*theQuestion, 10);
CORRADE_COMPARE(*theAnswer, 42);
CORRADE_COMPARE(rm.count<Int>(), 2);
/* Cannot change already final resource */
std::ostringstream out;
Error::setOutput(&out);
rm.set(answerKey, 43, ResourceDataState::Mutable, ResourcePolicy::Resident);
CORRADE_COMPARE(*theAnswer, 42);
CORRADE_COMPARE(out.str(), "ResourceManager::set(): cannot change already final resource " + answerKey.hexString() + '\n');
/* But non-final can be changed */
rm.set(questionKey, 20, ResourceDataState::Final, ResourcePolicy::Resident);
CORRADE_COMPARE(theQuestion.state(), ResourceState::Final);
CORRADE_COMPARE(*theQuestion, 20);
}
void ResourceManagerTest::residentPolicy() {
ResourceManager* rm = new ResourceManager;
rm->set("blah", new Data, ResourceDataState::Mutable, ResourcePolicy::Resident);
CORRADE_COMPARE(Data::count, 1);
rm->free();
CORRADE_COMPARE(Data::count, 1);
delete rm;
CORRADE_COMPARE(Data::count, 0);
}
void ResourceManagerTest::referenceCountedPolicy() {
ResourceManager rm;
ResourceKey dataRefCountKey("dataRefCount");
/* Resource is deleted after all references are removed */
rm.set(dataRefCountKey, new Data, ResourceDataState::Final, ResourcePolicy::ReferenceCounted);
CORRADE_COMPARE(rm.count<Data>(), 1);
{
Resource<Data> data = rm.get<Data>(dataRefCountKey);
CORRADE_COMPARE(data.state(), ResourceState::Final);
CORRADE_COMPARE(Data::count, 1);
}
CORRADE_COMPARE(rm.count<Data>(), 0);
CORRADE_COMPARE(Data::count, 0);
/* Reference counted resources which were not used once will stay loaded
until free() is called */
rm.set(dataRefCountKey, new Data, ResourceDataState::Final, ResourcePolicy::ReferenceCounted);
CORRADE_COMPARE(rm.count<Data>(), 1);
CORRADE_COMPARE(rm.state<Data>(dataRefCountKey), ResourceState::Final);
CORRADE_COMPARE(rm.referenceCount<Data>(dataRefCountKey), 0);
rm.free<Data>();
CORRADE_COMPARE(rm.count<Data>(), 0);
CORRADE_COMPARE(rm.state<Data>(dataRefCountKey), ResourceState::NotLoaded);
CORRADE_COMPARE(rm.referenceCount<Data>(dataRefCountKey), 0);
}
void ResourceManagerTest::manualPolicy() {
ResourceManager rm;
ResourceKey dataKey("data");
/* Manual free */
{
rm.set(dataKey, new Data, ResourceDataState::Mutable, ResourcePolicy::Manual);
Resource<Data> data = rm.get<Data>(dataKey);
rm.free();
}
CORRADE_COMPARE(rm.count<Data>(), 1);
CORRADE_COMPARE(Data::count, 1);
rm.free();
CORRADE_COMPARE(rm.count<Data>(), 0);
CORRADE_COMPARE(Data::count, 0);
rm.set(dataKey, new Data, ResourceDataState::Mutable, ResourcePolicy::Manual);
CORRADE_COMPARE(rm.count<Data>(), 1);
CORRADE_COMPARE(Data::count, 1);
}
void ResourceManagerTest::defaults() {
ResourceManager rm;
rm.set("data", new Data);
CORRADE_COMPARE(rm.state<Data>("data"), ResourceState::Final);
}
void ResourceManagerTest::clear() {
ResourceManager rm;
rm.set("blah", new Data);
CORRADE_COMPARE(Data::count, 1);
rm.free();
CORRADE_COMPARE(Data::count, 1);
rm.clear();
CORRADE_COMPARE(Data::count, 0);
}
void ResourceManagerTest::clearWhileReferenced() {
/* Should cover also the destruction case */
std::ostringstream out;
Error::setOutput(&out);
ResourceManager rm;
rm.set("blah", Int());
/** @todo this will leak, is there any better solution without hitting
assertion in decrementReferenceCount()? */
new Resource<Int>(rm.get<Int>("blah"));
rm.clear();
CORRADE_COMPARE(out.str(), "ResourceManager: cleared/destroyed while data are still referenced\n");
}
void ResourceManagerTest::loader() {
class IntResourceLoader: public AbstractResourceLoader<Int> {
public:
IntResourceLoader(): resource(ResourceManager::instance().get<Data>("data")) {}
void load() {
set("hello", 773, ResourceDataState::Final, ResourcePolicy::Resident);
setNotFound("world");
}
private:
void doLoad(ResourceKey) override {}
std::string doName(ResourceKey key) const override {
if(key == ResourceKey("hello")) return "hello";
return "";
}
/* To verify that the loader is destroyed before unloading
_all types of_ resources */
Resource<Data> resource;
};
auto rm = new ResourceManager;
auto loader = new IntResourceLoader;
rm->setLoader(loader);
{
Resource<Data> data = rm->get<Data>("data");
Resource<Int> hello = rm->get<Int>("hello");
Resource<Int> world = rm->get<Int>("world");
CORRADE_COMPARE(data.state(), ResourceState::NotLoaded);
CORRADE_COMPARE(hello.state(), ResourceState::Loading);
CORRADE_COMPARE(world.state(), ResourceState::Loading);
CORRADE_COMPARE(loader->requestedCount(), 2);
CORRADE_COMPARE(loader->loadedCount(), 0);
CORRADE_COMPARE(loader->notFoundCount(), 0);
CORRADE_COMPARE(loader->name(ResourceKey("hello")), "hello");
loader->load();
CORRADE_COMPARE(hello.state(), ResourceState::Final);
CORRADE_COMPARE(*hello, 773);
CORRADE_COMPARE(world.state(), ResourceState::NotFound);
CORRADE_COMPARE(loader->requestedCount(), 2);
CORRADE_COMPARE(loader->loadedCount(), 1);
CORRADE_COMPARE(loader->notFoundCount(), 1);
/* Verify that the loader is deleted at proper time */
rm->set("data", new Data);
CORRADE_COMPARE(Data::count, 1);
}
delete rm;
CORRADE_COMPARE(Data::count, 0);
}
}}
