147 lines
4.6 KiB
C++
147 lines
4.6 KiB
C++
#include "OpenGLVegetationLayer.h"
|
|
|
|
#include "CameraDefinition.h"
|
|
#include "Mutex.h"
|
|
#include "OpenGLFunctions.h"
|
|
#include "OpenGLVegetation.h"
|
|
#include "OpenGLVegetationImpostor.h"
|
|
#include "OpenGLVegetationInstance.h"
|
|
#include "Vector3.h"
|
|
#include "VegetationLayerDefinition.h"
|
|
#include "VegetationPresenceDefinition.h"
|
|
#include <algorithm>
|
|
|
|
OpenGLVegetationLayer::OpenGLVegetationLayer(OpenGLVegetation *parent, VegetationLayerDefinition *definition,
|
|
bool own_instances)
|
|
: parent(parent), definition(definition), own_instances(own_instances) {
|
|
lock_instances = new Mutex;
|
|
camera_location = new Vector3(0.0, 0.0, 0.0);
|
|
impostor = new OpenGLVegetationImpostor();
|
|
range = 10.0;
|
|
|
|
reset();
|
|
}
|
|
|
|
OpenGLVegetationLayer::~OpenGLVegetationLayer() {
|
|
delete camera_location;
|
|
delete lock_instances;
|
|
delete impostor;
|
|
}
|
|
|
|
void OpenGLVegetationLayer::produceInstancesInArea(double xmin, double xmax, double zmin, double zmax,
|
|
vector<OpenGLVegetationInstance *> *instances) const {
|
|
vector<VegetationInstance> result;
|
|
definition->getPresence()->collectInstances(&result, *definition->getModel(), xmin, zmin, xmax, zmax, false);
|
|
for (auto raw_instance : result) {
|
|
instances->push_back(new OpenGLVegetationInstance(raw_instance));
|
|
}
|
|
}
|
|
|
|
static bool isNull(void *ptr) {
|
|
return ptr == NULL;
|
|
}
|
|
|
|
static bool compareInstances(OpenGLVegetationInstance *instance1, OpenGLVegetationInstance *instance2) {
|
|
return instance1->getDistance() > instance2->getDistance();
|
|
}
|
|
|
|
void OpenGLVegetationLayer::removeInstancesOutsideArea(double xmin, double xmax, double zmin, double zmax,
|
|
vector<OpenGLVegetationInstance *> *instances) const {
|
|
for (auto &instance : *instances) {
|
|
Vector3 base = instance->getBase();
|
|
if (base.x < xmin or base.x >= xmax or base.z < zmin or base.z >= zmax) {
|
|
if (own_instances) {
|
|
delete instance;
|
|
}
|
|
instance = NULL;
|
|
}
|
|
}
|
|
instances->erase(remove_if(instances->begin(), instances->end(), isNull), instances->end());
|
|
}
|
|
|
|
void OpenGLVegetationLayer::updateInstances() {
|
|
// Compute new area around camera
|
|
double newxmin, newxmax, newzmin, newzmax;
|
|
newxmin = camera_location->x - range;
|
|
newxmax = camera_location->x + range;
|
|
newzmin = camera_location->z - range;
|
|
newzmax = camera_location->z + range;
|
|
|
|
// Prepare instances where area grew
|
|
vector<OpenGLVegetationInstance *> new_instances;
|
|
if (newxmin < xmin) {
|
|
produceInstancesInArea(newxmin, xmin, newzmin, newzmax, &new_instances);
|
|
}
|
|
if (newxmax > xmax) {
|
|
produceInstancesInArea(xmax, newxmax, newzmin, newzmax, &new_instances);
|
|
}
|
|
if (newzmin < zmin) {
|
|
produceInstancesInArea(xmin, xmax, newzmin, zmin, &new_instances);
|
|
}
|
|
if (newzmax > zmax) {
|
|
produceInstancesInArea(xmin, xmax, zmax, newzmax, &new_instances);
|
|
}
|
|
|
|
// Apply the changes
|
|
lock_instances->acquire();
|
|
xmin = newxmin;
|
|
xmax = newxmax;
|
|
zmin = newzmin;
|
|
zmax = newzmax;
|
|
removeInstancesOutsideArea(xmin, xmax, zmin, zmax, &instances);
|
|
instances.insert(instances.end(), new_instances.begin(), new_instances.end());
|
|
for (auto instance : instances) {
|
|
instance->setDistance(instance->getBase().sub(*camera_location).getNorm());
|
|
}
|
|
sort(instances.begin(), instances.end(), compareInstances);
|
|
lock_instances->release();
|
|
}
|
|
|
|
void OpenGLVegetationLayer::updateImpostor() {
|
|
bool interrupted = false;
|
|
impostor->prepareTexture(*definition->getModel(), *parent->getScenery(), &interrupted);
|
|
}
|
|
|
|
void OpenGLVegetationLayer::threadedUpdate() {
|
|
if (camera_changed) {
|
|
camera_changed = false;
|
|
|
|
updateInstances();
|
|
updateImpostor();
|
|
}
|
|
}
|
|
|
|
void OpenGLVegetationLayer::render() {
|
|
lock_instances->acquire();
|
|
|
|
// TODO Instanced rendering
|
|
for (auto instance : instances) {
|
|
impostor->render(parent->getProgram(), instance, *camera_location);
|
|
}
|
|
|
|
lock_instances->release();
|
|
}
|
|
|
|
void OpenGLVegetationLayer::reset() {
|
|
lock_instances->acquire();
|
|
camera_changed = true;
|
|
xmin = 0.0;
|
|
xmax = 0.0;
|
|
zmin = 0.0;
|
|
zmax = 0.0;
|
|
if (own_instances) {
|
|
for (auto instance : instances) {
|
|
delete instance;
|
|
}
|
|
}
|
|
instances.clear();
|
|
lock_instances->release();
|
|
}
|
|
|
|
void OpenGLVegetationLayer::setCamera(const CameraDefinition *camera) {
|
|
if (camera_location->sub(camera->getLocation()).getNorm() > 1.0) {
|
|
*camera_location = camera->getLocation();
|
|
camera_changed = true;
|
|
}
|
|
}
|