mirror of
https://github.com/overte-org/overte.git
synced 2025-06-19 07:00:00 +02:00
620 lines
21 KiB
C++
620 lines
21 KiB
C++
//
|
|
// RenderableZoneEntityItem.cpp
|
|
//
|
|
//
|
|
// Created by Clement on 4/22/15.
|
|
// Copyright 2015 High Fidelity, Inc.
|
|
//
|
|
// Distributed under the Apache License, Version 2.0.
|
|
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
|
//
|
|
|
|
#include "RenderableZoneEntityItem.h"
|
|
|
|
#include <gpu/Batch.h>
|
|
|
|
#include <model/Stage.h>
|
|
|
|
#include <AbstractViewStateInterface.h>
|
|
#include <DependencyManager.h>
|
|
#include <GeometryCache.h>
|
|
#include <PerfStat.h>
|
|
#include <procedural/ProceduralSkybox.h>
|
|
|
|
#include "EntityTreeRenderer.h"
|
|
#include "RenderableEntityItem.h"
|
|
|
|
#include <LightPayload.h>
|
|
#include "DeferredLightingEffect.h"
|
|
|
|
|
|
class RenderableZoneEntityItemMeta {
|
|
public:
|
|
RenderableZoneEntityItemMeta(EntityItemPointer entity);
|
|
~RenderableZoneEntityItemMeta();
|
|
|
|
typedef render::Payload<RenderableZoneEntityItemMeta> Payload;
|
|
typedef Payload::DataPointer Pointer;
|
|
|
|
EntityItemPointer entity;
|
|
|
|
void render(RenderArgs* args);
|
|
|
|
void setVisible(bool visible) { _isVisible = visible; }
|
|
bool isVisible() const { return _isVisible; }
|
|
|
|
render::Item::Bound& editBound() { _needUpdate = true; return _bound; }
|
|
|
|
model::LightPointer editSunLight() { _needSunUpdate = true; return _sunLight; }
|
|
model::LightPointer editAmbientLight() { _needAmbientUpdate = true; return _ambientLight; }
|
|
model::SunSkyStagePointer editBackground() { _needBackgroundUpdate = true; return _background; }
|
|
model::SkyboxPointer editSkybox() { return editBackground()->getSkybox(); }
|
|
|
|
void setAmbientURL(const QString& ambientUrl);
|
|
|
|
void setSkyboxURL(const QString& skyboxUrl);
|
|
|
|
void setBackgroundMode(BackgroundMode mode);
|
|
void setSkyboxColor(const glm::vec3& color);
|
|
void setProceduralUserData(QString userData);
|
|
|
|
protected:
|
|
render::Item::Bound _bound;
|
|
|
|
model::LightPointer _sunLight;
|
|
model::LightPointer _ambientLight;
|
|
model::SunSkyStagePointer _background;
|
|
BackgroundMode _backgroundMode { BACKGROUND_MODE_INHERIT };
|
|
|
|
LightStagePointer _stage;
|
|
LightStage::Index _sunIndex { LightStage::INVALID_INDEX };
|
|
LightStage::Index _ambientIndex { LightStage::INVALID_INDEX };
|
|
|
|
BackgroundStagePointer _backgroundStage;
|
|
BackgroundStage::Index _backgroundIndex { BackgroundStage::INVALID_INDEX };
|
|
|
|
bool _needUpdate { true };
|
|
bool _needSunUpdate { true };
|
|
bool _needAmbientUpdate { true };
|
|
bool _needBackgroundUpdate { true };
|
|
bool _isVisible { true };
|
|
|
|
|
|
void updateAmbientMap();
|
|
void updateSkyboxMap();
|
|
|
|
// More attributes used for rendering:
|
|
QString _ambientTextureURL;
|
|
NetworkTexturePointer _ambientTexture;
|
|
bool _pendingAmbientTexture { false };
|
|
bool _validAmbientTexture { false };
|
|
|
|
QString _skyboxTextureURL;
|
|
NetworkTexturePointer _skyboxTexture;
|
|
bool _pendingSkyboxTexture { false };
|
|
bool _validSkyboxTexture { false };
|
|
|
|
QString _proceduralUserData;
|
|
};
|
|
|
|
// Sphere entities should fit inside a cube entity of the same size, so a sphere that has dimensions 1x1x1
|
|
// is a half unit sphere. However, the geometry cache renders a UNIT sphere, so we need to scale down.
|
|
static const float SPHERE_ENTITY_SCALE = 0.5f;
|
|
|
|
EntityItemPointer RenderableZoneEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
|
|
EntityItemPointer entity{ new RenderableZoneEntityItem(entityID) };
|
|
entity->setProperties(properties);
|
|
return entity;
|
|
}
|
|
|
|
template<typename Lambda>
|
|
void RenderableZoneEntityItem::changeProperties(Lambda setNewProperties) {
|
|
QString oldShapeURL = getCompoundShapeURL();
|
|
glm::vec3 oldPosition = getPosition(), oldDimensions = getDimensions();
|
|
glm::quat oldRotation = getRotation();
|
|
|
|
setNewProperties();
|
|
|
|
if (oldShapeURL != getCompoundShapeURL()) {
|
|
if (_model) {
|
|
_model.reset();
|
|
}
|
|
|
|
_model = std::make_shared<Model>();
|
|
_model->setIsWireframe(true);
|
|
_model->init();
|
|
_needsInitialSimulation = true;
|
|
_model->setURL(getCompoundShapeURL());
|
|
}
|
|
if (oldPosition != getPosition() ||
|
|
oldRotation != getRotation() ||
|
|
oldDimensions != getDimensions()) {
|
|
_needsInitialSimulation = true;
|
|
}
|
|
}
|
|
|
|
bool RenderableZoneEntityItem::setProperties(const EntityItemProperties& properties) {
|
|
bool somethingChanged = false;
|
|
changeProperties([&]() {
|
|
somethingChanged = this->ZoneEntityItem::setProperties(properties);
|
|
});
|
|
return somethingChanged;
|
|
}
|
|
|
|
void RenderableZoneEntityItem::somethingChangedNotification() {
|
|
DependencyManager::get<EntityTreeRenderer>()->updateZone(_id);
|
|
|
|
// If graphics elements are changed, we need to update the render items
|
|
notifyChangedRenderItem();
|
|
|
|
// Poopagate back to parent
|
|
ZoneEntityItem::somethingChangedNotification();
|
|
}
|
|
|
|
|
|
int RenderableZoneEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead,
|
|
ReadBitstreamToTreeParams& args,
|
|
EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
|
|
bool& somethingChanged) {
|
|
int bytesRead = 0;
|
|
changeProperties([&]() {
|
|
bytesRead = ZoneEntityItem::readEntitySubclassDataFromBuffer(data, bytesLeftToRead,
|
|
args, propertyFlags,
|
|
overwriteLocalData, somethingChanged);
|
|
});
|
|
return bytesRead;
|
|
}
|
|
|
|
void RenderableZoneEntityItem::updateGeometry() {
|
|
if (_model && !_model->isActive() && hasCompoundShapeURL()) {
|
|
// Since we have a delayload, we need to update the geometry if it has been downloaded
|
|
_model->setURL(getCompoundShapeURL());
|
|
}
|
|
if (_model && _model->isActive() && _needsInitialSimulation) {
|
|
_model->setScaleToFit(true, getDimensions());
|
|
_model->setSnapModelToRegistrationPoint(true, getRegistrationPoint());
|
|
_model->setRotation(getRotation());
|
|
_model->setTranslation(getPosition());
|
|
_model->simulate(0.0f);
|
|
_needsInitialSimulation = false;
|
|
}
|
|
}
|
|
|
|
void RenderableZoneEntityItem::render(RenderArgs* args) {
|
|
Q_ASSERT(getType() == EntityTypes::Zone);
|
|
|
|
if (_drawZoneBoundaries) {
|
|
switch (getShapeType()) {
|
|
case SHAPE_TYPE_COMPOUND: {
|
|
PerformanceTimer perfTimer("zone->renderCompound");
|
|
updateGeometry();
|
|
if (_model && _model->needsFixupInScene()) {
|
|
// check to see if when we added our models to the scene they were ready, if they were not ready, then
|
|
// fix them up in the scene
|
|
render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
|
|
render::Transaction transaction;
|
|
_model->removeFromScene(scene, transaction);
|
|
render::Item::Status::Getters statusGetters;
|
|
makeEntityItemStatusGetters(getThisPointer(), statusGetters);
|
|
_model->addToScene(scene, transaction);
|
|
|
|
scene->enqueueTransaction(transaction);
|
|
|
|
_model->setVisibleInScene(getVisible(), scene);
|
|
}
|
|
break;
|
|
}
|
|
case SHAPE_TYPE_BOX:
|
|
case SHAPE_TYPE_SPHERE: {
|
|
PerformanceTimer perfTimer("zone->renderPrimitive");
|
|
glm::vec4 DEFAULT_COLOR(1.0f, 1.0f, 1.0f, 1.0f);
|
|
|
|
Q_ASSERT(args->_batch);
|
|
gpu::Batch& batch = *args->_batch;
|
|
|
|
bool success;
|
|
auto shapeTransform = getTransformToCenter(success);
|
|
if (!success) {
|
|
break;
|
|
}
|
|
auto geometryCache = DependencyManager::get<GeometryCache>();
|
|
if (getShapeType() == SHAPE_TYPE_SPHERE) {
|
|
shapeTransform.postScale(SPHERE_ENTITY_SCALE);
|
|
batch.setModelTransform(shapeTransform);
|
|
geometryCache->renderWireSphereInstance(batch, DEFAULT_COLOR);
|
|
} else {
|
|
batch.setModelTransform(shapeTransform);
|
|
geometryCache->renderWireCubeInstance(batch, DEFAULT_COLOR);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
// Not handled
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ((!_drawZoneBoundaries || getShapeType() != SHAPE_TYPE_COMPOUND) &&
|
|
_model && !_model->needsFixupInScene()) {
|
|
// If the model is in the scene but doesn't need to be, remove it.
|
|
render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
|
|
render::Transaction transaction;
|
|
_model->removeFromScene(scene, transaction);
|
|
scene->enqueueTransaction(transaction);
|
|
}
|
|
}
|
|
|
|
bool RenderableZoneEntityItem::contains(const glm::vec3& point) const {
|
|
if (getShapeType() != SHAPE_TYPE_COMPOUND) {
|
|
return EntityItem::contains(point);
|
|
}
|
|
const_cast<RenderableZoneEntityItem*>(this)->updateGeometry();
|
|
|
|
if (_model && _model->isActive() && EntityItem::contains(point)) {
|
|
return _model->convexHullContains(point);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool RenderableZoneEntityItem::addToScene(EntityItemPointer self, const render::ScenePointer& scene,
|
|
render::Transaction& transaction) {
|
|
_myMetaItem = scene->allocateID();
|
|
|
|
auto renderData = std::make_shared<RenderableZoneEntityItemMeta>(self);
|
|
auto renderPayload = std::make_shared<RenderableZoneEntityItemMeta::Payload>(renderData);
|
|
updateKeyZoneItemFromEntity((*renderData));
|
|
updateKeySunFromEntity((*renderData));
|
|
updateKeyAmbientFromEntity((*renderData));
|
|
updateKeyBackgroundFromEntity((*renderData));
|
|
|
|
render::Item::Status::Getters statusGetters;
|
|
makeEntityItemStatusGetters(getThisPointer(), statusGetters);
|
|
renderPayload->addStatusGetters(statusGetters);
|
|
|
|
transaction.resetItem(_myMetaItem, renderPayload);
|
|
|
|
return true;
|
|
}
|
|
|
|
void RenderableZoneEntityItem::removeFromScene(EntityItemPointer self, const render::ScenePointer& scene,
|
|
render::Transaction& transaction) {
|
|
transaction.removeItem(_myMetaItem);
|
|
render::Item::clearID(_myMetaItem);
|
|
if (_model) {
|
|
_model->removeFromScene(scene, transaction);
|
|
}
|
|
}
|
|
|
|
void RenderableZoneEntityItem::notifyBoundChanged() {
|
|
notifyChangedRenderItem();
|
|
}
|
|
|
|
void RenderableZoneEntityItem::updateKeySunFromEntity(RenderableZoneEntityItemMeta& keyZonePayload) {
|
|
auto sunLight = keyZonePayload.editSunLight();
|
|
sunLight->setType(model::Light::SUN);
|
|
|
|
sunLight->setPosition(this->getPosition());
|
|
sunLight->setOrientation(this->getRotation());
|
|
|
|
// Set the keylight
|
|
sunLight->setColor(ColorUtils::toVec3(this->getKeyLightProperties().getColor()));
|
|
sunLight->setIntensity(this->getKeyLightProperties().getIntensity());
|
|
sunLight->setDirection(this->getKeyLightProperties().getDirection());
|
|
}
|
|
|
|
void RenderableZoneEntityItem::updateKeyAmbientFromEntity(RenderableZoneEntityItemMeta& keyZonePayload) {
|
|
auto ambientLight = keyZonePayload.editAmbientLight();
|
|
ambientLight->setType(model::Light::AMBIENT);
|
|
|
|
ambientLight->setPosition(this->getPosition());
|
|
ambientLight->setOrientation(this->getRotation());
|
|
|
|
|
|
// Set the keylight
|
|
ambientLight->setAmbientIntensity(this->getKeyLightProperties().getAmbientIntensity());
|
|
|
|
if (this->getKeyLightProperties().getAmbientURL().isEmpty()) {
|
|
keyZonePayload.setAmbientURL(this->getSkyboxProperties().getURL());
|
|
} else {
|
|
keyZonePayload.setAmbientURL(this->getKeyLightProperties().getAmbientURL());
|
|
}
|
|
|
|
}
|
|
|
|
void RenderableZoneEntityItem::updateKeyBackgroundFromEntity(RenderableZoneEntityItemMeta& keyZonePayload) {
|
|
auto background = keyZonePayload.editBackground();
|
|
|
|
keyZonePayload.setBackgroundMode(this->getBackgroundMode());
|
|
keyZonePayload.setSkyboxColor(this->getSkyboxProperties().getColorVec3());
|
|
keyZonePayload.setProceduralUserData(this->getUserData());
|
|
keyZonePayload.setSkyboxURL(this->getSkyboxProperties().getURL());
|
|
}
|
|
|
|
|
|
void RenderableZoneEntityItem::updateKeyZoneItemFromEntity(RenderableZoneEntityItemMeta& keyZonePayload) {
|
|
|
|
keyZonePayload.setVisible(this->getVisible());
|
|
|
|
bool success;
|
|
keyZonePayload.editBound() = this->getAABox(success);
|
|
if (!success) {
|
|
keyZonePayload.editBound() = render::Item::Bound();
|
|
}
|
|
|
|
/* TODO: Implement the sun model behavior / Keep this code here for reference, this is how we
|
|
{
|
|
// Set the stage
|
|
bool isSunModelEnabled = this->getStageProperties().getSunModelEnabled();
|
|
sceneStage->setSunModelEnable(isSunModelEnabled);
|
|
if (isSunModelEnabled) {
|
|
sceneStage->setLocation(this->getStageProperties().getLongitude(),
|
|
this->getStageProperties().getLatitude(),
|
|
this->getStageProperties().getAltitude());
|
|
|
|
auto sceneTime = sceneStage->getTime();
|
|
sceneTime->setHour(this->getStageProperties().calculateHour());
|
|
sceneTime->setDay(this->getStageProperties().calculateDay());
|
|
}
|
|
}*/
|
|
}
|
|
|
|
|
|
void RenderableZoneEntityItem::sceneUpdateRenderItemFromEntity(render::Transaction& transaction) {
|
|
if (!render::Item::isValidID(_myMetaItem)) {
|
|
return;
|
|
}
|
|
|
|
bool sunChanged = _keyLightPropertiesChanged;
|
|
bool backgroundChanged = _backgroundPropertiesChanged;
|
|
bool skyboxChanged = _skyboxPropertiesChanged;
|
|
|
|
transaction.updateItem<RenderableZoneEntityItemMeta>(_myMetaItem, [=](RenderableZoneEntityItemMeta& data) {
|
|
|
|
updateKeyZoneItemFromEntity(data);
|
|
|
|
if (sunChanged) {
|
|
updateKeySunFromEntity(data);
|
|
}
|
|
|
|
if (sunChanged || skyboxChanged) {
|
|
updateKeyAmbientFromEntity(data);
|
|
}
|
|
if (backgroundChanged || skyboxChanged) {
|
|
updateKeyBackgroundFromEntity(data);
|
|
}
|
|
});
|
|
}
|
|
|
|
void RenderableZoneEntityItem::notifyChangedRenderItem() {
|
|
if (!render::Item::isValidID(_myMetaItem)) {
|
|
return;
|
|
}
|
|
|
|
render::Transaction transaction;
|
|
render::ScenePointer scene = AbstractViewStateInterface::instance()->getMain3DScene();
|
|
sceneUpdateRenderItemFromEntity(transaction);
|
|
scene->enqueueTransaction(transaction);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
namespace render {
|
|
template <> const ItemKey payloadGetKey(const RenderableZoneEntityItemMeta::Pointer& payload) {
|
|
return ItemKey::Builder().withTypeMeta().build();
|
|
}
|
|
|
|
template <> const Item::Bound payloadGetBound(const RenderableZoneEntityItemMeta::Pointer& payload) {
|
|
if (payload && payload->entity) {
|
|
bool success;
|
|
auto result = payload->entity->getAABox(success);
|
|
if (!success) {
|
|
return render::Item::Bound();
|
|
}
|
|
return result;
|
|
}
|
|
return render::Item::Bound();
|
|
}
|
|
template <> void payloadRender(const RenderableZoneEntityItemMeta::Pointer& payload, RenderArgs* args) {
|
|
payload->render(args);
|
|
}
|
|
}
|
|
|
|
RenderableZoneEntityItemMeta::RenderableZoneEntityItemMeta(EntityItemPointer entity) :
|
|
entity(entity),
|
|
_sunLight(std::make_shared<model::Light>()),
|
|
_ambientLight(std::make_shared<model::Light>()),
|
|
_background(std::make_shared<model::SunSkyStage>())
|
|
{
|
|
_background->setSkybox(std::make_shared<ProceduralSkybox>());
|
|
}
|
|
|
|
|
|
RenderableZoneEntityItemMeta::~RenderableZoneEntityItemMeta() {
|
|
if (_stage) {
|
|
if (!LightStage::isIndexInvalid(_sunIndex)) {
|
|
_stage->removeLight(_sunIndex);
|
|
}
|
|
if (!LightStage::isIndexInvalid(_ambientIndex)) {
|
|
_stage->removeLight(_ambientIndex);
|
|
|
|
}
|
|
}
|
|
|
|
if (_backgroundStage) {
|
|
if (!BackgroundStage::isIndexInvalid(_backgroundIndex)) {
|
|
_backgroundStage->removeBackground(_backgroundIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
void RenderableZoneEntityItemMeta::setAmbientURL(const QString& ambientUrl) {
|
|
// nothing change if nothing change
|
|
if (_ambientTextureURL == ambientUrl) {
|
|
return;
|
|
}
|
|
_ambientTextureURL = ambientUrl;
|
|
|
|
if (_ambientTextureURL.isEmpty()) {
|
|
_validAmbientTexture = false;
|
|
_pendingAmbientTexture = false;
|
|
_ambientTexture.clear();
|
|
|
|
_ambientLight->setAmbientMap(nullptr);
|
|
_ambientLight->setAmbientSpherePreset(gpu::SphericalHarmonics::BREEZEWAY);
|
|
} else {
|
|
_pendingAmbientTexture = true;
|
|
auto textureCache = DependencyManager::get<TextureCache>();
|
|
_ambientTexture = textureCache->getTexture(_ambientTextureURL, image::TextureUsage::CUBE_TEXTURE);
|
|
|
|
// keep whatever is assigned on the ambient map/sphere until texture is loaded
|
|
}
|
|
}
|
|
|
|
void RenderableZoneEntityItemMeta::updateAmbientMap() {
|
|
if (_pendingAmbientTexture) {
|
|
if (_ambientTexture && _ambientTexture->isLoaded()) {
|
|
_pendingAmbientTexture = false;
|
|
|
|
auto texture = _ambientTexture->getGPUTexture();
|
|
if (texture) {
|
|
if (texture->getIrradiance()) {
|
|
_ambientLight->setAmbientSphere(*texture->getIrradiance());
|
|
} else {
|
|
_ambientLight->setAmbientSpherePreset(gpu::SphericalHarmonics::BREEZEWAY);
|
|
}
|
|
editAmbientLight()->setAmbientMap(texture);
|
|
_validAmbientTexture = true;
|
|
} else {
|
|
qCDebug(entitiesrenderer) << "Failed to load ambient texture:" << _ambientTexture->getURL();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void RenderableZoneEntityItemMeta::setSkyboxURL(const QString& skyboxUrl) {
|
|
// nothing change if nothing change
|
|
if (_skyboxTextureURL == skyboxUrl) {
|
|
return;
|
|
}
|
|
_skyboxTextureURL = skyboxUrl;
|
|
|
|
if (_skyboxTextureURL.isEmpty()) {
|
|
_validSkyboxTexture = false;
|
|
_pendingSkyboxTexture = false;
|
|
_skyboxTexture.clear();
|
|
|
|
editSkybox()->setCubemap(nullptr);
|
|
} else {
|
|
_pendingSkyboxTexture = true;
|
|
auto textureCache = DependencyManager::get<TextureCache>();
|
|
_skyboxTexture = textureCache->getTexture(_skyboxTextureURL, image::TextureUsage::CUBE_TEXTURE);
|
|
}
|
|
}
|
|
|
|
void RenderableZoneEntityItemMeta::updateSkyboxMap() {
|
|
if (_pendingSkyboxTexture) {
|
|
if (_skyboxTexture && _skyboxTexture->isLoaded()) {
|
|
_pendingSkyboxTexture = false;
|
|
|
|
auto texture = _skyboxTexture->getGPUTexture();
|
|
if (texture) {
|
|
editSkybox()->setCubemap(texture);
|
|
_validSkyboxTexture = true;
|
|
} else {
|
|
qCDebug(entitiesrenderer) << "Failed to load Skybox texture:" << _skyboxTexture->getURL();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void RenderableZoneEntityItemMeta::setBackgroundMode(BackgroundMode mode) {
|
|
_backgroundMode = mode;
|
|
}
|
|
|
|
void RenderableZoneEntityItemMeta::setSkyboxColor(const glm::vec3& color) {
|
|
editSkybox()->setColor(color);
|
|
}
|
|
|
|
void RenderableZoneEntityItemMeta::setProceduralUserData(QString userData) {
|
|
if (_proceduralUserData != userData) {
|
|
_proceduralUserData = userData;
|
|
std::dynamic_pointer_cast<ProceduralSkybox>(editSkybox())->parse(_proceduralUserData);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void RenderableZoneEntityItemMeta::render(RenderArgs* args) {
|
|
if (!_stage) {
|
|
_stage = DependencyManager::get<DeferredLightingEffect>()->getLightStage();
|
|
}
|
|
|
|
if (!_backgroundStage) {
|
|
_backgroundStage = DependencyManager::get<DeferredLightingEffect>()->getBackgroundStage();
|
|
}
|
|
|
|
{ // Sun
|
|
// Need an update ?
|
|
if (_needSunUpdate) {
|
|
// Do we need to allocate the light in the stage ?
|
|
if (LightStage::isIndexInvalid(_sunIndex)) {
|
|
_sunIndex = _stage->addLight(_sunLight);
|
|
} else {
|
|
_stage->updateLightArrayBuffer(_sunIndex);
|
|
}
|
|
_needSunUpdate = false;
|
|
}
|
|
}
|
|
|
|
{ // Ambient
|
|
updateAmbientMap();
|
|
|
|
// Need an update ?
|
|
if (_needAmbientUpdate) {
|
|
// Do we need to allocate the light in the stage ?
|
|
if (LightStage::isIndexInvalid(_ambientIndex)) {
|
|
_ambientIndex = _stage->addLight(_ambientLight);
|
|
} else {
|
|
_stage->updateLightArrayBuffer(_ambientIndex);
|
|
}
|
|
_needAmbientUpdate = false;
|
|
}
|
|
}
|
|
|
|
{ // Skybox
|
|
updateSkyboxMap();
|
|
|
|
if (_needBackgroundUpdate) {
|
|
if (BackgroundStage::isIndexInvalid(_backgroundIndex)) {
|
|
_backgroundIndex = _backgroundStage->addBackground(_background);
|
|
} else {
|
|
|
|
}
|
|
_needBackgroundUpdate = false;
|
|
}
|
|
}
|
|
|
|
if (isVisible()) {
|
|
// FInally, push the light visible in the frame
|
|
// THe directional key light for sure
|
|
_stage->_currentFrame.pushSunLight(_sunIndex);
|
|
|
|
// The ambient light only if it has a valid texture to render with
|
|
if (_validAmbientTexture || _validSkyboxTexture) {
|
|
_stage->_currentFrame.pushAmbientLight(_ambientIndex);
|
|
}
|
|
|
|
// The background only if the mode is not inherit
|
|
if (_backgroundMode != BACKGROUND_MODE_INHERIT) {
|
|
_backgroundStage->_currentFrame.pushBackground(_backgroundIndex);
|
|
}
|
|
}
|
|
}
|