* limitations under the License.
*
*/
+#include <cstring>
+#include <iostream>
+#include <random>
#include "dali/dali.h"
#include "dali/public-api/actors/actor.h"
#include "dali/public-api/rendering/renderer.h"
-#include <random>
-#include <iostream>
-#include <cstring>
+
+#include "generated/deferred-shading-mainpass-vert.h"
+#include "generated/deferred-shading-mainpass-frag.h"
+#include "generated/deferred-shading-prepass-vert.h"
+#include "generated/deferred-shading-prepass-frag.h"
using namespace Dali;
#define DEFINE_MAX_LIGHTS "const int kMaxLights = " QUOTE(MAX_LIGHTS) ";"
-#define DEFINE(x) "#define " DALI_COMPOSE_SHADER(x) DALI_COMPOSE_SHADER(\n)
-
-//=============================================================================
-// PRE-PASS
-//=============================================================================
-const char* const PREPASS_VSH = DALI_COMPOSE_SHADER(#version 300 es\n
-precision mediump float;)
- DALI_COMPOSE_SHADER(
-
-// DALI uniforms
-uniform mat4 uMvpMatrix;
-uniform mat3 uNormalMatrix;
-uniform vec3 uSize;
-
-uniform vec3 uDepth_InvDepth_Near;\n)
- DEFINE(DEPTH uDepth_InvDepth_Near.x)
- DEFINE(INV_DEPTH uDepth_InvDepth_Near.y)
- DEFINE(NEAR uDepth_InvDepth_Near.z)
- DALI_COMPOSE_SHADER(
-
-in vec3 aPosition;
-in vec3 aNormal;
-
-out vec4 vPosition;
-out vec3 vNormal;
-
-vec4 Map(vec4 v) // projection space -> texture
-{
- return vec4(v.xyz / (2.f * v.w) + vec3(.5f), (v.w - NEAR) * INV_DEPTH);
-}
-
-void main()
-{
- vec4 position = uMvpMatrix * vec4(aPosition * uSize, 1.f);
- vPosition = Map(position);
- gl_Position = position;
-
- vNormal = normalize(uNormalMatrix * aNormal);
-});
-
-//=============================================================================
-const char* const PREPASS_FSH = DALI_COMPOSE_SHADER(#version 300 es\n
-precision mediump float;
-
-// DALI uniform
-uniform vec4 uColor;
-
-in vec4 vPosition;
-in vec3 vNormal;
-
-// These are our outputs.
-layout(location = 0) out vec3 oNormal;
-layout(location = 1) out vec4 oPosition;
-layout(location = 2) out vec3 oColor;
-
-void main()
-{
- oColor = uColor.rgb;
- oPosition = vPosition;
- oNormal = normalize(vNormal) * .5f + .5f;
-});
-
-//=============================================================================
-// MAIN (LIGHTING) PASS
-//=============================================================================
-const char* const MAINPASS_VSH = DALI_COMPOSE_SHADER(#version 300 es\n
-precision mediump float;
-
-// DALI uniforms
-uniform mat4 uMvpMatrix;
-uniform vec3 uSize;
-
-in vec3 aPosition;
-in vec2 aTexCoord;
-
-out vec2 vUv;
-
-void main()
-{
- vec4 position = uMvpMatrix * vec4(aPosition * uSize, 1.f);
- vUv = aTexCoord;
-
- gl_Position = position;
-});
-
-//=============================================================================
-const char* const MAINPASS_FSH = DALI_COMPOSE_SHADER(#version 300 es\n
-precision mediump float;\n)
- DEFINE_MAX_LIGHTS
- DALI_COMPOSE_SHADER(
-
-const float kAttenuationConst = .05f;
-const float kAttenuationLinear = .1f;
-const float kAttenuationQuadratic = .15f;
-
-// G-buffer
-uniform sampler2D uTextureNormal;
-uniform sampler2D uTexturePosition;
-uniform sampler2D uTextureColor;
-
-uniform mat4 uInvProjection;
-
-uniform vec3 uDepth_InvDepth_Near;\n)
- DEFINE(DEPTH uDepth_InvDepth_Near.x)
- DEFINE(INV_DEPTH uDepth_InvDepth_Near.y)
- DEFINE(NEAR uDepth_InvDepth_Near.z)
- DALI_COMPOSE_SHADER(
-
-// Light source uniforms
-struct Light
-{
- vec3 position; // view space
- float radius;
- vec3 color;
-};
-
-uniform Light uLights[kMaxLights];
-
-in vec2 vUv;
-
-out vec4 oColor;
-
-vec4 Unmap(vec4 m) // texture -> projection
-{
- m.w = m.w * DEPTH + NEAR;
- m.xyz = (m.xyz - vec3(.5)) * (2.f * m.w);
- return m;
-}
-
-vec3 CalculateLighting(vec3 pos, vec3 normal)
-{
- vec3 viewDir = normalize(pos);
- vec3 viewDirRefl = -reflect(viewDir, normal);
-
- vec3 light = vec3(0.04f); // fake ambient term
- for (int i = 0; i < kMaxLights; ++i)
- {
- vec3 rel = pos - uLights[i].position;
- float distance = length(rel);
- rel /= distance;
-
- float a = uLights[i].radius / (kAttenuationConst + kAttenuationLinear * distance +
- kAttenuationQuadratic * distance * distance); // attenuation
-
- float l = max(0.f, dot(normal, rel)); // lambertian
- float s = pow(max(0.f, dot(viewDirRefl, rel)), 256.f); // specular
-
- light += (uLights[i].color * (l + s)) * a;
- }
-
- return light;
-}
-
-void main()
-{
- vec3 normSample = texture(uTextureNormal, vUv).xyz;
- if (dot(normSample, normSample) == 0.f)
- {
- discard; // if we didn't write this texel, don't bother lighting it.
- }
-
- vec3 normal = normalize(normSample - .5f);
-
- vec4 posSample = texture(uTexturePosition, vUv);
- vec3 pos = (uInvProjection * Unmap(posSample)).xyz;
-
- vec3 color = texture(uTextureColor, vUv).rgb;
- vec3 finalColor = color * CalculateLighting(pos, normal);
-
- oColor = vec4(finalColor, 1.f);
-});
-
//=============================================================================
// PRNG for floats.
struct FloatRand
{
- std::random_device mDevice;
- std::mt19937 mMersenneTwister;
+ std::random_device mDevice;
+ std::mt19937 mMersenneTwister;
std::uniform_real_distribution<float> mDistribution;
FloatRand()
: mMersenneTwister(mDevice()),
mDistribution(0., 1.)
- {}
+ {
+ }
float operator()()
{
Vector3 FromHueSaturationLightness(Vector3 hsl)
{
Vector3 rgb;
- if (hsl.y * hsl.y > 0.f)
+ if(hsl.y * hsl.y > 0.f)
{
if(hsl.x >= 360.f)
{
}
hsl.x /= 60.f;
- int i = FastFloor(hsl.x);
+ int i = FastFloor(hsl.x);
float ff = hsl.x - i;
- float p = hsl.z * (1.0 - hsl.y);
- float q = hsl.z * (1.0 - (hsl.y * ff));
- float t = hsl.z * (1.0 - (hsl.y * (1.f - ff)));
+ float p = hsl.z * (1.0 - hsl.y);
+ float q = hsl.z * (1.0 - (hsl.y * ff));
+ float t = hsl.z * (1.0 - (hsl.y * (1.f - ff)));
- switch (i)
+ switch(i)
{
- case 0:
- rgb.r = hsl.z;
- rgb.g = t;
- rgb.b = p;
- break;
-
- case 1:
- rgb.r = q;
- rgb.g = hsl.z;
- rgb.b = p;
- break;
-
- case 2:
- rgb.r = p;
- rgb.g = hsl.z;
- rgb.b = t;
- break;
-
- case 3:
- rgb.r = p;
- rgb.g = q;
- rgb.b = hsl.z;
- break;
-
- case 4:
- rgb.r = t;
- rgb.g = p;
- rgb.b = hsl.z;
- break;
-
- case 5:
- default:
- rgb.r = hsl.z;
- rgb.g = p;
- rgb.b = q;
- break;
+ case 0:
+ rgb.r = hsl.z;
+ rgb.g = t;
+ rgb.b = p;
+ break;
+
+ case 1:
+ rgb.r = q;
+ rgb.g = hsl.z;
+ rgb.b = p;
+ break;
+
+ case 2:
+ rgb.r = p;
+ rgb.g = hsl.z;
+ rgb.b = t;
+ break;
+
+ case 3:
+ rgb.r = p;
+ rgb.g = q;
+ rgb.b = hsl.z;
+ break;
+
+ case 4:
+ rgb.r = t;
+ rgb.g = p;
+ rgb.b = hsl.z;
+ break;
+
+ case 5:
+ default:
+ rgb.r = hsl.z;
+ rgb.g = p;
+ rgb.b = q;
+ break;
}
}
else
};
Vertex vertexData[] = {
- { Vector3(-.5f, .5f, .0f), Vector2(.0f, 1.0f) },
- { Vector3(.5f, .5f, .0f), Vector2(1.0f, 1.0f) },
- { Vector3(-.5f, -.5f, .0f), Vector2(.0f, .0f) },
- { Vector3(.5f, -.5f, .0f), Vector2(1.0f, .0f) },
+ {Vector3(-.5f, .5f, .0f), Vector2(.0f, 1.0f)},
+ {Vector3(.5f, .5f, .0f), Vector2(1.0f, 1.0f)},
+ {Vector3(-.5f, -.5f, .0f), Vector2(.0f, .0f)},
+ {Vector3(.5f, -.5f, .0f), Vector2(1.0f, .0f)},
};
- if (flipV)
+ if(flipV)
{
std::swap(vertexData[0].aTexCoord, vertexData[2].aTexCoord);
std::swap(vertexData[1].aTexCoord, vertexData[3].aTexCoord);
}
- PropertyBuffer vertexBuffer = PropertyBuffer::New( Property::Map()
- .Add( "aPosition", Property::VECTOR3 )
- .Add( "aTexCoord", Property::VECTOR2 ) );
- vertexBuffer.SetData( vertexData, std::extent<decltype(vertexData)>::value );
+ VertexBuffer vertexBuffer = VertexBuffer::New(Property::Map()
+ .Add("aPosition", Property::VECTOR3)
+ .Add("aTexCoord", Property::VECTOR2));
+ vertexBuffer.SetData(vertexData, std::extent<decltype(vertexData)>::value);
Geometry geometry = Geometry::New();
- geometry.AddVertexBuffer( vertexBuffer );
- geometry.SetType( Geometry::TRIANGLE_STRIP );
+ geometry.AddVertexBuffer(vertexBuffer);
+ geometry.SetType(Geometry::TRIANGLE_STRIP);
return geometry;
}
Geometry CreateOctahedron(bool invertNormals)
{
Vector3 positions[] = {
- Vector3{ -1.f, 0.f, 0.f },
- Vector3{ 1.f, 0.f, 0.f },
- Vector3{ 0.f, -1.f, 0.f },
- Vector3{ 0.f, 1.f, 0.f },
- Vector3{ 0.f, 0.f, -1.f },
- Vector3{ 0.f, 0.f, 1.f },
+ Vector3{-1.f, 0.f, 0.f},
+ Vector3{1.f, 0.f, 0.f},
+ Vector3{0.f, -1.f, 0.f},
+ Vector3{0.f, 1.f, 0.f},
+ Vector3{0.f, 0.f, -1.f},
+ Vector3{0.f, 0.f, 1.f},
};
struct Vertex
Vector3 normal;
};
Vertex vertexData[] = {
- { positions[0] },
- { positions[3] },
- { positions[5] },
+ {positions[0]},
+ {positions[3]},
+ {positions[5]},
- { positions[5] },
- { positions[3] },
- { positions[1] },
+ {positions[5]},
+ {positions[3]},
+ {positions[1]},
- { positions[1] },
- { positions[3] },
- { positions[4] },
+ {positions[1]},
+ {positions[3]},
+ {positions[4]},
- { positions[4] },
- { positions[3] },
- { positions[0] },
+ {positions[4]},
+ {positions[3]},
+ {positions[0]},
- { positions[0] },
- { positions[5] },
- { positions[2] },
+ {positions[0]},
+ {positions[5]},
+ {positions[2]},
- { positions[5] },
- { positions[1] },
- { positions[2] },
+ {positions[5]},
+ {positions[1]},
+ {positions[2]},
- { positions[1] },
- { positions[4] },
- { positions[2] },
+ {positions[1]},
+ {positions[4]},
+ {positions[2]},
- { positions[4] },
- { positions[0] },
- { positions[2] },
+ {positions[4]},
+ {positions[0]},
+ {positions[2]},
};
// Calculate normals
- for (uint32_t i = 0; i < std::extent<decltype(vertexData)>::value / 3; ++i)
+ for(uint32_t i = 0; i < std::extent<decltype(vertexData)>::value / 3; ++i)
{
uint32_t idx = i * 3;
- Vector3 normal = (vertexData[idx + 2].position - vertexData[idx].position).
- Cross(vertexData[idx + 1].position - vertexData[idx].position);
+ Vector3 normal = (vertexData[idx + 2].position - vertexData[idx].position).Cross(vertexData[idx + 1].position - vertexData[idx].position);
normal.Normalize();
normal *= invertNormals * 2.f - 1.f;
vertexData[idx++].normal = normal;
vertexData[idx++].normal = normal;
- vertexData[idx].normal = normal;
+ vertexData[idx].normal = normal;
}
// Configure property buffers and create geometry.
- PropertyBuffer vertexBuffer = PropertyBuffer::New(Property::Map()
- .Add("aPosition", Property::VECTOR3)
- .Add("aNormal", Property::VECTOR3));
+ VertexBuffer vertexBuffer = VertexBuffer::New(Property::Map()
+ .Add("aPosition", Property::VECTOR3)
+ .Add("aNormal", Property::VECTOR3));
vertexBuffer.SetData(vertexData, std::extent<decltype(vertexData)>::value);
Geometry geometry = Geometry::New();
- geometry.AddVertexBuffer( vertexBuffer );
- geometry.SetType( Geometry::TRIANGLES );
+ geometry.AddVertexBuffer(vertexBuffer);
+ geometry.SetType(Geometry::TRIANGLES);
return geometry;
}
//=============================================================================
enum RendererOptions
{
- OPTION_NONE = 0x0,
- OPTION_BLEND = 0x01,
- OPTION_DEPTH_TEST = 0x02,
+ OPTION_NONE = 0x0,
+ OPTION_BLEND = 0x01,
+ OPTION_DEPTH_TEST = 0x02,
OPTION_DEPTH_WRITE = 0x04
};
{
Renderer renderer = Renderer::New(geometry, shader);
renderer.SetProperty(Renderer::Property::BLEND_MODE,
- (options & OPTION_BLEND) ? BlendMode::ON : BlendMode::OFF);
+ (options & OPTION_BLEND) ? BlendMode::ON : BlendMode::OFF);
renderer.SetProperty(Renderer::Property::DEPTH_TEST_MODE,
- (options & OPTION_DEPTH_TEST) ? DepthTestMode::ON : DepthTestMode::OFF);
+ (options & OPTION_DEPTH_TEST) ? DepthTestMode::ON : DepthTestMode::OFF);
renderer.SetProperty(Renderer::Property::DEPTH_WRITE_MODE,
- (options & OPTION_DEPTH_WRITE) ? DepthWriteMode::ON : DepthWriteMode::OFF);
+ (options & OPTION_DEPTH_WRITE) ? DepthWriteMode::ON : DepthWriteMode::OFF);
renderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK);
- if (!textures)
+ if(!textures)
{
textures = TextureSet::New();
}
//=============================================================================
void CenterActor(Actor actor)
{
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
}
//=============================================================================
h.RegisterProperty("uDepth_InvDepth_Near", Vector3(depth, 1.f / depth, near));
}
-}
+} // namespace
//=============================================================================
/// Create a String whose size can be evaluated at compile time
struct ConstantString
{
- const char * const string;
- const uint16_t size;
+ const char* const string;
+ const uint16_t size;
template<uint16_t inputSize>
constexpr ConstantString(const char (&input)[inputSize])
constexpr ConstantString POSITION_STRING("position");
constexpr ConstantString RADIUS_STRING("radius");
constexpr ConstantString COLOR_STRING("color");
-constexpr uint16_t LIGHT_SOURCE_BUFFER_SIZE(128u);
+constexpr uint16_t LIGHT_SOURCE_BUFFER_SIZE(128u);
//=============================================================================
class DeferredShadingExample : public ConnectionTracker
{
enum
{
- NONE = 0x0,
+ NONE = 0x0,
SHOW_LIGHTS = 0x1,
};
};
: mApp(app),
mOptions(options)
{
- app.InitSignal().Connect( this, &DeferredShadingExample::Create );
- app.TerminateSignal().Connect( this, &DeferredShadingExample::Destroy );
+ app.InitSignal().Connect(this, &DeferredShadingExample::Create);
+ app.TerminateSignal().Connect(this, &DeferredShadingExample::Destroy);
}
private:
void Create(Application& app)
{
// Grab window, configure layer
- Window window = app.GetWindow();
- auto rootLayer = window.GetRootLayer();
- rootLayer.SetProperty( Layer::Property::BEHAVIOR, Layer::LAYER_3D );
+ Window window = app.GetWindow();
+ auto rootLayer = window.GetRootLayer();
+ rootLayer.SetProperty(Layer::Property::BEHAVIOR, Layer::LAYER_3D);
Vector2 windowSize = window.GetSize();
float unit = windowSize.y / 24.f;
// Get camera - we'll be re-using the same old camera in the two passes.
- RenderTaskList tasks = window.GetRenderTaskList();
- CameraActor camera = tasks.GetTask(0).GetCameraActor();
+ RenderTaskList tasks = window.GetRenderTaskList();
+ CameraActor camera = tasks.GetTask(0).GetCameraActor();
auto zCameraPos = camera.GetProperty(Actor::Property::POSITION_Z).Get<float>();
camera.SetFarClippingPlane(zCameraPos + windowSize.y * .5f);
camera.SetNearClippingPlane(zCameraPos - windowSize.y * .5f);
const float zNear = camera.GetNearClippingPlane();
- const float zFar = camera.GetFarClippingPlane();
+ const float zFar = camera.GetFarClippingPlane();
const float depth = zFar - zNear;
// Create root of scene that shall be rendered off-screen.
Geometry mesh = CreateOctahedron(false);
// Create main actors
- Shader preShader = Shader::New(PREPASS_VSH, PREPASS_FSH);
+ Shader preShader = Shader::New(SHADER_DEFERRED_SHADING_PREPASS_VERT, SHADER_DEFERRED_SHADING_PREPASS_FRAG);
TextureSet noTexturesThanks = TextureSet::New();
- Renderer meshRenderer = CreateRenderer(noTexturesThanks, mesh, preShader,
- OPTION_DEPTH_TEST | OPTION_DEPTH_WRITE);
+ Renderer meshRenderer = CreateRenderer(noTexturesThanks, mesh, preShader, OPTION_DEPTH_TEST | OPTION_DEPTH_WRITE);
meshRenderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK);
RegisterDepthProperties(depth, zNear, meshRenderer);
float c = 1.f;
- for (auto v: {
- Vector3{ -c, -c, -c },
- Vector3{ c, -c, -c },
- Vector3{ -c, c, -c },
- Vector3{ c, c, -c },
- Vector3{ -c, -c, c },
- Vector3{ c, -c, c },
- Vector3{ -c, c, c },
- Vector3{ c, c, c },
-
- Vector3{ 0.f, -c, -c },
- Vector3{ 0.f, c, -c },
- Vector3{ 0.f, -c, c },
- Vector3{ 0.f, c, c },
-
- Vector3{ -c, 0.f, -c },
- Vector3{ c, 0.f, -c },
- Vector3{ -c, 0.f, c },
- Vector3{ c, 0.f, c },
-
- Vector3{ -c, -c, 0.f },
- Vector3{ c, -c, 0.f },
- Vector3{ -c, c, 0.f },
- Vector3{ c, c, 0.f },
- })
+ for(auto v : {
+ Vector3{-c, -c, -c},
+ Vector3{c, -c, -c},
+ Vector3{-c, c, -c},
+ Vector3{c, c, -c},
+ Vector3{-c, -c, c},
+ Vector3{c, -c, c},
+ Vector3{-c, c, c},
+ Vector3{c, c, c},
+
+ Vector3{0.f, -c, -c},
+ Vector3{0.f, c, -c},
+ Vector3{0.f, -c, c},
+ Vector3{0.f, c, c},
+
+ Vector3{-c, 0.f, -c},
+ Vector3{c, 0.f, -c},
+ Vector3{-c, 0.f, c},
+ Vector3{c, 0.f, c},
+
+ Vector3{-c, -c, 0.f},
+ Vector3{c, -c, 0.f},
+ Vector3{-c, c, 0.f},
+ Vector3{c, c, 0.f},
+ })
{
Actor a = Actor::New();
CenterActor(a);
- Vector3 position{ v * unit * 5.f };
- a.SetProperty( Actor::Property::POSITION, position );
+ Vector3 position{v * unit * 5.f};
+ a.SetProperty(Actor::Property::POSITION, position);
- float scale = (c + ((v.x + v.y + v.z) + c * 3.f) * .5f) / (c * 4.f);
- Vector3 size{ Vector3::ONE * scale * unit * 2.f };
- a.SetProperty( Actor::Property::SIZE, size);
+ float scale = (c + ((v.x + v.y + v.z) + c * 3.f) * .5f) / (c * 4.f);
+ Vector3 size{Vector3::ONE * scale * unit * 2.f};
+ a.SetProperty(Actor::Property::SIZE, size);
- a.SetProperty( Actor::Property::COLOR,Color::WHITE * .25f +
- (Color::RED * (v.x + c) / (c * 2.f) +
- Color::GREEN * (v.y + c) / (c * 2.f) +
- Color::BLUE * (v.z + c) / (c * 2.f)) * .015625f);
+ a.SetProperty(Actor::Property::COLOR, Color::WHITE * .25f + (Color::RED * (v.x + c) / (c * 2.f) + Color::GREEN * (v.y + c) / (c * 2.f) + Color::BLUE * (v.z + c) / (c * 2.f)) * .015625f);
a.AddRenderer(meshRenderer);
axis.Add(a);
}
// Create off-screen textures, fbo and render task.
- uint32_t width = static_cast<uint32_t>(windowSize.x);
+ uint32_t width = static_cast<uint32_t>(windowSize.x);
uint32_t height = static_cast<uint32_t>(windowSize.y);
- Texture rttNormal = Texture::New(TextureType::TEXTURE_2D, Pixel::Format::RGB888,
- width, height);
- Texture rttPosition = Texture::New(TextureType::TEXTURE_2D, Pixel::Format::RGBA8888,
- width, height);
- Texture rttColor = Texture::New(TextureType::TEXTURE_2D, Pixel::Format::RGB888,
- width, height);
- FrameBuffer fbo = FrameBuffer::New(width, height, FrameBuffer::Attachment::DEPTH);
+ Texture rttNormal = Texture::New(TextureType::TEXTURE_2D, Pixel::Format::RGB888, width, height);
+ Texture rttPosition = Texture::New(TextureType::TEXTURE_2D, Pixel::Format::RGBA8888, width, height);
+ Texture rttColor = Texture::New(TextureType::TEXTURE_2D, Pixel::Format::RGB888, width, height);
+ FrameBuffer fbo = FrameBuffer::New(width, height, FrameBuffer::Attachment::DEPTH);
fbo.AttachColorTexture(rttNormal);
fbo.AttachColorTexture(rttPosition);
fbo.AttachColorTexture(rttColor);
// Create final image for deferred shading
auto finalImage = Actor::New();
CenterActor(finalImage);
- finalImage.SetProperty( Actor::Property::SIZE, windowSize);
+ finalImage.SetProperty(Actor::Property::SIZE, windowSize);
TextureSet finalImageTextures = TextureSet::New();
finalImageTextures.SetTexture(0, rttNormal);
finalImageTextures.SetSampler(1, sampler);
finalImageTextures.SetSampler(2, sampler);
- Shader shdMain = Shader::New(MAINPASS_VSH, MAINPASS_FSH);
- Geometry finalImageGeom = CreateTexturedQuadGeometry(true);
+ Shader shdMain = Shader::New(SHADER_DEFERRED_SHADING_MAINPASS_VERT, SHADER_DEFERRED_SHADING_MAINPASS_FRAG);
+ Geometry finalImageGeom = CreateTexturedQuadGeometry(true);
Renderer finalImageRenderer = CreateRenderer(finalImageTextures, finalImageGeom, shdMain);
RegisterDepthProperties(depth, zNear, finalImageRenderer);
- auto propInvProjection = finalImageRenderer.RegisterProperty("uInvProjection", Matrix::IDENTITY);
- Constraint cnstrInvProjection = Constraint::New<Matrix>(finalImageRenderer, propInvProjection,
- [zCameraPos, zNear, depth](Matrix& output, const PropertyInputContainer& input) {
- output = input[0]->GetMatrix();
- DALI_ASSERT_ALWAYS(output.Invert() && "Failed to invert projection matrix.");
- });
+ auto propInvProjection = finalImageRenderer.RegisterProperty("uInvProjection", Matrix::IDENTITY);
+ Constraint cnstrInvProjection = Constraint::New<Matrix>(finalImageRenderer, propInvProjection, [zCameraPos, zNear, depth](Matrix& output, const PropertyInputContainer& input) {
+ output = input[0]->GetMatrix();
+ DALI_ASSERT_ALWAYS(output.Invert() && "Failed to invert projection matrix.");
+ });
cnstrInvProjection.AddSource(Source(camera, CameraActor::Property::PROJECTION_MATRIX));
cnstrInvProjection.AddSource(Source(camera, CameraActor::Property::VIEW_MATRIX));
cnstrInvProjection.Apply();
// Create Lights
const bool showLights = mOptions & Options::SHOW_LIGHTS;
- Renderer lightRenderer;
- if (showLights)
+ Renderer lightRenderer;
+ if(showLights)
{
Geometry lightMesh = CreateOctahedron(true);
- lightRenderer = CreateRenderer(noTexturesThanks, lightMesh, preShader,
- OPTION_DEPTH_TEST | OPTION_DEPTH_WRITE);
+ lightRenderer = CreateRenderer(noTexturesThanks, lightMesh, preShader, OPTION_DEPTH_TEST | OPTION_DEPTH_WRITE);
lightRenderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::FRONT);
}
- Vector3 lightPos{ unit * 12.f, 0.f, 0.f };
- float theta = M_PI * 2.f / MAX_LIGHTS;
- float cosTheta = std::cos(theta);
- float sinTheta = std::sin(theta);
- for (int i = 0; i < MAX_LIGHTS; ++i)
+ Vector3 lightPos{unit * 12.f, 0.f, 0.f};
+ float theta = M_PI * 2.f / MAX_LIGHTS;
+ float cosTheta = std::cos(theta);
+ float sinTheta = std::sin(theta);
+ for(int i = 0; i < MAX_LIGHTS; ++i)
{
Vector3 color = FromHueSaturationLightness(Vector3((360.f * i) / MAX_LIGHTS, .5f, 1.f));
Actor light = CreateLight(lightPos * (1 + (i % 8)) / 8.f, unit * 16.f, color, camera, finalImageRenderer);
- float z = (((i & 1) << 1) - 1) * unit * 8.f;
+ float z = (((i & 1) << 1) - 1) * unit * 8.f;
lightPos = Vector3(cosTheta * lightPos.x - sinTheta * lightPos.y, sinTheta * lightPos.x + cosTheta * lightPos.y, z);
- if (showLights)
+ if(showLights)
{
light.SetProperty(Actor::Property::SIZE, Vector3::ONE * unit / 8.f);
light.AddRenderer(lightRenderer);
light.SetProperty(Actor::Property::COLOR, Color::WHITE);
light.SetProperty(Actor::Property::POSITION, position);
- auto iPropRadius = light.RegisterProperty("radius", radius);
+ auto iPropRadius = light.RegisterProperty("radius", radius);
auto iPropLightColor = light.RegisterProperty("lightcolor", color);
// Create light source uniforms on lighting shader.
- char buffer[LIGHT_SOURCE_BUFFER_SIZE];
+ char buffer[LIGHT_SOURCE_BUFFER_SIZE];
char* writep = buffer + snprintf(buffer, LIGHT_SOURCE_BUFFER_SIZE, "uLights[%d].", mNumLights);
++mNumLights;
// Constrain the light position, radius and color to lighting shader uniforms.
// Convert light position to view space;
- Constraint cLightPos = Constraint::New<Vector3>(renderer, oPropLightPos, [](Vector3& output, const PropertyInputContainer& input)
- {
+ Constraint cLightPos = Constraint::New<Vector3>(renderer, oPropLightPos, [](Vector3& output, const PropertyInputContainer& input) {
Vector4 worldPos(input[0]->GetVector3());
worldPos.w = 1.f;
worldPos = input[1]->GetMatrix() * worldPos;
- output = Vector3(worldPos);
+ output = Vector3(worldPos);
});
cLightPos.AddSource(Source(light, Actor::Property::WORLD_POSITION));
cLightPos.AddSource(Source(camera, CameraActor::Property::VIEW_MATRIX));
cLightPos.Apply();
- Constraint cLightRadius = Constraint::New<float>(renderer, oPropLightRadius,
- EqualToConstraint());
+ Constraint cLightRadius = Constraint::New<float>(renderer, oPropLightRadius, EqualToConstraint());
cLightRadius.AddSource(Source(light, iPropRadius));
cLightRadius.Apply();
- Constraint cLightColor = Constraint::New<Vector3>(renderer, oPropLightColor,
- EqualToConstraint());
+ Constraint cLightColor = Constraint::New<Vector3>(renderer, oPropLightColor, EqualToConstraint());
cLightColor.AddSource(Source(light, iPropLightColor));
cLightColor.Apply();
void OnPan(Actor, PanGesture const& gesture)
{
- Quaternion q = mAxis.GetProperty(Actor::Property::ORIENTATION).Get<Quaternion>();
- Quaternion qx(Radian(Degree(gesture.screenDisplacement.y) * -.5f), Vector3::XAXIS);
- Quaternion qy(Radian(Degree(gesture.screenDisplacement.x) * .5f), Vector3::YAXIS);
+ Quaternion q = mAxis.GetProperty(Actor::Property::ORIENTATION).Get<Quaternion>();
+ const Vector2& displacement = gesture.GetScreenDisplacement();
+ Quaternion qx(Radian(Degree(displacement.y) * -.5f), Vector3::XAXIS);
+ Quaternion qy(Radian(Degree(displacement.x) * .5f), Vector3::YAXIS);
mAxis.SetProperty(Actor::Property::ORIENTATION, qy * qx * q);
}
void OnKeyEvent(const KeyEvent& event)
{
- if(event.GetState() == KeyEvent::Down)
+ if(event.GetState() == KeyEvent::DOWN)
{
- if( IsKey( event, Dali::DALI_KEY_ESCAPE) || IsKey( event, Dali::DALI_KEY_BACK) )
+ if(IsKey(event, Dali::DALI_KEY_ESCAPE) || IsKey(event, Dali::DALI_KEY_BACK))
{
mApp.Quit();
}
}
Application& mApp;
- uint32_t mOptions;
+ uint32_t mOptions;
Actor mSceneRoot;
Actor mAxis;
RenderTask mSceneRender;
- Actor mFinalImage;
+ Actor mFinalImage;
int mNumLights = 0;
PanGestureDetector mPanDetector;
};
-
-int main(int argc, char** argv)
+int DALI_EXPORT_API main(int argc, char** argv)
{
- const bool showLights = [](int argc, char** argv)
- {
+ const bool showLights = [](int argc, char** argv) {
auto endArgs = argv + argc;
- return std::find_if(argv, endArgs, [](const char* arg)
- {
- return strcmp(arg, "--show-lights") == 0;
- }) != endArgs;
+ return std::find_if(argv, endArgs, [](const char* arg) {
+ return strcmp(arg, "--show-lights") == 0;
+ }) != endArgs;
}(argc, argv);
- Application app = Application::New(&argc, &argv);
+ Application app = Application::New(&argc, &argv);
DeferredShadingExample example(app, (showLights ? DeferredShadingExample::Options::SHOW_LIGHTS : 0));
app.MainLoop();
return 0;