out vec4 vPosition;
out vec3 vNormal;
-vec4 Map(vec4 v) // projection space -> texture
+vec4 Map(vec4 v) // projection space -> texture
{
return vec4(v.xyz / (2.f * v.w) + vec3(.5f), (v.w - NEAR) * INV_DEPTH);
}
// Light source uniforms
struct Light
{
- vec3 position; // view space
+ vec3 position; // view space
float radius;
vec3 color;
};
out vec4 oColor;
-vec4 Unmap(vec4 m) // texture -> projection
+vec4 Unmap(vec4 m) // texture -> projection
{
m.w = m.w * DEPTH + NEAR;
m.xyz = (m.xyz - vec3(.5)) * (2.f * m.w);
rel /= distance;
float a = uLights[i].radius / (kAttenuationConst + kAttenuationLinear * distance +
- kAttenuationQuadratic * distance * distance); // attenuation
+ 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
+ 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;
}
std::swap(vertexData[1].aTexCoord, vertexData[3].aTexCoord);
}
- PropertyBuffer vertexBuffer = PropertyBuffer::New( Property::Map()
+ VertexBuffer vertexBuffer = VertexBuffer::New( Property::Map()
.Add( "aPosition", Property::VECTOR3 )
.Add( "aTexCoord", Property::VECTOR2 ) );
vertexBuffer.SetData( vertexData, std::extent<decltype(vertexData)>::value );
}
// Configure property buffers and create geometry.
- PropertyBuffer vertexBuffer = PropertyBuffer::New(Property::Map()
+ VertexBuffer vertexBuffer = VertexBuffer::New(Property::Map()
.Add("aPosition", Property::VECTOR3)
.Add("aNormal", Property::VECTOR3));
vertexBuffer.SetData(vertexData, std::extent<decltype(vertexData)>::value);
//=============================================================================
void CenterActor(Actor actor)
{
- actor.SetAnchorPoint( AnchorPoint::CENTER );
- actor.SetParentOrigin( ParentOrigin::CENTER );
+ actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+ actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
}
//=============================================================================
private:
void Create(Application& app)
{
- // Grab stage, configure layer
- Stage stage = Stage::GetCurrent();
- auto rootLayer = stage.GetRootLayer();
- rootLayer.SetBehavior(Layer::LAYER_3D);
+ // Grab window, configure layer
+ Window window = app.GetWindow();
+ auto rootLayer = window.GetRootLayer();
+ rootLayer.SetProperty( Layer::Property::BEHAVIOR, Layer::LAYER_3D );
- auto stageSize = stage.GetSize();
- auto stageHalfSize = stageSize * .5f;
- auto invStageHalfSize = Vector2::ONE / stageHalfSize;
+ Vector2 windowSize = window.GetSize();
- float unit = stageSize.y / 24.f;
+ float unit = windowSize.y / 24.f;
// Get camera - we'll be re-using the same old camera in the two passes.
- RenderTaskList tasks = stage.GetRenderTaskList();
+ RenderTaskList tasks = window.GetRenderTaskList();
CameraActor camera = tasks.GetTask(0).GetCameraActor();
auto zCameraPos = camera.GetProperty(Actor::Property::POSITION_Z).Get<float>();
- camera.SetFarClippingPlane(zCameraPos + stageSize.y * .5f);
- camera.SetNearClippingPlane(zCameraPos - stageSize.y * .5f);
+ camera.SetFarClippingPlane(zCameraPos + windowSize.y * .5f);
+ camera.SetNearClippingPlane(zCameraPos - windowSize.y * .5f);
const float zNear = camera.GetNearClippingPlane();
const float zFar = camera.GetFarClippingPlane();
CenterActor(sceneRoot);
mSceneRoot = sceneRoot;
- stage.Add(sceneRoot);
+ window.Add(sceneRoot);
// Create an axis to spin our actors around.
auto axis = Actor::New();
Renderer meshRenderer = CreateRenderer(noTexturesThanks, mesh, preShader,
OPTION_DEPTH_TEST | OPTION_DEPTH_WRITE);
meshRenderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK);
- meshRenderer.RegisterProperty("uInvStageHalfSize", invStageHalfSize);
RegisterDepthProperties(depth, zNear, meshRenderer);
float c = 1.f;
for (auto v: {
CenterActor(a);
Vector3 position{ v * unit * 5.f };
- a.SetPosition(position);
+ 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.SetSize(size);
+ a.SetProperty( Actor::Property::SIZE, size);
- a.SetColor(Color::WHITE * .25f +
+ 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);
}
// Create off-screen textures, fbo and render task.
- uint32_t width = static_cast<uint32_t>(stageSize.x);
- uint32_t height = static_cast<uint32_t>(stageSize.y);
+ 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);
fbo.AttachColorTexture(rttColor);
RenderTask sceneRender = tasks.CreateTask();
- sceneRender.SetViewportSize(stageSize);
+ sceneRender.SetViewportSize(windowSize);
sceneRender.SetFrameBuffer(fbo);
sceneRender.SetCameraActor(camera);
sceneRender.SetSourceActor(sceneRoot);
// Create final image for deferred shading
auto finalImage = Actor::New();
CenterActor(finalImage);
- finalImage.SetSize(stageSize);
+ finalImage.SetProperty( Actor::Property::SIZE, windowSize);
TextureSet finalImageTextures = TextureSet::New();
finalImageTextures.SetTexture(0, rttNormal);
Shader shdMain = Shader::New(MAINPASS_VSH, MAINPASS_FSH);
Geometry finalImageGeom = CreateTexturedQuadGeometry(true);
Renderer finalImageRenderer = CreateRenderer(finalImageTextures, finalImageGeom, shdMain);
- finalImageRenderer.RegisterProperty("uStageHalfSize", stageHalfSize);
RegisterDepthProperties(depth, zNear, finalImageRenderer);
auto propInvProjection = finalImageRenderer.RegisterProperty("uInvProjection", Matrix::IDENTITY);
finalImage.AddRenderer(finalImageRenderer);
mFinalImage = finalImage;
- stage.Add(finalImage);
+ window.Add(finalImage);
// Create a node for our lights
auto lights = Actor::New();
animLights.Play();
// Event handling
- stage.KeyEventSignal().Connect(this, &DeferredShadingExample::OnKeyEvent);
+ window.KeyEventSignal().Connect(this, &DeferredShadingExample::OnKeyEvent);
mPanDetector = PanGestureDetector::New();
mPanDetector.DetectedSignal().Connect(this, &DeferredShadingExample::OnPan);
- mPanDetector.Attach(stage.GetRootLayer());
+ mPanDetector.Attach(window.GetRootLayer());
}
void Destroy(Application& app)
{
- Stage::GetCurrent().GetRenderTaskList().RemoveTask(mSceneRender);
+ app.GetWindow().GetRenderTaskList().RemoveTask(mSceneRender);
mSceneRender.Reset();
UnparentAndReset(mSceneRoot);
void OnKeyEvent(const KeyEvent& event)
{
- if(event.state == KeyEvent::Down)
+ if(event.GetState() == KeyEvent::DOWN)
{
if( IsKey( event, Dali::DALI_KEY_ESCAPE) || IsKey( event, Dali::DALI_KEY_BACK) )
{