paysages3d/src/definition/Scenery.cpp

215 lines
5 KiB
C++
Raw Normal View History

#include "Scenery.h"
#include <ctime>
#include <map>
#include "PackStream.h"
#include "AtmosphereDefinition.h"
#include "CameraDefinition.h"
#include "CloudsDefinition.h"
#include "TerrainDefinition.h"
#include "TexturesDefinition.h"
2015-10-18 15:26:19 +00:00
#include "VegetationDefinition.h"
#include "WaterDefinition.h"
#include "Logs.h"
static const double APP_HEADER = 19866544632.125;
static const int DATA_VERSION = 1;
Scenery::Scenery():
DefinitionNode(NULL, "scenery", "scenery")
{
atmosphere = new AtmosphereDefinition(this);
camera = new CameraDefinition(this);
clouds = new CloudsDefinition(this);
terrain = new TerrainDefinition(this);
textures = new TexturesDefinition(this);
water = new WaterDefinition(this);
2015-10-18 15:26:19 +00:00
vegetation = new VegetationDefinition(this);
}
void Scenery::validate()
{
DefinitionNode::validate();
keepCameraAboveGround(camera);
}
Scenery::FileOperationResult Scenery::saveGlobal(const std::string &filepath) const
{
PackStream stream;
2015-08-03 22:00:56 +00:00
double app_header = (double)APP_HEADER;
double version_header = (double)DATA_VERSION;
if (not stream.bindToFile(filepath, true))
{
return FILE_OPERATION_IOERROR;
}
stream.write(&app_header);
stream.write(&version_header);
save(&stream);
2015-08-03 22:00:56 +00:00
stream.write(&version_header);
stream.write(&app_header);
Logs::debug() << "Scenery saved to file: " << filepath << std::endl;
return FILE_OPERATION_OK;
}
Scenery::FileOperationResult Scenery::loadGlobal(const std::string &filepath)
{
PackStream stream;
double app_header, version_header;
if (not stream.bindToFile(filepath, false))
{
return FILE_OPERATION_IOERROR;
}
stream.read(&app_header);
if (app_header != APP_HEADER)
{
return FILE_OPERATION_APP_MISMATCH;
}
stream.read(&version_header);
if ((int)version_header != DATA_VERSION)
{
return FILE_OPERATION_VERSION_MISMATCH;
}
load(&stream);
// Reset read headers, to test them again
app_header = -1;
version_header = -1;
2015-08-03 22:00:56 +00:00
stream.read(&version_header);
if ((int)version_header != DATA_VERSION)
{
return FILE_OPERATION_VERSION_MISMATCH;
}
stream.read(&app_header);
if (app_header != APP_HEADER)
{
return FILE_OPERATION_APP_MISMATCH;
}
Logs::debug() << "Scenery loaded from file: " << filepath << std::endl;
return FILE_OPERATION_OK;
}
2015-10-18 20:15:19 +00:00
const Scenery* Scenery::getScenery() const
{
return this;
}
void Scenery::autoPreset(int seed)
{
if (!seed)
{
seed = time(NULL);
}
srand(seed);
terrain->applyPreset(TerrainDefinition::TERRAIN_PRESET_STANDARD);
textures->applyPreset(TexturesDefinition::TEXTURES_PRESET_FULL);
atmosphere->applyPreset(AtmosphereDefinition::ATMOSPHERE_PRESET_CLEAR_DAY);
water->applyPreset(WaterDefinition::WATER_PRESET_LAKE);
clouds->applyPreset(CloudsDefinition::CLOUDS_PRESET_PARTLY_CLOUDY);
2015-10-18 15:26:19 +00:00
vegetation->applyPreset(VegetationDefinition::VEGETATION_PRESET_TEMPERATE);
camera->setLocation(VECTOR_ZERO);
camera->setTarget(VECTOR_NORTH);
validate();
2015-08-19 20:07:44 +00:00
Logs::debug() << "New scenery generated from seed " << seed << std::endl;
}
void Scenery::setAtmosphere(AtmosphereDefinition* atmosphere)
{
atmosphere->copy(this->atmosphere);
}
void Scenery::getAtmosphere(AtmosphereDefinition* atmosphere)
{
this->atmosphere->copy(atmosphere);
}
void Scenery::setCamera(CameraDefinition* camera)
{
camera->copy(this->camera);
keepCameraAboveGround(this->camera);
}
void Scenery::getCamera(CameraDefinition* camera)
{
this->camera->copy(camera);
}
void Scenery::setClouds(CloudsDefinition* clouds)
{
clouds->copy(this->clouds);
}
void Scenery::getClouds(CloudsDefinition* clouds)
{
this->clouds->copy(clouds);
}
void Scenery::setTerrain(TerrainDefinition* terrain)
{
terrain->copy(this->terrain);
}
void Scenery::getTerrain(TerrainDefinition* terrain)
{
this->terrain->copy(terrain);
}
void Scenery::setTextures(TexturesDefinition* textures)
{
textures->copy(this->textures);
}
void Scenery::getTextures(TexturesDefinition* textures)
{
this->textures->copy(textures);
}
2015-10-18 15:26:19 +00:00
void Scenery::setVegetation(VegetationDefinition* vegetation)
{
vegetation->copy(this->vegetation);
}
void Scenery::getVegetation(VegetationDefinition* vegetation)
{
this->vegetation->copy(vegetation);
}
void Scenery::setWater(WaterDefinition* water)
{
water->copy(this->water);
}
void Scenery::getWater(WaterDefinition* water)
{
this->water->copy(water);
}
void Scenery::keepCameraAboveGround(CameraDefinition* camera)
{
Vector3 camera_location = camera->getLocation();
double terrain_height = terrain->getInterpolatedHeight(camera_location.x, camera_location.z, true, true) + 1.0;
double water_height = 0.5;
if (camera_location.y < water_height || camera_location.y < terrain_height)
{
double diff = ((water_height > terrain_height) ? water_height : terrain_height) - camera_location.y;
camera->setLocation(camera_location.add(Vector3(0.0, diff, 0.0)));
}
}