Mirrors/overte-lubosz
3
0
Fork 0
mirror of https://github.com/lubosz/overte.git synced 2025-04-09 08:22:30 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #13572 from Zvork/fade

Browse source 
Repair Transition effect
This commit is contained in:
John Conklin II 2018-07-12 10:54:20 -07:00 committed by GitHub
commit d1280bc464
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 75 additions and 48 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -15,19 +15,20 @@
#define CATEGORY_COUNT 5
<@include Fade_shared.slh@>
<@include FadeObjectParams.shared.slh@>
layout(std140) uniform fadeParametersBuffer {
FadeParameters fadeParameters[CATEGORY_COUNT];
};
uniform sampler2D fadeMaskMap;
struct FadeObjectParams {
int category;
float threshold;
vec3 noiseOffset;
vec3 baseOffset;
vec3 baseInvSize;
};
vec3 getNoiseInverseSize(int category) {
return fadeParameters[category]._noiseInvSizeAndLevel.xyz;
}
float getNoiseLevel(int category) {
return fadeParameters[category]._noiseInvSizeAndLevel.w;
}
vec2 hash2D(vec3 position) {
return position.xy* vec2(0.1677, 0.221765) + position.z*0.561;
@ -40,7 +41,7 @@ float noise3D(vec3 position) {
float evalFadeNoiseGradient(FadeObjectParams params, vec3 position) {
// Do tri-linear interpolation
vec3 noisePosition = position * fadeParameters[params.category]._noiseInvSizeAndLevel.xyz + params.noiseOffset;
vec3 noisePosition = position * getNoiseInverseSize(params.category) + params.noiseOffset.xyz;
vec3 noisePositionFloored = floor(noisePosition);
vec3 noisePositionFraction = fract(noisePosition);
@ -61,11 +62,11 @@ float evalFadeNoiseGradient(FadeObjectParams params, vec3 position) {
float noise = mix(maskY.x, maskY.y, noisePositionFraction.y);
noise -= 0.5; // Center on value 0
return noise * fadeParameters[params.category]._noiseInvSizeAndLevel.w;
return noise * getNoiseLevel(params.category);
}
float evalFadeBaseGradient(FadeObjectParams params, vec3 position) {
float gradient = length((position - params.baseOffset) * params.baseInvSize.xyz);
float gradient = length((position - params.baseOffset.xyz) * params.baseInvSize.xyz);
gradient = gradient-0.5; // Center on value 0.5
gradient *= fadeParameters[params.category]._baseLevel;
return gradient;
@ -112,20 +113,14 @@ void applyFade(FadeObjectParams params, vec3 position, out vec3 emissive) {
<@func declareFadeFragmentUniform()@>
uniform int fadeCategory;
uniform vec3 fadeNoiseOffset;
uniform vec3 fadeBaseOffset;
uniform vec3 fadeBaseInvSize;
uniform float fadeThreshold;
layout(std140) uniform fadeObjectParametersBuffer {
FadeObjectParams fadeObjectParams;
};
<@endfunc@>
<@func fetchFadeObjectParams(fadeParams)@>
<$fadeParams$>.category = fadeCategory;
<$fadeParams$>.threshold = fadeThreshold;
<$fadeParams$>.noiseOffset = fadeNoiseOffset;
<$fadeParams$>.baseOffset = fadeBaseOffset;
<$fadeParams$>.baseInvSize = fadeBaseInvSize;
<$fadeParams$> = fadeObjectParams;
<@endfunc@>
<@func declareFadeFragmentVertexInput()@>
@ -139,9 +134,9 @@ in vec4 _fadeData3;
<@func fetchFadeObjectParamsInstanced(fadeParams)@>
<$fadeParams$>.category = int(_fadeData1.w);
<$fadeParams$>.threshold = _fadeData2.w;
<$fadeParams$>.noiseOffset = _fadeData1.xyz;
<$fadeParams$>.baseOffset = _fadeData2.xyz;
<$fadeParams$>.baseInvSize = _fadeData3.xyz;
<$fadeParams$>.noiseOffset = _fadeData1;
<$fadeParams$>.baseOffset = _fadeData2;
<$fadeParams$>.baseInvSize = _fadeData3;
<@endfunc@>
<@func declareFadeFragment()@>

49
libraries/render-utils/src/FadeEffect.cpp
View file

@ -13,6 +13,8 @@
#include "render/TransitionStage.h"
#include "FadeObjectParams.shared.slh"
#include <PathUtils.h>
FadeEffect::FadeEffect() {
@ -31,15 +33,8 @@ void FadeEffect::build(render::Task::TaskConcept& task, const task::Varying& edi
render::ShapePipeline::BatchSetter FadeEffect::getBatchSetter() const {
return [this](const render::ShapePipeline& shapePipeline, gpu::Batch& batch, render::Args*) {
auto program = shapePipeline.pipeline->getProgram();
auto maskMapLocation = program->getTextures().findLocation("fadeMaskMap");
auto bufferLocation = program->getUniformBuffers().findLocation("fadeParametersBuffer");
if (maskMapLocation != -1) {
batch.setResourceTexture(maskMapLocation, _maskMap);
}
if (bufferLocation != -1) {
batch.setUniformBuffer(bufferLocation, _configurations);
}
batch.setResourceTexture(render::ShapePipeline::Slot::FADE_MASK, _maskMap);
batch.setUniformBuffer(render::ShapePipeline::Slot::FADE_PARAMETERS, _configurations);
};
}
@ -50,23 +45,29 @@ render::ShapePipeline::ItemSetter FadeEffect::getItemUniformSetter() const {
auto batch = args->_batch;
auto transitionStage = scene->getStage<render::TransitionStage>(render::TransitionStage::getName());
auto& transitionState = transitionStage->getTransition(item.getTransitionId());
auto program = shapePipeline.pipeline->getProgram();
auto& uniforms = program->getUniforms();
auto fadeNoiseOffsetLocation = uniforms.findLocation("fadeNoiseOffset");
auto fadeBaseOffsetLocation = uniforms.findLocation("fadeBaseOffset");
auto fadeBaseInvSizeLocation = uniforms.findLocation("fadeBaseInvSize");
auto fadeThresholdLocation = uniforms.findLocation("fadeThreshold");
auto fadeCategoryLocation = uniforms.findLocation("fadeCategory");
if (fadeNoiseOffsetLocation >= 0 || fadeBaseInvSizeLocation >= 0 || fadeBaseOffsetLocation >= 0 || fadeThresholdLocation >= 0 || fadeCategoryLocation >= 0) {
const auto fadeCategory = FadeJob::transitionToCategory[transitionState.eventType];
batch->_glUniform1i(fadeCategoryLocation, fadeCategory);
batch->_glUniform1f(fadeThresholdLocation, transitionState.threshold);
batch->_glUniform3f(fadeNoiseOffsetLocation, transitionState.noiseOffset.x, transitionState.noiseOffset.y, transitionState.noiseOffset.z);
batch->_glUniform3f(fadeBaseOffsetLocation, transitionState.baseOffset.x, transitionState.baseOffset.y, transitionState.baseOffset.z);
batch->_glUniform3f(fadeBaseInvSizeLocation, transitionState.baseInvSize.x, transitionState.baseInvSize.y, transitionState.baseInvSize.z);
if (transitionState.paramsBuffer._size != sizeof(gpu::StructBuffer<FadeObjectParams>)) {
static_assert(sizeof(transitionState.paramsBuffer) == sizeof(gpu::StructBuffer<FadeObjectParams>), "Assuming gpu::StructBuffer is a helper class for gpu::BufferView");
transitionState.paramsBuffer = gpu::StructBuffer<FadeObjectParams>();
}
const auto fadeCategory = FadeJob::transitionToCategory[transitionState.eventType];
auto& paramsConst = static_cast<gpu::StructBuffer<FadeObjectParams>&>(transitionState.paramsBuffer).get();
if (paramsConst.category != fadeCategory
|| paramsConst.threshold != transitionState.threshold
|| glm::vec3(paramsConst.baseOffset) != transitionState.baseOffset
|| glm::vec3(paramsConst.noiseOffset) != transitionState.noiseOffset
|| glm::vec3(paramsConst.baseInvSize) != transitionState.baseInvSize) {
auto& params = static_cast<gpu::StructBuffer<FadeObjectParams>&>(transitionState.paramsBuffer).edit();
params.category = fadeCategory;
params.threshold = transitionState.threshold;
params.baseInvSize = glm::vec4(transitionState.baseInvSize, 0.0f);
params.noiseOffset = glm::vec4(transitionState.noiseOffset, 0.0f);
params.baseOffset = glm::vec4(transitionState.baseOffset, 0.0f);
}
batch->setUniformBuffer(render::ShapePipeline::Slot::FADE_OBJECT_PARAMETERS, transitionState.paramsBuffer);
}
};
}

25
libraries/render-utils/src/FadeObjectParams.shared.slh Normal file
View file

@ -0,0 +1,25 @@
// glsl / C++ compatible source as interface for FadeObjectParams
#ifdef __cplusplus
# define FOP_VEC4 glm::vec4
# define FOP_VEC2 glm::vec2
# define FOP_FLOAT32 glm::float32
# define FOP_INT32 glm::int32
#else
# define FOP_VEC4 vec4
# define FOP_VEC2 vec2
# define FOP_FLOAT32 float
# define FOP_INT32 int
#endif
struct FadeObjectParams {
FOP_VEC4 noiseOffset;
FOP_VEC4 baseOffset;
FOP_VEC4 baseInvSize;
FOP_INT32 category;
FOP_FLOAT32 threshold;
};
// <@if 1@>
// Trigger Scribe include
// <@endif@> <!def that !>
//

2
libraries/render/src/render/ShapePipeline.cpp
View file

@ -95,6 +95,7 @@ void ShapePlumber::addPipeline(const Filter& filter, const gpu::ShaderPointer& p
slotBindings.insert(gpu::Shader::Binding(std::string("skyboxMap"), Slot::MAP::LIGHT_AMBIENT_MAP));
slotBindings.insert(gpu::Shader::Binding(std::string("fadeMaskMap"), Slot::MAP::FADE_MASK));
slotBindings.insert(gpu::Shader::Binding(std::string("fadeParametersBuffer"), Slot::BUFFER::FADE_PARAMETERS));
slotBindings.insert(gpu::Shader::Binding(std::string("fadeObjectParametersBuffer"), Slot::BUFFER::FADE_OBJECT_PARAMETERS));
slotBindings.insert(gpu::Shader::Binding(std::string("hazeBuffer"), Slot::BUFFER::HAZE_MODEL));
if (key.isTranslucent()) {
@ -124,6 +125,7 @@ void ShapePlumber::addPipeline(const Filter& filter, const gpu::ShaderPointer& p
locations->lightAmbientMapUnit = program->getTextures().findLocation("skyboxMap");
locations->fadeMaskTextureUnit = program->getTextures().findLocation("fadeMaskMap");
locations->fadeParameterBufferUnit = program->getUniformBuffers().findLocation("fadeParametersBuffer");
locations->fadeObjectParameterBufferUnit = program->getUniformBuffers().findLocation("fadeObjectParametersBuffer");
locations->hazeParameterBufferUnit = program->getUniformBuffers().findLocation("hazeBuffer");
if (key.isTranslucent()) {
locations->lightClusterGridBufferUnit = program->getUniformBuffers().findLocation("clusterGridBuffer");

4
libraries/render/src/render/ShapePipeline.h
View file

@ -240,6 +240,7 @@ public:
LIGHT_AMBIENT_BUFFER,
HAZE_MODEL,
FADE_PARAMETERS,
FADE_OBJECT_PARAMETERS,
LIGHT_CLUSTER_GRID_FRUSTUM_GRID_SLOT,
LIGHT_CLUSTER_GRID_CLUSTER_GRID_SLOT,
LIGHT_CLUSTER_GRID_CLUSTER_CONTENT_SLOT,
@ -254,9 +255,9 @@ public:
ROUGHNESS,
OCCLUSION,
SCATTERING,
FADE_MASK,
LIGHT_AMBIENT_MAP = 10,
FADE_MASK,
};
};
@ -278,6 +279,7 @@ public:
int lightAmbientMapUnit;
int fadeMaskTextureUnit;
int fadeParameterBufferUnit;
int fadeObjectParameterBufferUnit;
int hazeParameterBufferUnit;
int lightClusterGridBufferUnit;
int lightClusterContentBufferUnit;

2
libraries/render/src/render/Transition.h
View file

@ -42,6 +42,8 @@ namespace render {
glm::vec3 baseInvSize{ 1.f, 1.f, 1.f };
float threshold{ 0.f };
uint8_t isFinished{ 0 };
mutable gpu::BufferView paramsBuffer;
};
typedef std::shared_ptr<Transition> TransitionPointer;