paysages3d/src/render/software/SoftwareRenderer.cpp

159 lines
4.8 KiB
C++
Raw Normal View History

2013-11-09 17:46:34 +00:00
#include "SoftwareRenderer.h"
#include "CameraDefinition.h"
2013-11-10 16:04:38 +00:00
#include "Scenery.h"
#include "FluidMediumManager.h"
#include "AtmosphereRenderer.h"
2013-11-15 23:27:40 +00:00
#include "AtmosphereDefinition.h"
#include "AtmosphereResult.h"
#include "CloudsRenderer.h"
2013-12-15 12:59:21 +00:00
#include "CloudsDefinition.h"
#include "TerrainRenderer.h"
#include "TexturesRenderer.h"
2015-10-18 15:26:19 +00:00
#include "VegetationRenderer.h"
#include "WaterRenderer.h"
#include "SkyRasterizer.h"
2013-12-05 15:44:18 +00:00
#include "TerrainRasterizer.h"
2013-12-08 17:05:18 +00:00
#include "WaterRasterizer.h"
#include "NightSky.h"
#include "LightStatus.h"
#include "LightingManager.h"
#include "GodRaysSampler.h"
#include "GodRaysResult.h"
#include "System.h"
#include "Thread.h"
#include "RayCastingResult.h"
SoftwareRenderer::SoftwareRenderer(Scenery *scenery) : scenery(scenery) {
render_camera = new CameraDefinition;
2013-11-09 17:46:34 +00:00
2015-08-18 20:47:18 +00:00
scenery->getCamera()->copy(render_camera);
atmosphere_renderer = new BaseAtmosphereRenderer(this);
clouds_renderer = new CloudsRenderer(this);
terrain_renderer = new TerrainRenderer(this);
textures_renderer = new TexturesRenderer(this);
2015-10-18 15:26:19 +00:00
vegetation_renderer = new VegetationRenderer(this);
water_renderer = new WaterRenderer(this);
nightsky_renderer = new NightSky(this);
fluid_medium = new FluidMediumManager(this);
lighting = new LightingManager();
godrays = new GodRaysSampler();
2013-11-10 16:04:38 +00:00
2013-12-17 22:45:09 +00:00
lighting->registerFilter(water_renderer);
lighting->registerFilter(terrain_renderer);
2015-10-18 15:26:19 +00:00
lighting->registerFilter(vegetation_renderer);
2013-12-17 22:45:09 +00:00
lighting->registerFilter(clouds_renderer);
2015-09-24 22:12:31 +00:00
lighting->registerSource(atmosphere_renderer);
2015-09-10 17:33:52 +00:00
setQuality(0.5);
2013-11-09 17:46:34 +00:00
}
SoftwareRenderer::~SoftwareRenderer() {
delete render_camera;
2013-12-17 22:45:09 +00:00
delete fluid_medium;
delete lighting;
delete godrays;
2013-12-17 22:45:09 +00:00
delete nightsky_renderer;
delete atmosphere_renderer;
delete clouds_renderer;
delete terrain_renderer;
delete textures_renderer;
delete water_renderer;
}
void SoftwareRenderer::prepare() {
scenery->validate();
scenery->getCamera()->copy(render_camera);
// Prepare sub renderers
2015-09-24 22:12:31 +00:00
// TODO Don't recreate the renderer each time, only when it changes
lighting->unregisterSource(atmosphere_renderer);
delete atmosphere_renderer;
if (getScenery()->getAtmosphere()->model == AtmosphereDefinition::ATMOSPHERE_MODEL_BRUNETON) {
2013-12-15 13:28:46 +00:00
atmosphere_renderer = new SoftwareBrunetonAtmosphereRenderer(this);
} else {
2013-12-15 13:28:46 +00:00
atmosphere_renderer = new BaseAtmosphereRenderer(this);
}
2015-09-24 22:12:31 +00:00
lighting->registerSource(atmosphere_renderer);
clouds_renderer->update();
2013-12-17 22:45:09 +00:00
terrain_renderer->update();
water_renderer->update();
textures_renderer->update();
nightsky_renderer->update();
// Prepare global tools
godrays->prepare(this);
fluid_medium->clearMedia();
// fluid_medium->registerMedium(water_renderer);
2013-11-10 16:04:38 +00:00
}
void SoftwareRenderer::setQuality(double quality) {
terrain_renderer->setQuality(quality);
clouds_renderer->setQuality(quality);
godrays->setQuality(quality);
// TEMP compat with old code
render_quality = (int)(quality * 9.0) + 1;
}
Color SoftwareRenderer::applyLightingToSurface(const Vector3 &location, const Vector3 &normal,
const SurfaceMaterial &material) {
2015-09-24 22:12:31 +00:00
return lighting->apply(getCameraLocation(location), location, normal, material);
}
Color SoftwareRenderer::applyMediumTraversal(const Vector3 &location, const Color &color) {
Color result = atmosphere_renderer->applyAerialPerspective(location, color).final;
result = clouds_renderer->getColor(getCameraLocation(location), location, result);
return result;
}
2013-12-08 16:56:59 +00:00
RayCastingResult SoftwareRenderer::rayWalking(const Vector3 &location, const Vector3 &direction, int, int, int, int) {
RayCastingResult result;
Color sky_color;
result = terrain_renderer->castRay(location, direction);
if (!result.hit) {
sky_color = atmosphere_renderer->getSkyColor(direction).final;
result.hit = 1;
2013-12-11 10:32:10 +00:00
result.hit_location = location.add(direction.scale(1000.0));
result.hit_color = clouds_renderer->getColor(location, result.hit_location, sky_color);
}
2013-12-08 16:56:59 +00:00
return result;
}
Vector3 SoftwareRenderer::getCameraLocation(const Vector3 &) {
return render_camera->getLocation();
}
Vector3 SoftwareRenderer::getCameraDirection(const Vector3 &) {
return render_camera->getDirectionNormalized();
}
double SoftwareRenderer::getPrecision(const Vector3 &location) {
Vector3 projected;
projected = render_camera->project(location);
projected.x += 1.0;
// projected.y += 1.0;
2013-12-11 10:32:10 +00:00
return render_camera->unproject(projected).sub(location).getNorm(); // / (double)render_quality;
}
Vector3 SoftwareRenderer::projectPoint(const Vector3 &point) {
return render_camera->project(point);
}
Vector3 SoftwareRenderer::unprojectPoint(const Vector3 &point) {
return render_camera->unproject(point);
}