--- /dev/null
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+#include "utils.h"
+#include "dali-toolkit/dali-toolkit.h"
+#include <fstream>
+
+using namespace Dali;
+using namespace Dali::Toolkit;
+
+Vector3 ToHueSaturationLightness(Vector3 rgb)
+{
+ float min = std::min(rgb.r, std::min(rgb.g, rgb.b));
+ float max = std::max(rgb.r, std::max(rgb.g, rgb.b));
+
+ Vector3 hsl(max - min, 0.f, (max + min) * .5f);
+ if (hsl.x * hsl.x > .0f)
+ {
+ hsl.y = hsl.x / max;
+ if (max == rgb.r)
+ {
+ hsl.x = (rgb.g - rgb.b) / hsl.x;
+ }
+ else if(max == rgb.g)
+ {
+ hsl.x = 2.f + (rgb.b - rgb.r) / hsl.x;
+ }
+ else
+ {
+ hsl.x = 4.f + (rgb.r - rgb.g) / hsl.x;
+ }
+ hsl.x *= 60.f;
+ if (hsl.x < 0.f)
+ {
+ hsl.x += 360.f;
+ }
+ }
+ else
+ {
+ hsl.y = 0.f;
+ }
+
+ return hsl;
+}
+
+Vector3 FromHueSaturationLightness(Vector3 hsl)
+{
+ Vector3 rgb;
+ if (hsl.y * hsl.y > 0.f)
+ {
+ if(hsl.x >= 360.f)
+ {
+ hsl.x -= 360.f;
+ }
+ hsl.x /= 60.f;
+
+ 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)));
+
+ 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;
+ }
+ }
+ else
+ {
+ rgb = Vector3::ONE * hsl.z;
+ }
+
+ return rgb;
+}
+
+Geometry CreateTesselatedQuad(unsigned int xVerts, unsigned int yVerts,
+ Vector2 scale, VertexFn positionFn, VertexFn texCoordFn)
+{
+ DALI_ASSERT_DEBUG(xVerts > 1 && yVerts > 1);
+ int numVerts = xVerts * yVerts;
+ struct Vertex
+ {
+ Vector2 aPosition;
+ Vector2 aTexCoord;
+ };
+ std::vector<Vertex> vertices;
+ vertices.reserve( numVerts);
+
+ float dx = 1.f / (xVerts - 1);
+ float dz = 1.f / (yVerts - 1);
+
+ Vector2 pos{ 0.f, 0.f };
+ for (unsigned int i = 0; i < yVerts; ++i)
+ {
+ pos.x = float(int((i & 1) * 2) - 1) * dx * .25f;
+ for (unsigned int j = 0; j < xVerts; ++j)
+ {
+ auto vPos = pos + Vector2{ -.5f, -.5f };
+ vertices.push_back(Vertex{ (positionFn ? positionFn(vPos) : vPos) * scale,
+ texCoordFn ? texCoordFn(pos) : pos });
+ pos.x += dx;
+ }
+
+ pos.y += dz;
+ }
+
+ VertexBuffer vertexBuffer = VertexBuffer::New( Property::Map()
+ .Add( "aPosition", Property::VECTOR2 )
+ .Add( "aTexCoord", Property::VECTOR2 ));
+ vertexBuffer.SetData(vertices.data(), vertices.size());
+
+ int numInds = (xVerts - 1) * (yVerts - 1) * 6;
+ std::vector<uint16_t> indices;
+ indices.reserve(numInds);
+
+ for (unsigned int i = 1; i < yVerts; ++i)
+ {
+ if ((i & 1) == 0)
+ {
+ for (unsigned int j = 1; j < xVerts; ++j)
+ {
+ int iBase = i * xVerts + j;
+ indices.push_back(iBase);
+ indices.push_back(iBase - 1);
+ indices.push_back(iBase - xVerts - 1);
+ indices.push_back(indices.back());
+ indices.push_back(iBase - xVerts);
+ indices.push_back(iBase);
+ }
+ }
+ else
+ {
+ for (unsigned int j = 1; j < xVerts; ++j)
+ {
+ int iBase = i * xVerts + j;
+ indices.push_back(iBase);
+ indices.push_back(iBase - 1);
+ indices.push_back(iBase - xVerts);
+ indices.push_back(indices.back());
+ indices.push_back(iBase - 1);
+ indices.push_back(iBase - xVerts - 1);
+ }
+ }
+ }
+
+ Geometry geom = Geometry::New();
+ geom.AddVertexBuffer(vertexBuffer);
+ geom.SetIndexBuffer(indices.data(), indices.size());
+ return geom;
+}
+
+Texture LoadTexture(const std::string& path)
+{
+ PixelData pixelData = SyncImageLoader::Load(path);
+
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, pixelData.GetPixelFormat(),
+ pixelData.GetWidth(), pixelData.GetHeight());
+ texture.Upload(pixelData);
+ return texture;
+}
+
+Renderer CreateRenderer(TextureSet textures, Geometry geometry, Shader shader, uint32_t options)
+{
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetProperty(Renderer::Property::BLEND_MODE,
+ (options & OPTION_BLEND) ? BlendMode::ON : BlendMode::OFF);
+ renderer.SetProperty(Renderer::Property::DEPTH_TEST_MODE,
+ (options & OPTION_DEPTH_TEST) ? DepthTestMode::ON : DepthTestMode::OFF);
+ renderer.SetProperty(Renderer::Property::DEPTH_WRITE_MODE,
+ (options & OPTION_DEPTH_WRITE) ? DepthWriteMode::ON : DepthWriteMode::OFF);
+ renderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK);
+
+ if (!textures)
+ {
+ textures = TextureSet::New();
+ }
+
+ renderer.SetTextures(textures);
+ return renderer;
+}
+
+void CenterActor(Actor actor)
+{
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+}
+
+Actor CreateActor()
+{
+ auto actor = Actor::New();
+ CenterActor(actor);
+ return actor;
+}
+
+Renderer CloneRenderer(Renderer original)
+{
+ Geometry geom = original.GetGeometry();
+ Shader shader = original.GetShader();
+ Renderer clone = Renderer::New(geom, shader);
+
+ // Copy properties.
+ Property::IndexContainer indices;
+ original.GetPropertyIndices(indices);
+
+ for (auto& i: indices)
+ {
+ auto actualIndex = Dali::PropertyRanges::DEFAULT_RENDERER_PROPERTY_START_INDEX + i;
+ clone.SetProperty(actualIndex, original.GetProperty(actualIndex));
+ }
+
+ // Copy texture references (and create TextureSet, if there's any textures).
+ TextureSet ts = original.GetTextures();
+ clone.SetTextures(ts);
+
+ return clone;
+}
+
+Actor CloneActor(Actor original)
+{
+ using namespace Dali;
+
+ auto clone = Actor::New();
+ clone.SetProperty(Actor::Property::NAME, original.GetProperty(Actor::Property::NAME));
+
+ // Copy properties.
+ // Don't copy every single one of them.
+ // Definitely don't copy resize policy related things, which will internally enable
+ // relayout, which in turn will result in losing the ability to set Z size.
+ for (auto i : {
+ Actor::Property::PARENT_ORIGIN,
+ Actor::Property::ANCHOR_POINT,
+ Actor::Property::SIZE,
+ Actor::Property::POSITION,
+ Actor::Property::ORIENTATION,
+ Actor::Property::SCALE,
+ Actor::Property::VISIBLE,
+ Actor::Property::COLOR,
+ Actor::Property::NAME,
+ })
+ {
+ clone.SetProperty(i, original.GetProperty(i));
+ }
+
+ // Clone renderers.
+ for(unsigned int i = 0; i < original.GetRendererCount(); ++i)
+ {
+ auto rClone = CloneRenderer(original.GetRendererAt(i));
+ clone.AddRenderer(rClone);
+ }
+
+ // Recurse into children.
+ for(unsigned int i = 0; i < original.GetChildCount(); ++i)
+ {
+ Actor newChild = CloneActor(original.GetChildAt(i));
+ clone.Add(newChild);
+ }
+
+ return clone;
+}
--- /dev/null
+#ifndef WAVES_UTILS_H_
+#define WAVES_UTILS_H_
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+#include "dali/public-api/actors/actor.h"
+#include "dali/public-api/rendering/geometry.h"
+#include "dali/public-api/rendering/renderer.h"
+#include "dali/public-api/rendering/shader.h"
+#include "dali/public-api/rendering/texture.h"
+#include "dali/public-api/math/vector3.h"
+#include <cmath>
+
+//
+// Maths
+//
+inline
+float FastFloor(float x)
+{
+ return static_cast<int>(x) - static_cast<int>(x < 0);
+}
+
+inline
+float Sign(float x)
+{
+ return float(x > 0.f) - float(x < .0f);
+}
+
+template <typename T>
+inline
+typename std::decay<T>::type Lerp(
+ const T& min, const T& max, float alpha)
+{
+ return min + (max - min) * alpha;
+}
+
+template <typename T>
+T Normalized(T v)
+{
+ v.Normalize();
+ return v;
+}
+
+//
+// Files
+//
+///@brief Converts RGB values (in the 0..1 range) to HSL, where hue is in degrees,
+/// in the 0..360 range, and saturation and lightness are in the 0..1 range.
+Dali::Vector3 ToHueSaturationLightness(Dali::Vector3 rgb);
+
+///@brief Converts HSL values, where hue is in degrees, in the 0..360 range, and
+/// saturation and lightness are in 0..1 to RGB (in the 0..1 range)
+Dali::Vector3 FromHueSaturationLightness(Dali::Vector3 hsl);
+
+//
+// Dali entities
+//
+using VertexFn = Dali::Vector2(*)(const Dali::Vector2&);
+
+///@brief Creates a tesselated quad with @a xVerts vertices horizontally and @a yVerts
+/// vertices vertically. Allows the use of an optional @a shaderFn, which can be used to
+/// modify the vertex positions - these will be in the [{ 0.f, 0.f}, { 1.f, 1.f}] range.
+/// After returning from the shader, they're transformed
+Dali::Geometry CreateTesselatedQuad(unsigned int xVerts, unsigned int yVerts,
+ Dali::Vector2 scale, VertexFn positionFn = nullptr, VertexFn texCoordFn = nullptr);
+
+Dali::Texture LoadTexture(const std::string& path);
+
+enum RendererOptions
+{
+ OPTION_NONE = 0x0,
+ OPTION_BLEND = 0x01,
+ OPTION_DEPTH_TEST = 0x02,
+ OPTION_DEPTH_WRITE = 0x04
+};
+
+///@brief Creates a renderer with the given @a textures set, @a geometry, @a shader
+/// and @a options from above.
+///@note Back face culling is on.
+///@note If textures is not a valid handle, an empty texture set will be created.
+Dali::Renderer CreateRenderer(Dali::TextureSet textures, Dali::Geometry geometry,
+ Dali::Shader shader, uint32_t options = OPTION_NONE);
+
+///@brief Sets @a actor's anchor point and parent origin to center.
+void CenterActor(Dali::Actor actor);
+
+///@brief Creates an empty and centered actor.
+Dali::Actor CreateActor();
+
+///@brief Creates a copy of @a original, sharing the same geometry and shader and
+/// copying each properties.
+///@note Breaks if @a original has any custom properties. TODO: fix.
+Dali::Renderer CloneRenderer(Dali::Renderer original);
+
+///@brief Creates a copy of @a original, cloning each renderer, and a select set
+/// of properties: parent origin, anchor point, size, position, orientation, scale,
+/// visible, color and name.
+///@note Does not copy resize policy related properties, as setting those, even if
+/// default, will break the ability to specify a size for the actor in Z.
+Dali::Actor CloneActor(Dali::Actor original);
+
+#endif /* EXAMPLES_PARTICLES_UTILS_H_ */
--- /dev/null
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 ( "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// INTERNAL INCLUDES
+#include "utils.h"
+#include "dali/devel-api/adaptor-framework/tilt-sensor.h"
+#include "dali/public-api/adaptor-framework/application.h"
+#include "dali/public-api/adaptor-framework/key.h"
+#include "dali/public-api/animation/animation.h"
+#include "dali/public-api/events/pan-gesture-detector.h"
+#include "dali/public-api/events/tap-gesture-detector.h"
+#include "dali/public-api/events/key-event.h"
+#include "dali/public-api/actors/camera-actor.h"
+#include "dali/public-api/actors/layer.h"
+#include "dali/public-api/render-tasks/render-task.h"
+#include "dali/public-api/render-tasks/render-task-list.h"
+#include <fstream>
+#include <iostream>
+#include <numeric>
+
+using namespace Dali;
+
+namespace
+{
+
+constexpr std::string_view WAVES_VSH =
+ "#define FMA(a, b, c) ((a) * (b) + (c))\n" // fused multiply-add
+DALI_COMPOSE_SHADER(
+ precision highp float;
+
+ const float kTile = 1.;
+
+ const float kPi = 3.1415926535;
+ const float kEpsilon = 1. / 32.;
+
+ // DALI uniforms
+ uniform vec3 uSize;
+ uniform mat4 uModelView;
+ uniform mat4 uProjection;
+ uniform mat3 uNormalMatrix;
+
+ // our uniforms
+ uniform float uTime;
+ uniform vec2 uScrollScale;
+ uniform float uWaveRate;
+ uniform float uWaveAmplitude;
+ uniform float uParallaxAmount;
+
+ attribute vec2 aPosition;
+ attribute vec2 aTexCoord;
+
+ varying vec2 vUv;
+ varying vec3 vViewPos;
+ varying vec3 vNormal;
+ varying float vHeight;
+
+ float CubicHermite(float B, float C, float t)
+ {
+ float dCB = (C - B) * .5;
+ float A = B - dCB;
+ float D = B + dCB;
+ vec3 p = vec3(D + .5 * (((B - C) * 3.) - A), A - 2.5 * B + 2. * C - D,
+ .5 * (C - A));
+ return FMA(FMA(FMA(p.x, t, p.y), t, p.z), t, B);
+ }
+
+ float Hash(float n)
+ {
+ return fract(sin(n) * 43751.5453123);
+ }
+
+ float HeightAtTile(vec2 pos)
+ {
+ float rate = Hash(Hash(pos.x) * Hash(pos.y));
+
+ return (sin(uTime * rate * uWaveRate) * .5 + .5) * uWaveAmplitude;
+ }
+
+ float CalculateHeight(vec2 position)
+ {
+ vec2 tile = floor(position);
+ position = fract(position);
+
+ vec2 cp = vec2(
+ CubicHermite(
+ HeightAtTile(tile + vec2( kTile * -0.5, kTile * -0.5)),
+ HeightAtTile(tile + vec2( kTile * +0.5, kTile * -0.5)),
+ position.x),
+ CubicHermite(
+ HeightAtTile(tile + vec2( kTile * -0.5, kTile * +0.5)),
+ HeightAtTile(tile + vec2( kTile * +0.5, kTile * +0.5)),
+ position.x)
+ );
+
+ return CubicHermite(cp.x, cp.y, position.y);
+ }
+
+ vec3 CalculateNormal(vec2 position)
+ {
+ vec3 normal = vec3(
+ CalculateHeight(vec2(position.x - kEpsilon, position.y)) -
+ CalculateHeight(vec2(position.x + kEpsilon, position.y)),
+ .25,
+ CalculateHeight(vec2(position.x, position.y - kEpsilon)) -
+ CalculateHeight(vec2(position.x, position.y + kEpsilon))
+ );
+ return normal;
+ }
+
+ void main()
+ {
+ vUv = aTexCoord;
+
+ vec2 scrollPosition = aPosition * uScrollScale + vec2(0., uTime * -kPi);
+ vNormal = uNormalMatrix * CalculateNormal(scrollPosition);
+
+ float h = CalculateHeight(scrollPosition);
+ vHeight = h * uParallaxAmount;
+ vec3 position = vec3(aPosition.x, h, aPosition.y);
+
+ vec4 viewPosition = uModelView * vec4(position * uSize, 1.);
+ vViewPos = -viewPosition.xyz;
+
+ gl_Position = uProjection * viewPosition;
+ });
+
+constexpr std::string_view WAVES_FSH = DALI_COMPOSE_SHADER(
+ precision highp float;
+
+ uniform vec4 uColor; // DALi
+ uniform sampler2D uNormalMap; // DALi
+
+ uniform vec3 uInvLightDir;
+ uniform vec3 uLightColorSqr;
+ uniform vec3 uAmbientColor;
+
+ uniform float uNormalMapWeight;
+ uniform float uSpecularity;
+
+ varying vec2 vUv;
+ varying vec3 vNormal;
+ varying vec3 vViewPos;
+ varying float vHeight;
+
+ float Rand(vec2 co)
+ {
+ return fract(sin(dot(co.xy, vec2(12.98981, 78.2331))) * 43758.5453);
+ }
+
+ float Sum(vec3 v)
+ {
+ return v.x + v.y + v.z;
+ }
+
+ void main()
+ {
+ vec3 viewPos = normalize(vViewPos);
+ vec2 uv2 = vUv + vViewPos.xy / vViewPos.z * vHeight + vec2(.5, 0.);
+
+ vec3 perturbNormal = texture2D(uNormalMap, vUv).rgb * 2. - 1.;
+ vec3 perturbNormal2 = texture2D(uNormalMap, uv2).rgb * 2. - 1.;
+ vec3 normal = normalize(vNormal + perturbNormal * uNormalMapWeight);
+ vec3 normal2 = normalize(vNormal + perturbNormal2 * uNormalMapWeight);
+
+ vec3 color = uAmbientColor;
+ float d = max(0., dot(normal, -uInvLightDir));
+ color += uColor.rgb * d;
+
+ vec3 reflected = reflect(uInvLightDir, normal);
+ d = max(0., dot(reflected, viewPos));
+ color += pow(d, uSpecularity) * uLightColorSqr;
+
+ reflected = reflect(uInvLightDir, normal2);
+ d = max(0., dot(reflected, viewPos));
+ color += pow(d, uSpecularity) * uLightColorSqr;
+
+ gl_FragColor = vec4(color, 1.);
+ });
+
+const float TIME_STEP = 0.0952664626;
+
+const std::string UNIFORM_LIGHT_COLOR_SQR = "uLightColorSqr";
+const std::string UNIFORM_AMBIENT_COLOR = "uAmbientColor";
+const std::string UNIFORM_INV_LIGHT_DIR = "uInvLightDir";
+const std::string UNIFORM_SCROLL_SCALE = "uScrollScale";
+const std::string UNIFORM_WAVE_RATE = "uWaveRate";
+const std::string UNIFORM_WAVE_AMPLITUDE = "uWaveAmplitude";
+const std::string UNIFORM_NORMAL_MAP_WEIGHT = "uNormalMapWeight";
+const std::string UNIFORM_SPECULARITY = "uSpecularity";
+const std::string UNIFORM_PARALLAX_AMOUNT = "uParallaxAmount";
+const std::string UNIFORM_TIME = "uTime";
+
+const Vector3 WAVES_COLOR { .78f, .64f, .26f };
+const Vector3 LIGHT_COLOR { 1.0f, 0.91f, 0.6f };
+const Vector3 AMBIENT_COLOR { .002f, .001f, .001f };
+
+const Vector3 INV_LIGHT_DIR = Normalized(Vector3{ .125f, .8f, -.55f });
+
+const Vector2 SCROLL_SCALE{ 1.f, 3.5f };
+const float WAVE_RATE = 12.17f;
+const float WAVE_AMPLITUDE = 1.f;
+const float NORMAL_MAP_WEIGHT = 0.05f;
+const float SPECULARITY = 512.f;
+const float PARALLAX_AMOUNT = .25f;
+
+const float TILT_RANGE_DEGREES = 30.f;
+
+const float TRANSITION_DURATION = 1.2f;
+const float TRANSITION_TIME_SCALE = 6.f;
+
+const std::string_view NORMAL_MAP_NAME = "noise512.png";
+
+Vector3 RandomColor()
+{
+ float r = .5f + (rand() % RAND_MAX) / float(RAND_MAX) * .5f;
+ float g = .5f + (rand() % RAND_MAX) / float(RAND_MAX) * .5f;
+ float b = .5f + (rand() % RAND_MAX) / float(RAND_MAX) * .5f;
+ return Vector3(r, g, b);
+}
+
+class TiltFilter
+{
+public:
+ void Reset()
+ {
+ std::fill(mTiltSamples, mTiltSamples + FILTER_SIZE, Vector2(.0f, .0f));
+ }
+
+ void Add(Dali::Vector2 tilt)
+ {
+ mTiltSamples[mIdxNextSample] = tilt;
+ mIdxNextSample = (mIdxNextSample + 1) % FILTER_SIZE;
+ }
+
+ Dali::Vector2 Filter() const
+ {
+ return std::accumulate(mTiltSamples, mTiltSamples + FILTER_SIZE, Vector2(.0f, .0f)) / FILTER_SIZE;
+ }
+
+private:
+ enum { FILTER_SIZE = 8u };
+
+ Dali::Vector2 mTiltSamples[FILTER_SIZE];
+ size_t mIdxNextSample = 0;
+};
+
+} // nonamespace
+
+class WavesExample : public ConnectionTracker
+{
+public:
+ WavesExample( Application& app )
+ : mApp( app )
+ {
+ mApp.InitSignal().Connect( this, &WavesExample::Create );
+ mApp.TerminateSignal().Connect( this, &WavesExample::Destroy );
+ }
+
+ ~WavesExample() = default;
+
+private:
+ Application& mApp;
+
+ CameraActor mCamera; // no ownership
+
+ Actor mWaves;
+ Shader mWaveShader;
+
+ Property::Index mUInvLightDir;
+ Property::Index mULightColorSqr;
+ Property::Index mUAmbientColor;
+ Property::Index mUWaveRate;
+ Property::Index mUWaveAmplitude;
+ Property::Index mUScrollScale;
+ Property::Index mUNormalMapWeight;
+ Property::Index mUSpecularity;
+ Property::Index mUParallaxAmount;
+ Property::Index mUTime;
+
+ TapGestureDetector mDoubleTapGesture;
+
+ TiltSensor mTiltSensor;
+ TiltFilter mTiltFilter;
+
+ PanGestureDetector mPanGesture;
+
+ Animation mTimeAnim;
+ Animation mTransitionAnim;
+
+ void Create( Application& application )
+ {
+ Window window = application.GetWindow();
+ auto rootLayer = window.GetRootLayer();
+
+ window.SetBackgroundColor(Vector4(WAVES_COLOR * .5f));
+
+ // Get camera
+ RenderTaskList tasks = window.GetRenderTaskList();
+ RenderTask mainPass = tasks.GetTask(0);
+ CameraActor camera = mainPass.GetCameraActor();
+ mCamera = camera;
+
+ // NOTE: watchface doesn't tolerate modification of the camera well;
+ /// we're better off rotating the world.
+ Quaternion baseOrientation (Radian(Degree(-150.f)), Radian(M_PI), Radian(0.f));
+
+ auto shader = CreateShader();
+
+ // Create geometry
+ Geometry geom = CreateTesselatedQuad(16, 64, Vector2{ .25f, 3.8f }, [](const Vector2& v) {
+ float y = v.y + .5f; // 0..1
+ y = std::sqrt(y) - .5f; // perspective correction - increase vertex density closer to viewer
+
+ float x = v.x + v.x * (1.f - y) * 5.5f;
+
+ y -= .24f; // further translation
+ return Vector2{ x, y };
+ }, [](const Vector2& v) {
+ return Vector2{ v.x, std::sqrt(v.y) };
+ });
+
+ // Create texture
+ auto normalMap = LoadTexture(std::string(DEMO_IMAGE_DIR) + NORMAL_MAP_NAME.data());
+
+ TextureSet textures = TextureSet::New();
+ textures.SetTexture(0, normalMap);
+
+ Sampler sampler = Sampler::New();
+ sampler.SetFilterMode(FilterMode::NEAREST, FilterMode::NEAREST);
+ sampler.SetWrapMode(WrapMode::REPEAT, WrapMode::REPEAT);
+ textures.SetSampler(0, sampler);
+
+ // Create renderer
+ Renderer renderer = CreateRenderer(textures, geom, shader, OPTION_DEPTH_TEST | OPTION_DEPTH_WRITE);
+
+ auto waves = CreateActor();
+ auto size = Vector2(window.GetSize());
+ waves.SetProperty(Actor::Property::SIZE, Vector3(size.x, 100.f, size.y));
+ waves.SetProperty(Actor::Property::ORIENTATION, baseOrientation);
+ waves.SetProperty(Actor::Property::COLOR, WAVES_COLOR);
+ waves.AddRenderer(renderer);
+
+ window.Add(waves);
+ mWaves = waves;
+
+ window.KeyEventSignal().Connect( this, &WavesExample::OnKeyEvent );
+
+ // Setup double tap detector for color change
+ mDoubleTapGesture = TapGestureDetector::New(2);
+ mDoubleTapGesture.Attach(rootLayer);
+ mDoubleTapGesture.DetectedSignal().Connect(this, &WavesExample::OnDoubleTap);
+
+ // Touch controls
+ mTiltSensor = TiltSensor::Get();
+ if ( mTiltSensor.Start() )
+ {
+ // Get notifications when the device is tilted
+ mTiltSensor.TiltedSignal().Connect( this, &WavesExample::OnTilted );
+ }
+ else
+ {
+ mPanGesture = PanGestureDetector::New();
+ mPanGesture.Attach(rootLayer);
+ mPanGesture.DetectedSignal().Connect(this, &WavesExample::OnPan);
+ }
+
+ // Register for suspend / resume
+ application.PauseSignal().Connect(this, &WavesExample::OnPause);
+ application.ResumeSignal().Connect(this, &WavesExample::OnResume);
+
+ // Create animation for the simulation of time
+ Animation animTime = Animation::New(1.f);
+ animTime.AnimateBy(Property(mWaveShader, mUTime), TIME_STEP);
+ animTime.FinishedSignal().Connect(this, &WavesExample::OnTimeAnimFinished);
+ animTime.Play();
+ mTimeAnim = animTime;
+ }
+
+ void Destroy( Application& app)
+ {
+ mCamera.Reset();
+
+ mDoubleTapGesture.Reset();
+ mPanGesture.Reset();
+
+ UnparentAndReset(mWaves);
+ }
+
+ Shader CreateShader()
+ {
+ Vector3 lightColorSqr{ LIGHT_COLOR };
+ Vector3 ambientColor = AMBIENT_COLOR;
+ Vector3 invLightDir = INV_LIGHT_DIR;
+ Vector2 scrollScale = SCROLL_SCALE;
+ float waveRate = WAVE_RATE;
+ float waveAmp = WAVE_AMPLITUDE;
+ float normalMapWeight = NORMAL_MAP_WEIGHT;
+ float specularity = SPECULARITY;
+ float parallaxAmount = PARALLAX_AMOUNT;
+ if (mWaveShader)
+ {
+ lightColorSqr = mWaveShader.GetProperty(mULightColorSqr).Get<Vector3>();
+ ambientColor = mWaveShader.GetProperty(mUAmbientColor).Get<Vector3>();
+ invLightDir = mWaveShader.GetProperty(mUInvLightDir).Get<Vector3>();
+ scrollScale = mWaveShader.GetProperty(mUScrollScale).Get<Vector2>();
+ waveRate = mWaveShader.GetProperty(mUWaveRate).Get<float>();
+ waveAmp = mWaveShader.GetProperty(mUWaveAmplitude).Get<float>();
+ normalMapWeight = mWaveShader.GetProperty(mUNormalMapWeight).Get<float>();
+ specularity = mWaveShader.GetProperty(mUSpecularity).Get<float>();
+ }
+
+ Shader shader = Shader::New(WAVES_VSH.data(), WAVES_FSH.data(), Shader::Hint::MODIFIES_GEOMETRY);
+ mULightColorSqr = shader.RegisterProperty(UNIFORM_LIGHT_COLOR_SQR, lightColorSqr);
+ mUAmbientColor = shader.RegisterProperty(UNIFORM_AMBIENT_COLOR, ambientColor);
+ mUInvLightDir = shader.RegisterProperty(UNIFORM_INV_LIGHT_DIR, invLightDir);
+ mUScrollScale = shader.RegisterProperty(UNIFORM_SCROLL_SCALE, scrollScale);
+ mUWaveRate = shader.RegisterProperty(UNIFORM_WAVE_RATE, waveRate);
+ mUWaveAmplitude = shader.RegisterProperty(UNIFORM_WAVE_AMPLITUDE, waveAmp);
+ mUNormalMapWeight = shader.RegisterProperty(UNIFORM_NORMAL_MAP_WEIGHT, normalMapWeight);
+ mUSpecularity = shader.RegisterProperty(UNIFORM_SPECULARITY, specularity);
+ mUParallaxAmount = shader.RegisterProperty(UNIFORM_PARALLAX_AMOUNT, parallaxAmount);
+ mUTime = shader.RegisterProperty(UNIFORM_TIME, 0.f);
+
+ auto window = mApp.GetWindow();
+ shader.RegisterProperty("uScreenHalfSize", Vector2(window.GetSize()) * .5f);
+ mWaveShader = shader;
+
+ return shader;
+ }
+
+ void TriggerColorTransition(Vector3 wavesColor, Vector3 lightColor)
+ {
+ if (mTransitionAnim)
+ {
+ mTransitionAnim.Stop();
+ }
+
+ mTimeAnim.FinishedSignal().Disconnect(this, &WavesExample::OnTimeAnimFinished);
+ mTimeAnim.Stop();
+
+ Animation anim = Animation::New(TRANSITION_DURATION);
+ anim.AnimateTo(Property(mWaves, Actor::Property::COLOR), Vector4(wavesColor), AlphaFunction::EASE_IN_OUT);
+ anim.AnimateTo(Property(mWaveShader, mULightColorSqr), lightColor * lightColor, AlphaFunction::EASE_IN_OUT);
+ anim.AnimateBy(Property(mWaveShader, mUTime), TRANSITION_DURATION * TIME_STEP * TRANSITION_TIME_SCALE, AlphaFunction::EASE_IN_OUT);
+ anim.FinishedSignal().Connect(this, &WavesExample::OnTransitionFinished);
+ anim.Play();
+ mTransitionAnim = anim;
+ }
+
+ void OnTimeAnimFinished(Animation& anim)
+ {
+ anim.Play();
+ }
+
+ void OnTransitionFinished(Animation& anim)
+ {
+ mTransitionAnim.Reset();
+ mTimeAnim.FinishedSignal().Connect(this, &WavesExample::OnTimeAnimFinished);
+ mTimeAnim.Play();
+ }
+
+ void OnPause(Application& app)
+ {
+ mTimeAnim.Pause();
+ mTiltSensor.Stop();
+ }
+
+ void OnResume(Application& app)
+ {
+ mTiltSensor.Start();
+ mTimeAnim.Play();
+ }
+
+ void OnKeyEvent(const KeyEvent& event)
+ {
+ if ( event.GetState() == KeyEvent::UP) // single keystrokes
+ {
+ if( IsKey( event, DALI_KEY_ESCAPE ) || IsKey( event, DALI_KEY_BACK ) )
+ {
+ mApp.Quit();
+ }
+ }
+ }
+
+ void OnDoubleTap(Actor /*actor*/, const TapGesture& gesture)
+ {
+ Vector3 lightColor = mWaveShader.GetProperty(mULightColorSqr).Get<Vector3>();
+ TriggerColorTransition(lightColor, RandomColor());
+ }
+
+ void OnPan(Actor actor, const PanGesture& gesture)
+ {
+ auto tilt = gesture.GetDisplacement() / Vector2(mApp.GetWindow().GetSize());
+ switch (gesture.GetState())
+ {
+ case GestureState::STARTED:
+ mTiltFilter.Add(tilt);
+ break;
+
+ case GestureState::CONTINUING:
+ mTiltFilter.Add(mTiltFilter.Filter() + tilt);
+ break;
+
+ default:
+ break;
+ }
+
+ UpdateLightDirection();
+ }
+
+ void OnTilted( const TiltSensor& sensor)
+ {
+ mTiltFilter.Add(Vector2(sensor.GetPitch(), sensor.GetRoll()));
+
+ UpdateLightDirection();
+ }
+
+ void UpdateLightDirection()
+ {
+ Vector2 tilt = mTiltFilter.Filter();
+ Quaternion q(Radian(tilt.y), Radian(-tilt.x), Radian(0.f));
+ Vector3 lightDir = q.Rotate(INV_LIGHT_DIR);
+ mWaveShader.SetProperty(mUInvLightDir, lightDir);
+ }
+};
+
+int DALI_EXPORT_API main( int argc, char **argv )
+{
+ Application application = Application::New( &argc, &argv, DEMO_THEME_PATH );
+ WavesExample example( application);
+ application.MainLoop();
+ return 0;
+}
projects / platform / core / uifw / dali-demo.git / commitdiff
