Mirrors/overte-lubosz
3
0
Fork 0
mirror of https://github.com/lubosz/overte.git synced 2025-04-23 13:33:38 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

fix fading and highlighting issues

Browse source
This commit is contained in:
SamGondelman 2018-10-22 14:10:50 -07:00
parent 5652fa0b1e
commit 09ea32dcc0
10 changed files with 127 additions and 109 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
interface/src/avatar/AvatarManager.cpp
View file

@ -188,7 +188,7 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
{
// lock the hash for read to check the size
QReadLocker lock(&_hashLock);
if (_avatarHash.size() < 2 && _avatarsToFade.isEmpty()) {
if (_avatarHash.size() < 2 && _avatarsToFadeOut.isEmpty()) {
return;
}
}
@ -346,23 +346,23 @@ void AvatarManager::sendIdentityRequest(const QUuid& avatarID) const {
}
void AvatarManager::simulateAvatarFades(float deltaTime) {
if (_avatarsToFade.empty()) {
if (_avatarsToFadeOut.empty()) {
return;
}
QReadLocker locker(&_hashLock);
QVector<AvatarSharedPointer>::iterator avatarItr = _avatarsToFade.begin();
QVector<AvatarSharedPointer>::iterator avatarItr = _avatarsToFadeOut.begin();
const render::ScenePointer& scene = qApp->getMain3DScene();
render::Transaction transaction;
while (avatarItr != _avatarsToFade.end()) {
while (avatarItr != _avatarsToFadeOut.end()) {
auto avatar = std::static_pointer_cast<Avatar>(*avatarItr);
avatar->updateFadingStatus(scene);
avatar->updateFadingStatus();
if (!avatar->isFading()) {
// fading to zero is such a rare event we push a unique transaction for each
if (avatar->isInScene()) {
avatar->removeFromScene(*avatarItr, scene, transaction);
}
avatarItr = _avatarsToFade.erase(avatarItr);
avatarItr = _avatarsToFadeOut.erase(avatarItr);
} else {
++avatarItr;
}
@ -457,7 +457,7 @@ void AvatarManager::handleRemovedAvatar(const AvatarSharedPointer& removedAvatar
DependencyManager::get<UsersScriptingInterface>()->avatarDisconnected(avatar->getSessionUUID());
avatar->fadeOut(qApp->getMain3DScene(), removalReason);
}
_avatarsToFade.push_back(removedAvatar);
_avatarsToFadeOut.push_back(removedAvatar);
}
void AvatarManager::clearOtherAvatars() {

2
interface/src/avatar/AvatarManager.h
View file

@ -222,7 +222,7 @@ private:
void handleRemovedAvatar(const AvatarSharedPointer& removedAvatar,
KillAvatarReason removalReason = KillAvatarReason::NoReason) override;
QVector<AvatarSharedPointer> _avatarsToFade;
QVector<AvatarSharedPointer> _avatarsToFadeOut;
using SetOfOtherAvatars = std::set<OtherAvatarPointer>;
SetOfOtherAvatars _avatarsToChangeInPhysics;

2
interface/src/avatar/MyAvatar.cpp
View file

@ -857,6 +857,8 @@ void MyAvatar::simulate(float deltaTime) {
}
updateAvatarEntities();
updateFadingStatus();
}
// As far as I know no HMD system supports a play area of a kilometer in radius.

9
libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
View file

@ -612,6 +612,8 @@ void Avatar::simulate(float deltaTime, bool inView) {
PROFILE_RANGE(simulation, "entities");
updateAvatarEntities();
}
updateFadingStatus();
}
float Avatar::getSimulationRate(const QString& rateName) const {
@ -775,14 +777,15 @@ void Avatar::fade(render::Transaction& transaction, render::Transition::Type typ
_isFading = true;
}
void Avatar::updateFadingStatus(render::ScenePointer scene) {
void Avatar::updateFadingStatus() {
render::Transaction transaction;
transaction.queryTransitionOnItem(_renderItemID, [this](render::ItemID id, const render::Transition* transition) {
if (transition == nullptr || transition->isFinished) {
if (!transition || transition->isFinished) {
AbstractViewStateInterface::instance()->getMain3DScene()->resetItemTransition(id);
_isFading = false;
}
});
scene->enqueueTransaction(transaction);
AbstractViewStateInterface::instance()->getMain3DScene()->enqueueTransaction(transaction);
}
void Avatar::removeFromScene(AvatarSharedPointer self, const render::ScenePointer& scene, render::Transaction& transaction) {

2
libraries/avatars-renderer/src/avatars-renderer/Avatar.h
View file

@ -402,7 +402,7 @@ public:
void fadeIn(render::ScenePointer scene);
void fadeOut(render::ScenePointer scene, KillAvatarReason reason);
bool isFading() const { return _isFading; }
void updateFadingStatus(render::ScenePointer scene);
void updateFadingStatus();
// JSDoc is in AvatarData.h.
Q_INVOKABLE virtual float getEyeHeight() const override;

9
libraries/render-utils/src/Fade.slh
View file

@ -85,7 +85,11 @@ float evalFadeGradient(FadeObjectParams params, vec3 position) {
}
float evalFadeAlpha(FadeObjectParams params, vec3 position) {
return evalFadeGradient(params, position)-params.threshold;
float alpha = evalFadeGradient(params, position)-params.threshold;
if (fadeParameters[params.category]._isInverted != 0) {
alpha = -alpha;
}
return alpha;
}
void applyFadeClip(FadeObjectParams params, vec3 position) {
@ -96,9 +100,6 @@ void applyFadeClip(FadeObjectParams params, vec3 position) {
void applyFade(FadeObjectParams params, vec3 position, out vec3 emissive) {
float alpha = evalFadeAlpha(params, position);
if (fadeParameters[params.category]._isInverted!=0) {
alpha = -alpha;
}
if (alpha < 0.0) {
discard;

2
libraries/render-utils/src/GeometryCache.cpp
View file

@ -826,7 +826,7 @@ render::ShapePipelinePointer GeometryCache::getFadingShapePipeline(bool textured
bool unlit, bool depthBias) {
auto fadeEffect = DependencyManager::get<FadeEffect>();
auto fadeBatchSetter = fadeEffect->getBatchSetter();
auto fadeItemSetter = fadeEffect->getItemStoredSetter();
auto fadeItemSetter = fadeEffect->getItemUniformSetter();
return std::make_shared<render::ShapePipeline>(getSimplePipeline(textured, transparent, culled, unlit, depthBias, true), nullptr,
[fadeBatchSetter, fadeItemSetter](const render::ShapePipeline& shapePipeline, gpu::Batch& batch, render::Args* args) {
batch.setResourceTexture(gr::Texture::MaterialAlbedo, DependencyManager::get<TextureCache>()->getWhiteTexture());

81
libraries/render-utils/src/HighlightEffect.cpp
View file

@ -22,6 +22,8 @@
#include "GeometryCache.h"
#include "CubeProjectedPolygon.h"
#include "FadeEffect.h"
#include "render-utils/ShaderConstants.h"
using namespace render;
@ -37,7 +39,7 @@ namespace gr {
#define OUTLINE_STENCIL_MASK 1
extern void initZPassPipelines(ShapePlumber& plumber, gpu::StatePointer state);
extern void initZPassPipelines(ShapePlumber& plumber, gpu::StatePointer state, const render::ShapePipeline::BatchSetter& batchSetter, const render::ShapePipeline::ItemSetter& itemSetter);
HighlightResources::HighlightResources() {
}
@ -156,7 +158,6 @@ void DrawHighlightMask::run(const render::RenderContextPointer& renderContext, c
auto& highlight = highlightStage->getHighlight(highlightId);
RenderArgs* args = renderContext->args;
ShapeKey::Builder defaultKeyBuilder;
// Render full screen
outputs = args->_viewport;
@ -177,10 +178,6 @@ void DrawHighlightMask::run(const render::RenderContextPointer& renderContext, c
gpu::doInBatch("DrawHighlightMask::run", args->_context, [&](gpu::Batch& batch) {
args->_batch = &batch;
auto maskPipeline = _shapePlumber->pickPipeline(args, defaultKeyBuilder);
auto maskDeformedPipeline = _shapePlumber->pickPipeline(args, defaultKeyBuilder.withDeformed());
auto maskDeformedDQPipeline = _shapePlumber->pickPipeline(args, defaultKeyBuilder.withDeformed().withDualQuatSkinned());
// Setup camera, projection and viewport for all items
glm::mat4 projMat;
Transform viewMat;
@ -191,38 +188,54 @@ void DrawHighlightMask::run(const render::RenderContextPointer& renderContext, c
batch.setProjectionJitter(jitter.x, jitter.y);
batch.setViewTransform(viewMat);
std::vector<ShapeKey> deformedShapeKeys;
std::vector<ShapeKey> deformedDQShapeKeys;
const std::vector<ShapeKey::Builder> keys = {
ShapeKey::Builder(), ShapeKey::Builder().withFade(),
ShapeKey::Builder().withDeformed(), ShapeKey::Builder().withDeformed().withFade(),
ShapeKey::Builder().withDeformed().withDualQuatSkinned(), ShapeKey::Builder().withDeformed().withDualQuatSkinned().withFade(),
ShapeKey::Builder().withOwnPipeline(), ShapeKey::Builder().withOwnPipeline().withFade()
};
std::vector<std::vector<ShapeKey>> sortedShapeKeys(keys.size());
// Iterate through all inShapes and render the unskinned
args->_shapePipeline = maskPipeline;
batch.setPipeline(maskPipeline->pipeline);
const int OWN_PIPELINE_INDEX = 6;
for (const auto& items : inShapes) {
itemBounds.insert(itemBounds.end(), items.second.begin(), items.second.end());
if (items.first.isDeformed() && items.first.isDualQuatSkinned()) {
deformedDQShapeKeys.push_back(items.first);
} else if (items.first.isDeformed()) {
deformedShapeKeys.push_back(items.first);
} else {
renderItems(renderContext, items.second);
int index = items.first.hasOwnPipeline() ? OWN_PIPELINE_INDEX : 0;
if (items.first.isDeformed()) {
index += 2;
if (items.first.isDualQuatSkinned()) {
index += 2;
}
}
if (items.first.isFaded()) {
index += 1;
}
sortedShapeKeys[index].push_back(items.first);
}
// Render non-withOwnPipeline things
for (size_t i = 0; i < OWN_PIPELINE_INDEX; i++) {
auto& shapeKeys = sortedShapeKeys[i];
if (shapeKeys.size() > 0) {
const auto& shapePipeline = _shapePlumber->pickPipeline(args, keys[i]);
args->_shapePipeline = shapePipeline;
for (const auto& key : shapeKeys) {
renderShapes(renderContext, _shapePlumber, inShapes.at(key));
}
}
}
// Reiterate to render the skinned
if (deformedShapeKeys.size() > 0) {
args->_shapePipeline = maskDeformedPipeline;
batch.setPipeline(maskDeformedPipeline->pipeline);
for (const auto& key : deformedShapeKeys) {
renderItems(renderContext, inShapes.at(key));
}
}
// Reiterate to render the DQ skinned
if (deformedDQShapeKeys.size() > 0) {
args->_shapePipeline = maskDeformedDQPipeline;
batch.setPipeline(maskDeformedDQPipeline->pipeline);
for (const auto& key : deformedDQShapeKeys) {
renderItems(renderContext, inShapes.at(key));
// Render withOwnPipeline things
for (size_t i = OWN_PIPELINE_INDEX; i < keys.size(); i++) {
auto& shapeKeys = sortedShapeKeys[i];
if (shapeKeys.size() > 0) {
args->_shapePipeline = nullptr;
for (const auto& key : shapeKeys) {
args->_itemShapeKey = key._flags.to_ulong();
renderShapes(renderContext, _shapePlumber, inShapes.at(key));
}
}
}
@ -502,7 +515,9 @@ void DrawHighlightTask::build(JobModel& task, const render::Varying& inputs, ren
state->setDepthTest(true, true, gpu::LESS_EQUAL);
state->setColorWriteMask(false, false, false, false);
initZPassPipelines(*shapePlumber, state);
auto fadeEffect = DependencyManager::get<FadeEffect>();
initZPassPipelines(*shapePlumber, state, fadeEffect->getBatchSetter(), fadeEffect->getItemUniformSetter());
}
auto sharedParameters = std::make_shared<HighlightSharedParameters>();

30
libraries/render-utils/src/RenderPipelines.cpp
View file

@ -40,7 +40,7 @@ namespace gr {
void initDeferredPipelines(ShapePlumber& plumber, const render::ShapePipeline::BatchSetter& batchSetter, const render::ShapePipeline::ItemSetter& itemSetter);
void initForwardPipelines(ShapePlumber& plumber);
void initZPassPipelines(ShapePlumber& plumber, gpu::StatePointer state);
void initZPassPipelines(ShapePlumber& plumber, gpu::StatePointer state, const render::ShapePipeline::BatchSetter& batchSetter, const render::ShapePipeline::ItemSetter& itemSetter);
void addPlumberPipeline(ShapePlumber& plumber,
const ShapeKey& key, int programId,
@ -364,37 +364,29 @@ void lightBatchSetter(const ShapePipeline& pipeline, gpu::Batch& batch, RenderAr
}
}
void initZPassPipelines(ShapePlumber& shapePlumber, gpu::StatePointer state) {
void initZPassPipelines(ShapePlumber& shapePlumber, gpu::StatePointer state, const render::ShapePipeline::BatchSetter& extraBatchSetter, const render::ShapePipeline::ItemSetter& itemSetter) {
using namespace shader::render_utils::program;
gpu::ShaderPointer modelProgram = gpu::Shader::createProgram(model_shadow);
shapePlumber.addPipeline(
ShapeKey::Filter::Builder().withoutDeformed().withoutFade(),
modelProgram, state);
gpu::ShaderPointer skinProgram = gpu::Shader::createProgram(deformed_model_shadow);
shapePlumber.addPipeline(
ShapeKey::Filter::Builder().withDeformed().withoutDualQuatSkinned().withoutFade(),
skinProgram, state);
gpu::ShaderPointer modelFadeProgram = gpu::Shader::createProgram(model_shadow_fade);
gpu::Shader::createProgram(model_shadow), state);
shapePlumber.addPipeline(
ShapeKey::Filter::Builder().withoutDeformed().withFade(),
modelFadeProgram, state);
gpu::Shader::createProgram(model_shadow_fade), state, extraBatchSetter, itemSetter);
gpu::ShaderPointer skinFadeProgram = gpu::Shader::createProgram(deformed_model_shadow_fade);
shapePlumber.addPipeline(
ShapeKey::Filter::Builder().withDeformed().withoutDualQuatSkinned().withoutFade(),
gpu::Shader::createProgram(deformed_model_shadow), state);
shapePlumber.addPipeline(
ShapeKey::Filter::Builder().withDeformed().withoutDualQuatSkinned().withFade(),
skinFadeProgram, state);
gpu::Shader::createProgram(deformed_model_shadow_fade), state, extraBatchSetter, itemSetter);
gpu::ShaderPointer skinModelShadowDualQuatProgram = gpu::Shader::createProgram(deformed_model_shadow_dq);
shapePlumber.addPipeline(
ShapeKey::Filter::Builder().withDeformed().withDualQuatSkinned().withoutFade(),
skinModelShadowDualQuatProgram, state);
gpu::ShaderPointer skinModelShadowFadeDualQuatProgram = gpu::Shader::createProgram(deformed_model_shadow_fade_dq);
gpu::Shader::createProgram(deformed_model_shadow_dq), state);
shapePlumber.addPipeline(
ShapeKey::Filter::Builder().withDeformed().withDualQuatSkinned().withFade(),
skinModelShadowFadeDualQuatProgram, state);
gpu::Shader::createProgram(deformed_model_shadow_fade_dq), state, extraBatchSetter, itemSetter);
}
// FIXME find a better way to setup the default textures

85
libraries/render-utils/src/RenderShadowTask.cpp
View file

@ -26,6 +26,8 @@
#include "RenderCommonTask.h"
#include "FadeEffect.h"
// These values are used for culling the objects rendered in the shadow map
// but are readjusted afterwards
#define SHADOW_FRUSTUM_NEAR 1.0f
@ -33,7 +35,7 @@
using namespace render;
extern void initZPassPipelines(ShapePlumber& plumber, gpu::StatePointer state);
extern void initZPassPipelines(ShapePlumber& plumber, gpu::StatePointer state, const render::ShapePipeline::BatchSetter& batchSetter, const render::ShapePipeline::ItemSetter& itemSetter);
void RenderShadowTask::configure(const Config& configuration) {
DependencyManager::get<DeferredLightingEffect>()->setShadowMapEnabled(configuration.enabled);
@ -49,7 +51,8 @@ void RenderShadowTask::build(JobModel& task, const render::Varying& input, rende
state->setCullMode(gpu::State::CULL_BACK);
state->setDepthTest(true, true, gpu::LESS_EQUAL);
initZPassPipelines(*shapePlumber, state);
auto fadeEffect = DependencyManager::get<FadeEffect>();
initZPassPipelines(*shapePlumber, state, fadeEffect->getBatchSetter(), fadeEffect->getItemUniformSetter());
}
// FIXME: calling this here before the zones/lights are drawn during the deferred/forward passes means we're actually using the frames from the previous draw
@ -222,7 +225,6 @@ void RenderShadowMap::run(const render::RenderContextPointer& renderContext, con
auto& fbo = cascade.framebuffer;
RenderArgs* args = renderContext->args;
ShapeKey::Builder defaultKeyBuilder;
auto adjustedShadowFrustum = args->getViewFrustum();
// Adjust the frustum near and far depths based on the rendered items bounding box to have
@ -253,53 +255,56 @@ void RenderShadowMap::run(const render::RenderContextPointer& renderContext, con
batch.setProjectionTransform(projMat);
batch.setViewTransform(viewMat, false);
auto shadowPipeline = _shapePlumber->pickPipeline(args, defaultKeyBuilder);
auto shadowDeformedPipeline = _shapePlumber->pickPipeline(args, defaultKeyBuilder.withDeformed());
auto shadowDeformedDQPipeline = _shapePlumber->pickPipeline(args, defaultKeyBuilder.withDeformed().withDualQuatSkinned());
const std::vector<ShapeKey::Builder> keys = {
ShapeKey::Builder(), ShapeKey::Builder().withFade(),
ShapeKey::Builder().withDeformed(), ShapeKey::Builder().withDeformed().withFade(),
ShapeKey::Builder().withDeformed().withDualQuatSkinned(), ShapeKey::Builder().withDeformed().withDualQuatSkinned().withFade(),
ShapeKey::Builder().withOwnPipeline(), ShapeKey::Builder().withOwnPipeline().withFade()
};
std::vector<std::vector<ShapeKey>> sortedShapeKeys(keys.size());
std::vector<ShapeKey> deformedShapeKeys{};
std::vector<ShapeKey> deformedDQShapeKeys{};
std::vector<ShapeKey> ownPipelineShapeKeys{};
// Iterate through all inShapes and render the unskinned
args->_shapePipeline = shadowPipeline;
batch.setPipeline(shadowPipeline->pipeline);
for (auto items : inShapes) {
const int OWN_PIPELINE_INDEX = 6;
for (const auto& items : inShapes) {
int index = items.first.hasOwnPipeline() ? OWN_PIPELINE_INDEX : 0;
if (items.first.isDeformed()) {
index += 2;
if (items.first.isDualQuatSkinned()) {
deformedDQShapeKeys.push_back(items.first);
} else {
deformedShapeKeys.push_back(items.first);
index += 2;
}
}
if (items.first.isFaded()) {
index += 1;
}
sortedShapeKeys[index].push_back(items.first);
}
// Render non-withOwnPipeline things
for (size_t i = 0; i < OWN_PIPELINE_INDEX; i++) {
auto& shapeKeys = sortedShapeKeys[i];
if (shapeKeys.size() > 0) {
const auto& shapePipeline = _shapePlumber->pickPipeline(args, keys[i]);
args->_shapePipeline = shapePipeline;
for (const auto& key : shapeKeys) {
renderShapes(renderContext, _shapePlumber, inShapes.at(key));
}
} else if (!items.first.hasOwnPipeline()) {
renderItems(renderContext, items.second);
} else {
ownPipelineShapeKeys.push_back(items.first);
}
}
// Reiterate to render the skinned
args->_shapePipeline = shadowDeformedPipeline;
batch.setPipeline(shadowDeformedPipeline->pipeline);
for (const auto& key : deformedShapeKeys) {
renderItems(renderContext, inShapes.at(key));
// Render withOwnPipeline things
for (size_t i = OWN_PIPELINE_INDEX; i < keys.size(); i++) {
auto& shapeKeys = sortedShapeKeys[i];
if (shapeKeys.size() > 0) {
args->_shapePipeline = nullptr;
for (const auto& key : shapeKeys) {
args->_itemShapeKey = key._flags.to_ulong();
renderShapes(renderContext, _shapePlumber, inShapes.at(key));
}
}
}
// Reiterate to render the DQ skinned
args->_shapePipeline = shadowDeformedDQPipeline;
batch.setPipeline(shadowDeformedDQPipeline->pipeline);
for (const auto& key : deformedDQShapeKeys) {
renderItems(renderContext, inShapes.at(key));
}
// Finally render the items with their own pipeline last to prevent them from breaking the
// render state. This is probably a temporary code as there is probably something better
// to do in the render call of objects that have their own pipeline.
args->_shapePipeline = nullptr;
for (const auto& key : ownPipelineShapeKeys) {
args->_itemShapeKey = key._flags.to_ulong();
renderItems(renderContext, inShapes.at(key));
}
}
args->_batch = nullptr;