ENDIF()
FOREACH(EXAMPLE ${SUBDIRS})
+ # Generate source files for shaders
+ SET(SHADER_SOURCE_DIR "${EXAMPLES_SRC_DIR}/${EXAMPLE}/shaders/")
+ SET(SHADER_GENERATED_DIR "${EXAMPLES_SRC_DIR}/${EXAMPLE}/generated/")
+ SET(PARENT_CMAKE_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../")
+ IF (EXISTS ${SHADER_SOURCE_DIR})
+ EXECUTE_PROCESS( COMMAND bash -c "${PARENT_CMAKE_SOURCE_DIR}/shader-generator.sh ${SHADER_SOURCE_DIR} ${SHADER_GENERATED_DIR} --skip")
+ SET_PROPERTY( DIRECTORY APPEND PROPERTY ADDITIONAL_MAKE_CLEAN_FILES
+ "${SHADER_GENERATED_DIR}" )
+ ENDIF()
FILE(GLOB SRCS "${EXAMPLES_SRC_DIR}/${EXAMPLE}/*.cpp")
SET(SRCS ${SRCS} "${ROOT_SRC_DIR}/shared/resources-location.cpp")
IF(SHARED)
--- /dev/null
+#!/bin/bash
+
+# Set Colors
+Red='\033[0;31m' # Red
+Yellow='\033[0;33m' # Yellow
+Blue='\033[0;34m' # Blue
+Clear='\033[0m' # Text Reset
+
+#########################################################################################
+
+Usage()
+{
+ echo -e "${Yellow}Usage: $(basename ${BASH_SOURCE[0]}) [indir] [outdir] [OPTIONS]"
+ echo
+ echo -e " ${Blue}Mandatory parameters:${Clear}"
+ echo -e " indir The input directory where the original shader files are located"
+ echo -e " outdir The output directory where the header files for the shaders should be generated"
+ echo -e " ${Red}NOTE: All the above parameters must be provided${Clear}"
+ echo
+ echo -e " ${Blue}Options:${Clear}"
+ echo -e " -s|--skip Skip the generation of header and cpp files that include all the generated shader header files"
+ echo -e " -h|--help Help"
+}
+
+if [ "$1" = "-h" ] || [ "$1" = "--help" ]
+then
+ Usage
+ exit 0
+elif [ "$#" -lt 2 ]
+then
+ echo -e "${Red}ERROR:${Clear} Mandatory parameters are not provided"
+ echo
+ Usage
+ exit 1
+fi
+
+#########################################################################################
+
+indir=$1
+outdir=$2
+skip=""
+
+for option in $*
+do
+ if [ "$option" = "-s" ] || [ "$option" = "--skip" ]
+ then
+ skip="--skip"
+ continue
+ elif [[ $option == -* ]]
+ then
+ echo -e "${Red}Invalid Option: ${Blue}$option${Clear}"
+ echo
+ Usage
+ exit 1
+ fi
+done
+
+#########################################################################################
+
+mkdir -p $outdir
+
+if [ ! -e $indir ] ; then
+ echo "Error: The folder \""$indir"\" does not exist!"
+ exit 1
+fi
+
+cd $indir
+all_shaders=$(ls -1 *.{vert,frag,def} 2>/dev/null)
+cd $OLDPWD
+
+# Generate one header file per shader which is defined as a const std::string_view
+for name in $all_shaders ; do
+ echo "Generating header files for $name..."
+ varname=$(echo "SHADER_$name" | tr [a-z] [A-Z] | sed -e 's/-/_/g;s/\./_/g;')
+
+ newname=$(echo ${name} | sed -e 's/\./-/;')".h"
+ echo Writing $newname
+
+ shader_fullpath=$(echo ${indir})$name
+
+ header_name="${varname}_GEN_H"
+ echo "const std::string_view" "$varname""{" > $outdir/$newname
+ cat $shader_fullpath | sed -e 's/^..*$/"&\\n"/' >> $outdir/$newname
+ echo "};" >> $outdir/$newname
+done
+
+if [ "$skip" != "--skip" ]; then
+ # Generate one cpp file that includes all the previously generated string_views for shaders
+ echo "Generating cpp file..."
+ echo -e "#include \"../builtin-shader-extern-gen.h\"\n" > $outdir/builtin-shader-gen.cpp
+
+ varnames=
+ for name in $all_shaders ; do
+ varname=$(echo "SHADER_$name" | tr [a-z] [A-Z] | sed -e 's/-/_/g;s/\./_/g;')
+ newname=$(echo ${name} | sed -e 's/\./-/;')".h"
+ varnames="${varnames} $varname"
+ echo "#include \"$newname\"" >> $outdir/builtin-shader-gen.cpp
+ done
+
+ # Generate one header file that defines all the shader string_views as extern variables
+ echo "Generating extern header file ( for external use )..."
+ echo "#ifndef GRAPHICS_BUILTIN_SHADER_EXTERN_GEN_H" > $outdir/../builtin-shader-extern-gen.h
+ echo -e "#define GRAPHICS_BUILTIN_SHADER_EXTERN_GEN_H\n" >> $outdir/../builtin-shader-extern-gen.h
+
+ echo "#include <string_view>" >> $outdir/../builtin-shader-extern-gen.h
+ echo "" >> $outdir/../builtin-shader-extern-gen.h
+
+ for name in $all_shaders ; do
+ varname=$(echo "SHADER_$name" | tr [a-z] [A-Z] | sed -e 's/-/_/g;s/\./_/g;')
+ newname=$(echo ${name} | sed -e 's/\./-/;')".h"
+ echo "extern const std::string_view $varname;" >> $outdir/../builtin-shader-extern-gen.h
+ done
+ cat >> $outdir/../builtin-shader-extern-gen.h << EOF
+
+#endif // GRAPHICS_BUILTIN_SHADER_EXTERN_GEN_H
+EOF
+fi
+
#include <dali-toolkit/dali-toolkit.h>
#include <dali/dali.h>
#include "shared/view.h"
+#include "generated/animated-shapes-vert.h"
+#include "generated/animated-shapes-frag.h"
#include <sstream>
{
const char* APPLICATION_TITLE("Animated Shapes");
-// clang-format off
-const char* VERTEX_SHADER = DALI_COMPOSE_SHADER
-(
- attribute mediump vec3 aCoefficient;
- uniform mediump mat4 uMvpMatrix;
- uniform mediump vec3 uPosition[MAX_POINT_COUNT];
- varying lowp vec2 vCoefficient;
- void main()
- {
- int vertexId = int(aCoefficient.z);
- gl_Position = uMvpMatrix * vec4(uPosition[vertexId], 1.0);
-
- vCoefficient = aCoefficient.xy;
- }
-);
-
-// Fragment shader.
-const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER
-(
- uniform lowp vec4 uColor;
- varying lowp vec2 vCoefficient;
- void main()
- {
- lowp float C = (vCoefficient.x*vCoefficient.x-vCoefficient.y);
- lowp float Cdx = dFdx(C);
- lowp float Cdy = dFdy(C);
-
- lowp float distance = float(C / sqrt(Cdx*Cdx + Cdy*Cdy));
- lowp float alpha = 0.5 - distance;
- gl_FragColor = vec4( uColor.rgb, uColor.a * alpha );
- }
-);
-// clang-format on
-
Shader CreateShader(unsigned int pointCount)
{
std::ostringstream vertexShader;
vertexShader << "#define MAX_POINT_COUNT " << pointCount << "\n"
- << VERTEX_SHADER;
+ << SHADER_ANIMATED_SHAPES_VERT;
std::ostringstream fragmentShader;
fragmentShader << "#extension GL_OES_standard_derivatives : enable "
<< "\n"
- << FRAGMENT_SHADER;
+ << SHADER_ANIMATED_SHAPES_FRAG;
Shader shader = Shader::New(vertexShader.str(), fragmentShader.str());
for(unsigned int i(0); i < pointCount; ++i)
--- /dev/null
+uniform lowp vec4 uColor;
+varying lowp vec2 vCoefficient;
+
+void main()
+{
+ lowp float C = (vCoefficient.x*vCoefficient.x-vCoefficient.y);
+ lowp float Cdx = dFdx(C);
+ lowp float Cdy = dFdy(C);
+
+ lowp float distance = float(C / sqrt(Cdx*Cdx + Cdy*Cdy));
+ lowp float alpha = 0.5 - distance;
+ gl_FragColor = vec4( uColor.rgb, uColor.a * alpha );
+}
--- /dev/null
+attribute mediump vec3 aCoefficient;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uPosition[MAX_POINT_COUNT];
+varying lowp vec2 vCoefficient;
+
+void main()
+{
+ int vertexId = int(aCoefficient.z);
+ gl_Position = uMvpMatrix * vec4(uPosition[vertexId], 1.0);
+
+ vCoefficient = aCoefficient.xy;
+}
// INTERNAL INCLUDES
#include "shared/utility.h"
+#include "generated/benchmark-vert.h"
+#include "generated/benchmark-frag.h"
using namespace Dali;
using namespace Dali::Toolkit;
Vector2 texCoord;
};
-// clang-format off
-const char* VERTEX_SHADER_TEXTURE = DALI_COMPOSE_SHADER(
- attribute mediump vec2 aPosition;\n
- attribute mediump vec2 aTexCoord;\n
- uniform mediump mat4 uMvpMatrix;\n
- uniform mediump vec3 uSize;\n
- varying mediump vec2 vTexCoord;\n
- void main()\n
- {\n
- vec4 position = vec4(aPosition,0.0,1.0)*vec4(uSize,1.0);\n
- gl_Position = uMvpMatrix * position;\n
- vTexCoord = aTexCoord;\n
- }\n
-);
-
-const char* FRAGMENT_SHADER_TEXTURE = DALI_COMPOSE_SHADER(
- uniform lowp vec4 uColor;\n
- uniform sampler2D sTexture;\n
- varying mediump vec2 vTexCoord;\n
-
- void main()\n
- {\n
- gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
- }\n
-);
-// clang-format on
-
bool gUseMesh(false);
bool gNinePatch(false);
unsigned int gRowsPerPage(25);
//Create all the renderers
std::vector<Renderer> renderers(numImages);
- Shader shader = Shader::New(VERTEX_SHADER_TEXTURE, FRAGMENT_SHADER_TEXTURE);
+ Shader shader = Shader::New(SHADER_BENCHMARK_VERT, SHADER_BENCHMARK_FRAG);
Geometry geometry = DemoHelper::CreateTexturedQuad();
for(unsigned int i(0); i < numImages; ++i)
{
--- /dev/null
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
+}
--- /dev/null
+attribute mediump vec2 aPosition;
+attribute mediump vec2 aTexCoord;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ vec4 position = vec4(aPosition,0.0,1.0)*vec4(uSize,1.0);
+ gl_Position = uMvpMatrix * position;
+ vTexCoord = aTexCoord;
+}
#include <dali-toolkit/devel-api/controls/table-view/table-view.h>
#include <dali/dali.h>
#include "shared/view.h"
+#include "generated/bezier-curve-vert.h"
+#include "generated/bezier-curve-frag.h"
#include <sstream>
const int AXIS_LABEL_POINT_SIZE(7);
const float AXIS_LINE_SIZE(1.0f);
-// clang-format off
-const char* CURVE_VERTEX_SHADER = DALI_COMPOSE_SHADER
- (
- attribute mediump vec2 aPosition;
- uniform mediump mat4 uMvpMatrix;
- uniform vec3 uSize;
- void main()
- {
- gl_Position = uMvpMatrix * vec4(aPosition*uSize.xy, 0.0, 1.0);
- }
- );
-
-const char* CURVE_FRAGMENT_SHADER = DALI_COMPOSE_SHADER
- (
- uniform lowp vec4 uColor;
- void main()
- {
- gl_FragColor = vec4(0.0,0.0,0.0,1.0);
- }
- );
-// clang-format on
-
inline float Clamp(float v, float min, float max)
{
if(v < min) return min;
mCurve.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
mCurve.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- Shader shader = Shader::New(CURVE_VERTEX_SHADER, CURVE_FRAGMENT_SHADER);
+ Shader shader = Shader::New(SHADER_BEZIER_CURVE_VERT, SHADER_BEZIER_CURVE_FRAG);
Property::Map curveVertexFormat;
curveVertexFormat["aPosition"] = Property::VECTOR2;
line.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
line.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- Shader shader = Shader::New(CURVE_VERTEX_SHADER, CURVE_FRAGMENT_SHADER);
+ Shader shader = Shader::New(SHADER_BEZIER_CURVE_VERT, SHADER_BEZIER_CURVE_FRAG);
Geometry geometry = Geometry::New();
geometry.AddVertexBuffer(vertexBuffer);
geometry.SetType(Geometry::LINE_STRIP);
--- /dev/null
+uniform lowp vec4 uColor;
+
+void main()
+{
+ gl_FragColor = vec4(0.0,0.0,0.0,1.0);
+}
--- /dev/null
+attribute mediump vec2 aPosition;
+uniform mediump mat4 uMvpMatrix;
+uniform vec3 uSize;
+
+void main()
+{
+ gl_Position = uMvpMatrix * vec4(aPosition*uSize.xy, 0.0, 1.0);
+}
#include "utils.h"
#include "dali/dali.h"
#include "dali-toolkit/dali-toolkit.h"
+#include "generated/color-transition-controller-composite-vert.h"
+#include "generated/color-transition-controller-composite-frag.h"
using namespace Dali;
using namespace Dali::Toolkit;
const Vector4 BG_COLOR = Vector4(0.f, 0.f, 0.f, 0.f);
-const char* const COMPOSITE_VSH = DALI_COMPOSE_SHADER(
-precision mediump float;
-
-// <DALI>
-uniform mat4 uMvpMatrix;
-uniform vec3 uSize;
-// </DALI>
-
-uniform float uFlow;
-uniform vec4 uUvTransform; // rotation, scale (initial, target))
-
-attribute vec2 aPosition;
-
-varying vec2 vUv;
-varying vec2 vUvFlow;
-
-void main()
-{
- vec4 position = uMvpMatrix * vec4(aPosition * uSize.xy, 0., 1.);
-
- gl_Position = position;
-
- vec2 uv = position.xy / (position.ww * 2.);
- vUv = uv + vec2(.5);
-
- float alpha = uFlow * .5 + .5;
- vec2 uvRotationScale = mix(uUvTransform.xy, uUvTransform.zw, alpha);
- float c = cos(uvRotationScale.x) * uvRotationScale.y;
- float s = sin(uvRotationScale.x) * uvRotationScale.y;
- vec4 uvMatrix = vec4(c, -s, s, c);
- uv = vec2(dot(uvMatrix.xy, uv), dot(uvMatrix.zw, uv));
-
- // N.B. +y is down which is well aligned with the inverted y of the off-screen render,
- // however we need to flip the y of the uvs for the flow map.
- vUvFlow = vec2(uv.x + .5, .5 - uv.y);
-});
-
-const char* const COMPOSITE_FSH = DALI_COMPOSE_SHADER(
-precision mediump float;
-
-const float kStepsilon = 1e-2;
-
-uniform sampler2D sColor;
-uniform sampler2D sFlowMap;
-
-uniform float uFlow;
-uniform vec3 uRgb[2];
-
-varying vec2 vUv;
-varying vec2 vUvFlow;
-
-void main()
-{
- vec4 colorAlpha = texture2D(sColor, vUv);
- float flow = smoothstep(.5 - kStepsilon, .5 + kStepsilon, clamp(uFlow + texture2D(sFlowMap, vUvFlow).r, 0., 1.));
-
- gl_FragColor = vec4(mix(colorAlpha.rgb, mix(uRgb[0], uRgb[1], flow), colorAlpha.a), 1.);
-});
-
} // nonamespace
ColorTransitionController::ColorTransitionController(WeakHandle<RenderTaskList> window, Actor content, RenderTaskList tasks, Vector3 initialColor)
flowSampler.SetWrapMode(WrapMode::REPEAT, WrapMode::REPEAT);
tsComposite.SetSampler(1, flowSampler);
- auto shdComposite = Shader::New(COMPOSITE_VSH, COMPOSITE_FSH);
+ auto shdComposite = Shader::New(SHADER_COLOR_TRANSITION_CONTROLLER_COMPOSITE_VERT, SHADER_COLOR_TRANSITION_CONTROLLER_COMPOSITE_FRAG);
auto compositeRenderer = CreateRenderer(tsComposite, geomComposite, shdComposite);
composite.AddRenderer(compositeRenderer);
--- /dev/null
+precision mediump float;
+
+const float kStepsilon = 1e-2;
+
+uniform sampler2D sColor;
+uniform sampler2D sFlowMap;
+
+uniform float uFlow;
+uniform vec3 uRgb[2];
+
+varying vec2 vUv;
+varying vec2 vUvFlow;
+
+void main()
+{
+ vec4 colorAlpha = texture2D(sColor, vUv);
+ float flow = smoothstep(.5 - kStepsilon, .5 + kStepsilon, clamp(uFlow + texture2D(sFlowMap, vUvFlow).r, 0., 1.));
+
+ gl_FragColor = vec4(mix(colorAlpha.rgb, mix(uRgb[0], uRgb[1], flow), colorAlpha.a), 1.);
+}
--- /dev/null
+precision mediump float;
+
+// <DALI>
+uniform mat4 uMvpMatrix;
+uniform vec3 uSize;
+// </DALI>
+
+uniform float uFlow;
+uniform vec4 uUvTransform; // rotation, scale (initial, target))
+
+attribute vec2 aPosition;
+
+varying vec2 vUv;
+varying vec2 vUvFlow;
+
+void main()
+{
+ vec4 position = uMvpMatrix * vec4(aPosition * uSize.xy, 0., 1.);
+
+ gl_Position = position;
+
+ vec2 uv = position.xy / (position.ww * 2.);
+ vUv = uv + vec2(.5);
+
+ float alpha = uFlow * .5 + .5;
+ vec2 uvRotationScale = mix(uUvTransform.xy, uUvTransform.zw, alpha);
+ float c = cos(uvRotationScale.x) * uvRotationScale.y;
+ float s = sin(uvRotationScale.x) * uvRotationScale.y;
+ vec4 uvMatrix = vec4(c, -s, s, c);
+ uv = vec2(dot(uvMatrix.xy, uv), dot(uvMatrix.zw, uv));
+
+ // N.B. +y is down which is well aligned with the inverted y of the off-screen render,
+ // however we need to flip the y of the uvs for the flow map.
+ vUvFlow = vec2(uv.x + .5, .5 - uv.y);
+}
// INTERNAL INCLUDES
#include "shared/utility.h"
+#include "generated/compressed-texture-formats-example-vert.h"
+#include "generated/compressed-texture-formats-example-frag.h"
using namespace Dali;
using Dali::Toolkit::TextLabel;
const char* IMAGE_FILENAME_ASTC_LINEAR = DEMO_IMAGE_DIR "tx-astc-4x4-linear.ktx";
const char* IMAGE_FILENAME_ASTC_LINEAR_NATIVE = DEMO_IMAGE_DIR "tx-astc-4x4-linear-native.astc";
-// clang-format off
-static const char* VERTEX_SHADER_TEXTURE = DALI_COMPOSE_SHADER(
- attribute mediump vec2 aPosition;\n
- attribute mediump vec2 aTexCoord;\n
- uniform mediump mat4 uMvpMatrix;\n
- uniform mediump vec3 uSize;\n
- varying mediump vec2 vTexCoord;\n
- void main()\n
- {\n
- vec4 position = vec4(aPosition,0.0,1.0)*vec4(uSize,1.0);\n
- gl_Position = uMvpMatrix * position;\n
- vTexCoord = aTexCoord;\n
- }\n
-);
-
-static const char* FRAGMENT_SHADER_TEXTURE = DALI_COMPOSE_SHADER(
- uniform lowp vec4 uColor;\n
- uniform sampler2D sTexture;\n
- varying mediump vec2 vTexCoord;\n
-
- void main()\n
- {\n
- gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
- }\n
-);
-// clang-format on
-
/**
* @brief Create a renderer to render an image and adds it to an actor
* @param[in] imagePath The path where the image file is located
//Create the geometry and the shader renderers will use
Geometry geometry = DemoHelper::CreateTexturedQuad();
- Shader shader = Shader::New(VERTEX_SHADER_TEXTURE, FRAGMENT_SHADER_TEXTURE);
+ Shader shader = Shader::New(SHADER_COMPRESSED_TEXTURE_FORMATS_EXAMPLE_VERT, SHADER_COMPRESSED_TEXTURE_FORMATS_EXAMPLE_FRAG);
// Add images.
Actor actor = Actor::New();
--- /dev/null
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
+}
--- /dev/null
+attribute mediump vec2 aPosition;
+attribute mediump vec2 aTexCoord;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ vec4 position = vec4(aPosition,0.0,1.0)*vec4(uSize,1.0);
+ gl_Position = uMvpMatrix * position;
+ vTexCoord = aTexCoord;
+}
// EXTERNAL INCLUDES
#include <dali-toolkit/dali-toolkit.h>
+// INTERNAL INCLUDES
+#include "generated/clipped-image-vert.h"
+#include "generated/clipped-image-frag.h"
+
namespace ClippedImage
{
using namespace Dali;
const char* const DELTA_PROPERTY_NAME("uDelta"); ///< Name of uniform used to mix the Circle and Quad geometries.
/**
- * @brief This vertex-shader mixes in the quad and circle geometry depending on the value of uDelta.
- *
- * uDelta is used to mix in the Circle and the Quad positions.
- * If uDelta is 0.0f, then the circle position is adopted and if it is 1.0f, then the quad position is adopted.
- */
-// clang-format off
-const char * VERTEX_SHADER = DALI_COMPOSE_SHADER(
- attribute mediump vec2 aPositionCircle;\n
- attribute mediump vec2 aPositionQuad;\n
- uniform mediump float uDelta;
- uniform mediump mat4 uMvpMatrix;\n
- uniform mediump vec3 uSize;\n
- \n
- void main()\n
- {\n
- mediump vec4 vertexPosition = vec4(mix(aPositionCircle,aPositionQuad,uDelta), 0.0, 1.0);\n
- vertexPosition.xyz *= uSize;\n
- gl_Position = uMvpMatrix * vertexPosition;\n
- }\n
-);
-
-/**
- * @brief This fragment-shader does not output anything. It's for a control which is just going to clip as specified in the vertex shader.
- */
-const char * FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
- void main()\n
- {\n
- gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);\n
- }\n
-);
-// clang-format on
-
-/**
* @brief Creates the shader required for the clipped image
* @return A reference to a static handle to a shader object (only created when first called).
*/
if(!shader)
{
- shader = Shader::New(VERTEX_SHADER, FRAGMENT_SHADER);
+ shader = Shader::New(SHADER_CLIPPED_IMAGE_VERT, SHADER_CLIPPED_IMAGE_FRAG);
}
return shader;
--- /dev/null
+// This fragment-shader does not output anything.
+// It's for a control which is just going to clip as specified in the vertex shader.
+
+void main()
+{
+ gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+}
--- /dev/null
+// This vertex-shader mixes in the quad and circle geometry depending on the value of uDelta.
+//
+// uDelta is used to mix in the Circle and the Quad positions.
+// If uDelta is 0.0f, then the circle position is adopted and if it is 1.0f, then the quad position is adopted.
+
+attribute mediump vec2 aPositionCircle;
+attribute mediump vec2 aPositionQuad;
+uniform mediump float uDelta;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+
+void main()
+{
+ mediump vec4 vertexPosition = vec4(mix(aPositionCircle,aPositionQuad,uDelta), 0.0, 1.0);
+ vertexPosition.xyz *= uSize;
+ gl_Position = uMvpMatrix * vertexPosition;
+}
#include "dali/public-api/actors/actor.h"
#include "dali/public-api/rendering/renderer.h"
+#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;
namespace
#define DEFINE_MAX_LIGHTS "const int kMaxLights = " QUOTE(MAX_LIGHTS) ";"
-#define DEFINE(x) "#define " DALI_COMPOSE_SHADER(x) DALI_COMPOSE_SHADER(\n)
-
-// clang-format off
-
-//=============================================================================
-// 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);
-});
-// clang-format on
-
//=============================================================================
// PRNG for floats.
struct FloatRand
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);
meshRenderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK);
finalImageTextures.SetSampler(1, sampler);
finalImageTextures.SetSampler(2, sampler);
- Shader shdMain = Shader::New(MAINPASS_VSH, MAINPASS_FSH);
+ 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);
--- /dev/null
+#version 300 es
+
+precision mediump float;
+
+const int kMaxLights = 32;
+
+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;
+
+#define DEPTH uDepth_InvDepth_Near.x
+#define INV_DEPTH uDepth_InvDepth_Near.y
+#define NEAR uDepth_InvDepth_Near.z
+
+// 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);
+}
--- /dev/null
+#version 300 es
+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;
+}
--- /dev/null
+#version 300 es
+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;
+}
--- /dev/null
+#version 300 es
+
+precision mediump float;
+
+// DALI uniforms
+uniform mat4 uMvpMatrix;
+uniform mat3 uNormalMatrix;
+uniform vec3 uSize;
+
+uniform vec3 uDepth_InvDepth_Near;
+
+#define DEPTH uDepth_InvDepth_Near.x
+#define INV_DEPTH uDepth_InvDepth_Near.y
+#define NEAR uDepth_InvDepth_Near.z
+
+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);
+}
#include "game-model.h"
#include "game-texture.h"
-#include <dali/dali.h>
-
-namespace
-{
-// clang-format off
+#include "generated/game-renderer-vert.h"
+#include "generated/game-renderer-frag.h"
-const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
- attribute highp vec3 aPosition;\n
- attribute highp vec3 aNormal;\n
- attribute highp vec2 aTexCoord;\n
- uniform highp mat4 uMvpMatrix;\n
- varying highp vec2 vTexCoord;\n
- void main()\n
- {\n
- gl_Position = uMvpMatrix * vec4(aPosition, 1.0 );\n
- vTexCoord = aTexCoord;\n
- vTexCoord.y = 1.0 - vTexCoord.y;\n
- }\n
-)
- ;
-const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
- uniform sampler2D sTexture;\n
- varying highp vec2 vTexCoord;\n
- void main()\n
- {\n
- gl_FragColor = texture2D( sTexture, vTexCoord ) * vec4(1.2, 1.2, 1.2, 1.0);\n
- }\n
-);
-// clang-format on
-
-} // namespace
+#include <dali/dali.h>
GameRenderer::GameRenderer()
: mModel(NULL),
{
if(!mRenderer && mModel)
{
- Dali::Shader shader = Dali::Shader::New(VERTEX_SHADER, FRAGMENT_SHADER);
+ Dali::Shader shader = Dali::Shader::New(SHADER_GAME_RENDERER_VERT, SHADER_GAME_RENDERER_FRAG);
mRenderer = Dali::Renderer::New(mModel->GetGeometry(), shader);
mRenderer.SetProperty(Dali::Renderer::Property::DEPTH_WRITE_MODE, Dali::DepthWriteMode::ON);
mRenderer.SetProperty(Dali::Renderer::Property::DEPTH_FUNCTION, Dali::DepthFunction::LESS_EQUAL);
--- /dev/null
+uniform sampler2D sTexture;
+varying highp vec2 vTexCoord;
+
+void main()
+{
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * vec4(1.2, 1.2, 1.2, 1.0);
+}
--- /dev/null
+attribute highp vec3 aPosition;
+attribute highp vec3 aNormal;
+attribute highp vec2 aTexCoord;
+uniform highp mat4 uMvpMatrix;
+varying highp vec2 vTexCoord;
+
+void main()
+{
+ gl_Position = uMvpMatrix * vec4(aPosition, 1.0 );
+ vTexCoord = aTexCoord;
+ vTexCoord.y = 1.0 - vTexCoord.y;
+}
#include <dali-toolkit/devel-api/image-loader/texture-manager.h>
#include "shared/view.h"
+#include "generated/image-view-url-frag.h"
using namespace Dali;
const char* const BUTTON_ICON(DEMO_IMAGE_DIR "icon-change.png");
const char* const BUTTON_ICON_SELECTED(DEMO_IMAGE_DIR "icon-change-selected.png");
-const char* FILTER_FRAGMENT_SOURCE =
- {
- "precision highp float;\n"
- "varying mediump vec2 vTexCoord;\n"
- "uniform sampler2D sTexture;\n"
- "uniform mediump float uDelta;\n"
- "void main()\n"
- "{\n"
- " vec4 color = vec4(0.0);\n"
- " vec2 texCoord = vTexCoord * 2. - 1.;\n"
- " mat2 rotation = mat2(cos(uDelta), -sin(uDelta), sin(uDelta), cos(uDelta));"
- " texCoord = (rotation * texCoord) * .5 + .5;\n"
- " color += texture2D( sTexture, texCoord );\n"
- " gl_FragColor = color;\n"
- "}\n"};
-
const char* DELTA_UNIFORM_NAME = "uDelta";
const Vector2 TARGET_SIZE(800.f, 800.f);
mActorForInput.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
mActorForInput.SetProperty(Actor::Property::SIZE, TARGET_SIZE);
Property::Map customShader;
- customShader[Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = FILTER_FRAGMENT_SOURCE;
+ customShader[Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = SHADER_IMAGE_VIEW_URL_FRAG.data();
Property::Map visualMap;
visualMap.Insert(Toolkit::Visual::Property::SHADER, customShader);
mActorForInput.SetProperty(Toolkit::ImageView::Property::IMAGE, visualMap);
--- /dev/null
+precision highp float;
+varying mediump vec2 vTexCoord;
+uniform sampler2D sTexture;
+uniform mediump float uDelta;
+
+void main()
+{
+ vec4 color = vec4(0.0);
+ vec2 texCoord = vTexCoord * 2. - 1.;
+ mat2 rotation = mat2(cos(uDelta), -sin(uDelta), sin(uDelta), cos(uDelta));
+ texCoord = (rotation * texCoord) * .5 + .5;
+ color += texture2D( sTexture, texCoord );
+ gl_FragColor = color;
+}
\ No newline at end of file
// INTERNAL INCLUDES
#include "shared/view.h"
+#include "generated/line-mesh-vert.h"
+#include "generated/line-mesh-frag.h"
#include <sstream>
namespace
{
-#define MAKE_SHADER(A) #A
-
-const char* VERTEX_SHADER = MAKE_SHADER(
- attribute mediump vec2 aPosition1;
- attribute mediump vec2 aPosition2;
- attribute lowp vec3 aColor;
- uniform mediump mat4 uMvpMatrix;
- uniform mediump vec3 uSize;
- uniform mediump float uMorphAmount;
-
- varying lowp vec3 vColor;
-
- void main() {
- mediump vec2 morphPosition = mix(aPosition1, aPosition2, uMorphAmount);
- mediump vec4 vertexPosition = vec4(morphPosition, 0.0, 1.0);
- vColor = aColor;
- vertexPosition.xyz *= uSize;
- vertexPosition = uMvpMatrix * vertexPosition;
- gl_Position = vertexPosition;
- });
-
-const char* FRAGMENT_SHADER = MAKE_SHADER(
- uniform lowp vec4 uColor;
- uniform sampler2D sTexture;
-
- varying lowp vec3 vColor;
-
- void main() {
- gl_FragColor = uColor * vec4(vColor, 1.0);
- });
const unsigned short INDEX_LINES[] = {0, 1, 1, 2, 2, 3, 3, 4, 4, 0};
const unsigned short INDEX_LOOP[] = {0, 1, 2, 3, 4};
mMeshActor.Reset();
}
- mShader = Shader::New(VERTEX_SHADER, FRAGMENT_SHADER);
+ mShader = Shader::New(SHADER_LINE_MESH_VERT, SHADER_LINE_MESH_FRAG);
mGeometry = CreateGeometry();
mRenderer = Renderer::New(mGeometry, mShader);
--- /dev/null
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+
+varying lowp vec3 vColor;
+
+void main()
+{
+ gl_FragColor = uColor * vec4(vColor, 1.0);
+}
--- /dev/null
+attribute mediump vec2 aPosition1;
+attribute mediump vec2 aPosition2;
+attribute lowp vec3 aColor;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+uniform mediump float uMorphAmount;
+
+varying lowp vec3 vColor;
+
+void main()
+{
+ mediump vec2 morphPosition = mix(aPosition1, aPosition2, uMorphAmount);
+ mediump vec4 vertexPosition = vec4(morphPosition, 0.0, 1.0);
+ vColor = aColor;
+ vertexPosition.xyz *= uSize;
+ vertexPosition = uMvpMatrix * vertexPosition;
+ gl_Position = vertexPosition;
+}
// INTERNAL INCLUDES
#include "shared/view.h"
+#include "generated/mesh-morph-vert.h"
+#include "generated/mesh-morph-frag.h"
using namespace Dali;
namespace
{
-#define MAKE_SHADER(A) #A
-
-const char* VERTEX_SHADER = MAKE_SHADER(
- attribute mediump vec2 aInitPos;
- attribute mediump vec2 aFinalPos;
- attribute mediump vec3 aColor;
- uniform mediump mat4 uMvpMatrix;
- uniform mediump vec3 uSize;
- uniform mediump float uDelta;
- uniform lowp vec4 uColor;
- varying lowp vec4 vColor;
-
- void main() {
- mediump vec4 vertexPosition = vec4(mix(aInitPos, aFinalPos, uDelta), 0.0, 1.0);
- vertexPosition.xyz *= uSize;
- vertexPosition = uMvpMatrix * vertexPosition;
- gl_Position = vertexPosition;
- vColor = vec4(aColor, 0.) * uColor;
- });
-
-const char* FRAGMENT_SHADER = MAKE_SHADER(
- varying lowp vec4 vColor;
-
- void main() {
- gl_FragColor = vColor;
- });
Geometry CreateGeometry()
{
// The Init signal is received once (only) during the Application lifetime
- mShader = Shader::New(VERTEX_SHADER, FRAGMENT_SHADER);
+ mShader = Shader::New(SHADER_MESH_MORPH_VERT, SHADER_MESH_MORPH_FRAG);
mGeometry = CreateGeometry();
mRenderer = Renderer::New(mGeometry, mShader);
--- /dev/null
+varying lowp vec4 vColor;
+
+void main()
+{
+ gl_FragColor = vColor;
+}
\ No newline at end of file
--- /dev/null
+attribute mediump vec2 aInitPos;
+attribute mediump vec2 aFinalPos;
+attribute mediump vec3 aColor;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+uniform mediump float uDelta;
+uniform lowp vec4 uColor;
+varying lowp vec4 vColor;
+
+void main()
+{
+ mediump vec4 vertexPosition = vec4(mix(aInitPos, aFinalPos, uDelta), 0.0, 1.0);
+ vertexPosition.xyz *= uSize;
+ vertexPosition = uMvpMatrix * vertexPosition;
+ gl_Position = vertexPosition;
+ vColor = vec4(aColor, 0.) * uColor;
+}
// INTERNAL INCLUDES
#include "shared/utility.h" // DemoHelper::LoadTexture
+#include "generated/metaball-vert.h"
+#include "generated/metaball-frag.h"
+#include "generated/metaball-refraction-frag.h"
using namespace Dali;
constexpr uint32_t METABALL_NUMBER = 6;
/**
- * Vertex shader code for metaball
- */
-// clang-format off
-const char* const METABALL_VERTEX_SHADER = DALI_COMPOSE_SHADER (
- attribute mediump vec2 aPosition;\n
- attribute mediump vec2 aTexture;\n
- uniform mediump mat4 uMvpMatrix;\n
- uniform mediump vec3 uSize;\n
- uniform lowp vec4 uColor;\n
- varying mediump vec2 vTexCoord;\n
-
- void main()\n
- {\n
- vTexCoord = aTexture;\n
- mediump vec4 vertexPosition = vec4(aPosition.x, aPosition.y, 0.0, 1.0);\n
- gl_Position = uMvpMatrix * vertexPosition;\n
- }\n
-);
-
-/**
- * Fragment shader code for metaball
- */
-const char* const METABALL_FRAG_SHADER = DALI_COMPOSE_SHADER (
- precision mediump float;\n
- varying vec2 vTexCoord;\n
- uniform vec2 uPositionMetaball;\n
- uniform vec2 uPositionVar;\n
- uniform vec2 uGravityVector;\n
- uniform float uRadius;\n
- uniform float uRadiusVar;\n
- void main()\n
- {\n
- vec2 adjustedCoords = vTexCoord * 2.0 - 1.0;\n
- vec2 finalMetaballPosition = uPositionMetaball + uGravityVector + uPositionVar;\n
- \n
- float finalRadius = uRadius + uRadiusVar;\n
- vec2 distanceVec = adjustedCoords - finalMetaballPosition;\n
- float result = dot(distanceVec, distanceVec);\n
- float color = inversesqrt(result) * finalRadius;\n
- \n
- gl_FragColor = vec4(color,color,color,1.0);\n
- }\n
-);
-
-/**
- * Fragment shader code for metaball and background composition with refraction effect
- */
-const char* const REFRACTION_FRAG_SHADER = DALI_COMPOSE_SHADER (
- precision highp float;\n
- varying vec2 vTexCoord;\n
- uniform sampler2D sTexture;\n
- uniform sampler2D sEffect;\n
- uniform vec2 uPositionMetaball;\n
- void main()\n
- {\n
- vec2 zoomCoords;\n
- vec3 normal = vec3(0.0,0.0,1.0);\n
- vec2 fakePos = vec2(0.0,0.0);\n
- vec3 color = vec3(1.0, 1.0, 1.0);
- float ambient = 0.2;
- \n
- vec4 metaColor = texture2D(sEffect, vTexCoord);\n
- \n
- vec2 adjustedCoords = vTexCoord.xy * vec2(2.0) - vec2(1.0);\n
- fakePos = adjustedCoords.xy - vec2(uPositionMetaball.x, -uPositionMetaball.y);
- float len = length(fakePos) + 0.01;\n
- vec3 colorPos = vec3(0,0,1);
- \n
- if (metaColor.r > 0.85)\n
- {\n
- zoomCoords = ((vTexCoord - 0.5) * 0.9);\n
- zoomCoords = zoomCoords + 0.5;\n
- \n
- float interpNormal = mix(0.7, 1.0, (metaColor.r - 0.85) * 4.);\n
- normal.xyz = vec3(fakePos.x * (1.0 - interpNormal) / len, fakePos.y * (1.0 - interpNormal) / len, interpNormal);\n
- normal.xyz = normalize(normal.xyz);\n
- color = vec3(0.65, 1.0, 0);\n
- colorPos = vec3(fakePos.x,fakePos.y,0);
- }\n
- else if (metaColor.r > 0.75)\n
- {\n
- float interpolation = mix(0.9, 1.15, (0.85 - metaColor.r) * 10.0);\n
- zoomCoords = ((vTexCoord - 0.5) * interpolation);\n
- zoomCoords = zoomCoords + 0.5;\n
- \n
- float interpNormal = mix(0.7, 0.0, (0.85 - metaColor.r) * 10.0);\n
- normal.xyz = vec3(fakePos.x * (1.0 - interpNormal) / len, fakePos.y * (1.0 - interpNormal) / len, interpNormal);\n
- normal.xyz = normalize(normal.xyz);\n
- color = vec3(0.65, 1.0, 0);\n
- colorPos = vec3(fakePos.x,fakePos.y,0);
- }\n
- else\n
- {\n
- zoomCoords = vTexCoord;\n
- normal = vec3(0,0,0);\n
- ambient = 0.5;\n
- }\n
- \n
- vec3 lightPosition = vec3(-750.0,-1000.0,2000.0);\n
- vec3 vertex = vec3(adjustedCoords.x,adjustedCoords.y,0.0);\n
- \n
- vec3 vecToLight = normalize( lightPosition - vertex );\n
- \n
- float lightDiffuse = dot( vecToLight, normal );\n
- lightDiffuse = max(0.0,lightDiffuse);\n
- lightDiffuse = lightDiffuse * 0.5 + 0.5;
- \n
- vec3 vertexToEye = vec3(0,0,1) - vertex;\n
- vertexToEye = normalize(vertexToEye);
- vec3 lightReflect = normalize(reflect(-vecToLight, normal));\n
- float specularFactor = max(0.0,dot(vertexToEye, lightReflect));\n
- specularFactor = pow(specularFactor, 32.0) * 0.7;
- \n
- vec4 texColor = texture2D(sTexture, zoomCoords);\n
- gl_FragColor.rgb = texColor.rgb * ambient + color.rgb * texColor.rgb * lightDiffuse + vec3(specularFactor);\n
- gl_FragColor.a = 1.0;
- }\n
- );
-// clang-format on
-
-/**
* Metadata for each ball
*/
struct MetaballInfo
void MetaballExplosionController::CreateMetaballActors()
{
// Create the shader for the metaballs, tell DALi that shader modifies geometry so we dont need to set a meaningless size
- Shader shader = Shader::New(METABALL_VERTEX_SHADER, METABALL_FRAG_SHADER, Shader::Hint::MODIFIES_GEOMETRY);
+ Shader shader = Shader::New(SHADER_METABALL_VERT, SHADER_METABALL_FRAG, Shader::Hint::MODIFIES_GEOMETRY);
Geometry metaballGeom = CreateGeometry();
// Reuse same renderer for each actor
void MetaballExplosionController::CreateComposition()
{
//Create new shader
- Shader shader = Shader::New(METABALL_VERTEX_SHADER, REFRACTION_FRAG_SHADER);
+ Shader shader = Shader::New(SHADER_METABALL_VERT, SHADER_METABALL_REFRACTION_FRAG);
// Create new texture set
auto textureSet = TextureSet::New();
--- /dev/null
+//Fragment shader code for metaball and background composition with refraction effect
+
+precision highp float;
+varying vec2 vTexCoord;
+uniform sampler2D sTexture;
+uniform sampler2D sEffect;
+uniform vec2 uPositionMetaball;
+void main()
+{
+ vec2 zoomCoords;
+ vec3 normal = vec3(0.0,0.0,1.0);
+ vec2 fakePos = vec2(0.0,0.0);
+ vec3 color = vec3(1.0, 1.0, 1.0);
+ float ambient = 0.2;
+
+ vec4 metaColor = texture2D(sEffect, vTexCoord);
+
+ vec2 adjustedCoords = vTexCoord.xy * vec2(2.0) - vec2(1.0);
+ fakePos = adjustedCoords.xy - vec2(uPositionMetaball.x, -uPositionMetaball.y);
+ float len = length(fakePos) + 0.01;
+ vec3 colorPos = vec3(0,0,1);
+
+ if (metaColor.r > 0.85)
+ {
+ zoomCoords = ((vTexCoord - 0.5) * 0.9);
+ zoomCoords = zoomCoords + 0.5;
+
+ float interpNormal = mix(0.7, 1.0, (metaColor.r - 0.85) * 4.);
+ normal.xyz = vec3(fakePos.x * (1.0 - interpNormal) / len, fakePos.y * (1.0 - interpNormal) / len, interpNormal);
+ normal.xyz = normalize(normal.xyz);
+ color = vec3(0.65, 1.0, 0);
+ colorPos = vec3(fakePos.x,fakePos.y,0);
+ }
+ else if (metaColor.r > 0.75)
+ {
+ float interpolation = mix(0.9, 1.15, (0.85 - metaColor.r) * 10.0);
+ zoomCoords = ((vTexCoord - 0.5) * interpolation);
+ zoomCoords = zoomCoords + 0.5;
+
+ float interpNormal = mix(0.7, 0.0, (0.85 - metaColor.r) * 10.0);
+ normal.xyz = vec3(fakePos.x * (1.0 - interpNormal) / len, fakePos.y * (1.0 - interpNormal) / len, interpNormal);
+ normal.xyz = normalize(normal.xyz);
+ color = vec3(0.65, 1.0, 0);
+ colorPos = vec3(fakePos.x,fakePos.y,0);
+ }
+ else
+ {
+ zoomCoords = vTexCoord;
+ normal = vec3(0,0,0);
+ ambient = 0.5;
+ }
+
+ vec3 lightPosition = vec3(-750.0,-1000.0,2000.0);
+ vec3 vertex = vec3(adjustedCoords.x,adjustedCoords.y,0.0);
+
+ vec3 vecToLight = normalize( lightPosition - vertex );
+
+ float lightDiffuse = dot( vecToLight, normal );
+ lightDiffuse = max(0.0,lightDiffuse);
+ lightDiffuse = lightDiffuse * 0.5 + 0.5;
+
+ vec3 vertexToEye = vec3(0,0,1) - vertex;
+ vertexToEye = normalize(vertexToEye);
+ vec3 lightReflect = normalize(reflect(-vecToLight, normal));
+ float specularFactor = max(0.0,dot(vertexToEye, lightReflect));
+ specularFactor = pow(specularFactor, 32.0) * 0.7;
+
+ vec4 texColor = texture2D(sTexture, zoomCoords);
+ gl_FragColor.rgb = texColor.rgb * ambient + color.rgb * texColor.rgb * lightDiffuse + vec3(specularFactor);
+ gl_FragColor.a = 1.0;
+}
--- /dev/null
+// Fragment shader code for metaball
+
+precision mediump float;
+varying vec2 vTexCoord;
+uniform vec2 uPositionMetaball;
+uniform vec2 uPositionVar;
+uniform vec2 uGravityVector;
+uniform float uRadius;
+uniform float uRadiusVar;
+
+void main()
+{
+ vec2 adjustedCoords = vTexCoord * 2.0 - 1.0;
+ vec2 finalMetaballPosition = uPositionMetaball + uGravityVector + uPositionVar;
+
+ float finalRadius = uRadius + uRadiusVar;
+ vec2 distanceVec = adjustedCoords - finalMetaballPosition;
+ float result = dot(distanceVec, distanceVec);
+ float color = inversesqrt(result) * finalRadius;
+
+ gl_FragColor = vec4(color,color,color,1.0);
+}
--- /dev/null
+//Vertex shader code for metaball
+
+attribute mediump vec2 aPosition;
+attribute mediump vec2 aTexture;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+uniform lowp vec4 uColor;
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ vTexCoord = aTexture;
+ mediump vec4 vertexPosition = vec4(aPosition.x, aPosition.y, 0.0, 1.0);
+ gl_Position = uMvpMatrix * vertexPosition;
+}
// INTERNAL INCLUDES
#include "shared/utility.h" // DemoHelper::LoadTexture
+#include "generated/metaball-vert.h"
+#include "generated/metaball-frag.h"
+#include "generated/metaball-refraction-frag.h"
+#include "generated/fragment-frag.h"
using namespace Dali;
// number of metaballs
constexpr uint32_t METABALL_NUMBER = 6;
-// clang-format off
-
-/**
- * Vertex shader for metaballs
- */
-const char* const METABALL_VERTEX_SHADER = DALI_COMPOSE_SHADER (
- attribute mediump vec2 aPosition;\n
- attribute mediump vec2 aTexture;\n
- uniform mediump mat4 uMvpMatrix;\n
- uniform mediump vec3 uSize;\n
- uniform lowp vec4 uColor;\n
- varying mediump vec2 vTexCoord;\n
-
- void main()\n
- {\n
- mediump vec4 vertexPosition = vec4(aPosition.x, aPosition.y, 0.0, 1.0);\n
- vertexPosition = uMvpMatrix * vertexPosition;\n
- gl_Position = vertexPosition;\n
- vTexCoord = aTexture;\n
- }\n
-);
-
-/**
- * Fragment shader for metaballs
- */
-const char* const METABALL_FRAG_SHADER = DALI_COMPOSE_SHADER (
- precision mediump float;\n
- varying vec2 vTexCoord;\n
- uniform vec2 uPositionMetaball;\n
- uniform vec2 uPositionVar;\n
- uniform vec2 uGravityVector;\n
- uniform float uRadius;\n
- uniform float uRadiusVar;\n
- uniform float uAspect;\n
- void main()\n
- {\n
- vec2 adjustedCoords = vTexCoord * 2.0 - 1.0;\n
- vec2 finalMetaballPosition = uPositionMetaball + uGravityVector + uPositionVar;\n
-
- float distance = (adjustedCoords.x - finalMetaballPosition.x) * (adjustedCoords.x - finalMetaballPosition.x) +
- (adjustedCoords.y - finalMetaballPosition.y) * (adjustedCoords.y - finalMetaballPosition.y);\n
- float finalRadius = uRadius + uRadiusVar;\n
- float color = finalRadius / sqrt( distance );\n
- vec2 bordercolor = vec2(0.0,0.0);\n
- if (vTexCoord.x < 0.1)\n
- {\n
- bordercolor.x = (0.1 - vTexCoord.x) * 0.8;\n
- }\n
- if (vTexCoord.x > 0.9)\n
- {\n
- bordercolor.x = (vTexCoord.x - 0.9) * 0.8;\n
- }\n
- if (vTexCoord.y < 0.1)\n
- {\n
- bordercolor.y = (0.1 - vTexCoord.y) * 0.8;\n
- }\n
- if (vTexCoord.y > (0.9 * uAspect))\n
- {\n
- bordercolor.y = (vTexCoord.y - (0.9 * uAspect)) * 0.8;\n
- }\n
- float border = (bordercolor.x + bordercolor.y) * 0.5;\n
- gl_FragColor = vec4(color + border,color + border,color + border,1.0);\n
- }\n
-);
-
-/**
- * Fragment shader code for metaball and background composition with refraction effect
- */
-const char* const REFRACTION_FRAG_SHADER = DALI_COMPOSE_SHADER (
- precision mediump float;\n
- varying vec2 vTexCoord;\n
- uniform sampler2D sTexture;\n
- uniform sampler2D sEffect;\n
- void main()\n
- {\n
- vec4 metaColor = texture2D(sEffect, vTexCoord);\n
- vec2 zoomCoords;\n
- float bright = 1.0;\n
- if (metaColor.r > 0.85)\n
- {\n
- zoomCoords = ((vTexCoord - 0.5) * 0.95) + 0.5;\n
- }\n
- else if (metaColor.r > 0.78)\n
- {\n
- float interpolation = mix(0.95, 1.05, (0.85 - metaColor.r) * 50.0);\n
- zoomCoords = ((vTexCoord - 0.5) * interpolation) + 0.5;\n
- bright = 1.2;\n
- }\n
- else\n
- {\n
- zoomCoords = vTexCoord;\n
- }\n
-
- gl_FragColor = texture2D(sTexture, zoomCoords) * bright;\n
- }\n
- );
-
-/**
- * Fragment shader code when there's no effect
- */
-const char* const FRAG_SHADER = DALI_COMPOSE_SHADER (
- precision mediump float;\n
- varying vec2 vTexCoord;\n
- uniform sampler2D sTexture;\n
- void main()\n
- {\n
- gl_FragColor = texture2D(sTexture, vTexCoord);\n
- }\n
-);
-// clang-format on
-
/**
* Metadata for each ball
*/
const float aspect = mScreenSize.y / mScreenSize.x;
// Create the renderer for the metaballs
- Shader shader = Shader::New(METABALL_VERTEX_SHADER, METABALL_FRAG_SHADER, Shader::Hint::MODIFIES_GEOMETRY);
+ Shader shader = Shader::New(SHADER_METABALL_VERT, SHADER_METABALL_FRAG, Shader::Hint::MODIFIES_GEOMETRY);
Geometry metaballGeometry = CreateGeometry();
Renderer renderer = Renderer::New(metaballGeometry, shader);
renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
void MetaballRefracController::CreateComposition()
{
// Create Refraction shader and renderer
- mShaderRefraction = Shader::New(METABALL_VERTEX_SHADER, REFRACTION_FRAG_SHADER);
+ mShaderRefraction = Shader::New(SHADER_METABALL_VERT, SHADER_METABALL_REFRACTION_FRAG);
// Create new texture set
mTextureSetRefraction = TextureSet::New();
mTextureSetRefraction.SetTexture(1u, mMetaballFBO.GetColorTexture());
// Create normal shader
- mShaderNormal = Shader::New(METABALL_VERTEX_SHADER, FRAG_SHADER);
+ mShaderNormal = Shader::New(SHADER_METABALL_VERT, SHADER_FRAGMENT_FRAG);
// Create new texture set
mTextureSetNormal = TextureSet::New();
--- /dev/null
+// Fragment shader code when there's no effect
+
+precision mediump float;
+varying vec2 vTexCoord;
+uniform sampler2D sTexture;
+
+void main()
+{
+ gl_FragColor = texture2D(sTexture, vTexCoord);
+}
--- /dev/null
+// Fragment shader code for metaball and background composition with refraction effect
+
+precision mediump float;
+varying vec2 vTexCoord;
+uniform sampler2D sTexture;
+uniform sampler2D sEffect;
+
+void main()
+{
+ vec4 metaColor = texture2D(sEffect, vTexCoord);
+ vec2 zoomCoords;
+ float bright = 1.0;
+ if (metaColor.r > 0.85)
+ {
+ zoomCoords = ((vTexCoord - 0.5) * 0.95) + 0.5;
+ }
+ else if (metaColor.r > 0.78)
+ {
+ float interpolation = mix(0.95, 1.05, (0.85 - metaColor.r) * 50.0);
+ zoomCoords = ((vTexCoord - 0.5) * interpolation) + 0.5;
+ bright = 1.2;
+ }
+ else
+ {
+ zoomCoords = vTexCoord;
+ }
+
+ gl_FragColor = texture2D(sTexture, zoomCoords) * bright;
+}
--- /dev/null
+// Fragment shader for metaballs
+
+precision mediump float;
+varying vec2 vTexCoord;
+uniform vec2 uPositionMetaball;
+uniform vec2 uPositionVar;
+uniform vec2 uGravityVector;
+uniform float uRadius;
+uniform float uRadiusVar;
+uniform float uAspect;
+
+void main()
+{
+ vec2 adjustedCoords = vTexCoord * 2.0 - 1.0;
+ vec2 finalMetaballPosition = uPositionMetaball + uGravityVector + uPositionVar;
+
+ float distance = (adjustedCoords.x - finalMetaballPosition.x) * (adjustedCoords.x - finalMetaballPosition.x) +
+ (adjustedCoords.y - finalMetaballPosition.y) * (adjustedCoords.y - finalMetaballPosition.y);
+ float finalRadius = uRadius + uRadiusVar;
+ float color = finalRadius / sqrt( distance );
+ vec2 bordercolor = vec2(0.0,0.0);
+ if (vTexCoord.x < 0.1)
+ {
+ bordercolor.x = (0.1 - vTexCoord.x) * 0.8;
+ }
+ if (vTexCoord.x > 0.9)
+ {
+ bordercolor.x = (vTexCoord.x - 0.9) * 0.8;
+ }
+ if (vTexCoord.y < 0.1)
+ {
+ bordercolor.y = (0.1 - vTexCoord.y) * 0.8;
+ }
+ if (vTexCoord.y > (0.9 * uAspect))
+ {
+ bordercolor.y = (vTexCoord.y - (0.9 * uAspect)) * 0.8;
+ }
+ float border = (bordercolor.x + bordercolor.y) * 0.5;
+ gl_FragColor = vec4(color + border,color + border,color + border,1.0);
+}
--- /dev/null
+// Vertex shader for metaballs
+
+attribute mediump vec2 aPosition;
+attribute mediump vec2 aTexture;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+uniform lowp vec4 uColor;
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ mediump vec4 vertexPosition = vec4(aPosition.x, aPosition.y, 0.0, 1.0);
+ vertexPosition = uMvpMatrix * vertexPosition;
+ gl_Position = vertexPosition;
+ vTexCoord = aTexture;
+}
// INTERNAL INCLUDES
#include "shared/utility.h"
+#include "generated/native-image-source-texture-vert.h"
+#include "generated/native-image-source-texture-frag.h"
using namespace Dali;
using namespace Toolkit;
{
static const char* DEFAULT_SAMPLER_TYPENAME = "sampler2D";
- // clang-format off
- static const char* VERTEX_SHADER_TEXTURE = DALI_COMPOSE_SHADER(
- attribute mediump vec2 aPosition;\n
- attribute mediump vec2 aTexCoord;\n
- uniform mediump mat4 uMvpMatrix;\n
- uniform mediump vec3 uSize;\n
- varying mediump vec2 vTexCoord;\n
- void main()\n
- {\n
- vec4 position = vec4(aPosition,0.0,1.0)*vec4(uSize,1.0);\n
- gl_Position = uMvpMatrix * position;\n
- vTexCoord = aTexCoord;\n
- }\n
- );
-
- static const char* FRAGMENT_SHADER_TEXTURE = DALI_COMPOSE_SHADER(
- uniform lowp vec4 uColor;\n
- uniform sampler2D sTexture;\n
- varying mediump vec2 vTexCoord;\n
-
- void main()\n
- {\n
- gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
- }\n
- );
- // clang-format on
-
std::string fragmentShader;
//Get custom fragment shader prefix
if(fragmentPrefix)
{
fragmentShader = fragmentPrefix;
- fragmentShader += FRAGMENT_SHADER_TEXTURE;
+ fragmentShader += SHADER_NATIVE_IMAGE_SOURCE_TEXTURE_FRAG.data();
}
else
{
- fragmentShader = FRAGMENT_SHADER_TEXTURE;
+ fragmentShader = SHADER_NATIVE_IMAGE_SOURCE_TEXTURE_FRAG.data();
}
//Get custom sampler type name
fragmentShader.replace(fragmentShader.find(DEFAULT_SAMPLER_TYPENAME), strlen(DEFAULT_SAMPLER_TYPENAME), customSamplerTypename);
}
- return Shader::New(VERTEX_SHADER_TEXTURE, fragmentShader);
+ return Shader::New(SHADER_NATIVE_IMAGE_SOURCE_TEXTURE_VERT, fragmentShader);
}
} // namespace
--- /dev/null
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
+}
--- /dev/null
+attribute mediump vec2 aPosition;
+attribute mediump vec2 aTexCoord;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ vec4 position = vec4(aPosition,0.0,1.0)*vec4(uSize,1.0);
+ gl_Position = uMvpMatrix * position;
+ vTexCoord = aTexCoord;
+}
#include "utils.h"
#include "dali/public-api/animation/constraints.h"
+#include "generated/particle-view-vert.h"
+#include "generated/particle-view-frag.h"
+#include "generated/particle-view-simple-vert.h"
+#include "generated/particle-view-simple-frag.h"
+
//#define ENABLE_DEBUG_VOLUME
#define USE_GLSL_VERSION(version) "#version " #version "\n"
const uint32_t POPULATION_GRANULARITY = 128;
-///@brief Shader for billboarded particles, where the vertices of the particles
-/// are supplied as vec3 position (particle position) + vec2 sub-position.
-const char* const PARTICLES_VSH = USE_GLSL_VERSION(300 es)
-DALI_COMPOSE_SHADER(
- precision lowp float;
- uniform mat4 uModelView; // DALi
- uniform mat4 uProjection; // DALi
- uniform vec3 uSize; // DALi
- uniform vec4 uColor; // DALi
-
- uniform vec3 uSecondaryColor;
- uniform vec2 uDepthRange; // x is zNear, y is 1.f / (zFar - zNear)
- uniform float uTwinkleFrequency;
- uniform float uTwinkleSizeScale;
- uniform float uTwinkleOpacityWeight;
- uniform float uTime;
- uniform float uFocalLength;
- uniform float uAperture;
- uniform float uPopulation;
-
- struct Scatter
- {
- float radiusSqr;
- float amount;
- vec3 ray;
- };
-
- const int SCATTER_VARS = 6; // Must match ParticleView::mScatterProps' size.
- uniform Scatter uScatter[SCATTER_VARS];
-
- const int POPULATION_GRANULARITY = 128;
- uniform float uOrderLookUp[POPULATION_GRANULARITY];
-
- in vec3 aPosition;
- in float aSeed;
- in vec4 aPath;
- in vec2 aSubPosition;
- in float aSize;
-
- flat out float vDepth;
- flat out float vFocalDistance;
- out vec2 vUvUnit;
- flat out float vOpacity;
- flat out vec3 vColor; // ignore alpha
-
- float bezier(vec3 control, float alpha)
- {
- return mix(mix(control.x, control.y, alpha), mix(control.y, control.z, alpha), alpha);
- }
-
- void main() {
- // Get random order from the look-up table, based on particle ID.
- int particleId = gl_VertexID / 6;
- float order = uOrderLookUp[particleId & (POPULATION_GRANULARITY - 1)];
-
- // Get twinkle scalar
- float twinkle = sin(uTime * floor(uTwinkleFrequency * aSeed) + fract(aSeed * 1.17137));
-
- // Add Motion
- float s = sin(uTime + aSeed) * .5f + .5f; // different phase for all
- // NOTE: you'd think that taking the bezier() calls apart would save 4 mix() calls, since
- // the mix()es (of xy / yz / zw / wx) are all calculated twice. It turns out that the MALI
- // compiler is already doing this; leaving it as is for readability.
- float bx0 = bezier(aPath.xyz, s);
- float bx1 = bezier(aPath.zwx, s);
- float by0 = bezier(aPath.yzw, s);
- float by1 = bezier(aPath.wxy, s);
- vec3 motion = vec3(mix(bx0, bx1, s), mix(by0, by1, s), 0.f);
-
- // Model to view position
- vec3 position3 = aPosition * uSize + motion;
-
- vec4 position = uModelView * vec4(position3, 1.f);
-
- // Add scatter - calculated in view space, using view ray
- vec3 normalizedPos = position.xyz / uSize;
- for (int i = 0; i < SCATTER_VARS; ++i)
- {
- vec2 scatterDist = (normalizedPos - uScatter[i].ray * dot(uScatter[i].ray, normalizedPos)).xy;
-
- // NOTE: replacing the division with a multiplication (by inverse) oddly results in more instructions (MALI).
- float scatter = max(0.f, uScatter[i].radiusSqr - dot(scatterDist, scatterDist)) *
- uScatter[i].amount / aSize;
- position.xy += scatter * normalize(scatterDist) * uSize.xy;
- }
-
- // Calculate normalised depth and distance from focal plane
- float depth = (position.z - uDepthRange.x) * uDepthRange.y;
- vDepth = depth;
-
- float focalDist = (uFocalLength - depth) * uAperture;
- focalDist *= focalDist;
- vFocalDistance = max(focalDist, 1e-6f); // NOTE: was clamp(..., 1.f); side effect: out of focus particles get squashed at higher aperture values.
-
- // Calculate expiring scale - for size and opacity.
- float expiringScale = smoothstep(order + 1.f, order, uPopulation);
-
- // Calculate billboard position and size
- vec2 subPosition = aSubPosition * aSize *
- (1.f + twinkle * aSeed * uTwinkleSizeScale) *
- expiringScale;
-
- // Insist on hacking the size? Do it here...
- float sizeHack = depth + .5f;
- // NOTE: sizeHack *= sizeHack looked slightly better.
- subPosition *= sizeHack;
-
- vec3 subPositionView = vec3(subPosition, 0.);
-
- // Add billboards to view position.
- position += vec4(subPositionView, 0.f);
-
- // subPosition doubles as normalized (-1..1) UV.
- vUvUnit = aSubPosition;
-
- // Vary opacity (actor alpha) by time as well as expiring scale.
- vOpacity = uColor.a * expiringScale *
- (1.0f + aSeed + twinkle * uTwinkleOpacityWeight) / (2.0f + uTwinkleOpacityWeight);
-
- // Randomize RGB using seed.
- vec3 mixColor = vec3(fract(aSeed), fract(aSeed * 16.f), fract(aSeed * 256.f));
- vColor = mix(uColor.rgb, uSecondaryColor, mixColor);
-
- gl_Position = uProjection * position;
- });
-
-///@brief Fragment shader for particles, which simulates depth of field
-/// using a combination of procedural texturing, alpha testing and alpha
-/// blending.
-const char* const PARTICLES_FSH = USE_GLSL_VERSION(300 es)
-DALI_COMPOSE_SHADER(
- precision lowp float;
- uniform float uAlphaTestRefValue;
- uniform vec2 uFadeRange; // near, far
- in vec2 vUvUnit;
- flat in float vDepth;
- flat in float vFocalDistance;
- flat in float vOpacity;
- flat in vec3 vColor;
- out vec4 oFragColor;
-
- const float REF_VALUE_THRESHOLD = 1. / 64.;
-
- void main() {
- // Softened disc pattern from normalized UVs
- float value = 1.f - dot(vUvUnit, vUvUnit);
-
- // Decrease area of particles 'in-focus'.
- float refValue = (1.f - vFocalDistance) * .5f;
- float threshold = REF_VALUE_THRESHOLD * (1.f + vDepth);
- float alpha = pow(value, vFocalDistance) * smoothstep(refValue - threshold, refValue + threshold, value);
- if (alpha < uAlphaTestRefValue)
- {
- discard;
- }
-
- // Apply opacity
- alpha *= vOpacity;
- alpha *= alpha;
-
- // Fade particles out as they get close to the near and far clipping planes
- alpha *= smoothstep(.0f, uFadeRange.x, vDepth) * smoothstep(1.f, uFadeRange.y, vDepth);
-
- oFragColor = vec4(vColor, alpha);
- });
-
-///@brief Shader for simple textured geometry.
-const char* const SIMPLE_VSH = USE_GLSL_VERSION(300 es)
-DALI_COMPOSE_SHADER(
- precision mediump float;
- uniform mat4 uMvpMatrix;//by DALi
- uniform vec3 uSize; // by DALi
- in vec3 aPosition;
- void main() {
- gl_Position = uMvpMatrix * vec4(aPosition * uSize, 1.f);
- });
-
-///@brief Shader for an unlit, unfogged, textured mesh.
-const char* const SIMPLE_FSH = USE_GLSL_VERSION(300 es)
-DALI_COMPOSE_SHADER(
- precision mediump float;
- uniform vec4 uColor;
- out vec4 oFragColor;
-
- void main() {
- oFragColor = uColor;
- });
-
-
uint32_t GetSkipValue(uint32_t count, uint32_t prime)
{
uint32_t skip = 0;
}
// create shader
- Shader particleShader = Shader::New(PARTICLES_VSH, PARTICLES_FSH, Shader::Hint::MODIFIES_GEOMETRY);
+ Shader particleShader = Shader::New(SHADER_PARTICLE_VIEW_VERT, SHADER_PARTICLE_VIEW_FRAG, Shader::Hint::MODIFIES_GEOMETRY);
float zNear = camera.GetNearClippingPlane();
float zFar = camera.GetFarClippingPlane();
#ifdef ENABLE_DEBUG_VOLUME
Geometry cubeGeom = CreateCuboidWireframeGeometry();
- renderer = CreateRenderer(renderer.GetTextures(), cubeGeom, Shader::New(SIMPLE_VSH, SIMPLE_FSH));
+ renderer = CreateRenderer(renderer.GetTextures(), cubeGeom, Shader::New(SHADER_PARTICLE_VIEW_SIMPLE_VERT, SHADER_PARTICLE_VIEW_SIMPLE_FRAG));
masterParticles.AddRenderer(renderer);
#endif
--- /dev/null
+// Shader for an unlit, unfogged, textured mesh.
+
+#version 300 es
+
+precision mediump float;
+uniform vec4 uColor;
+out vec4 oFragColor;
+
+void main()
+{
+ oFragColor = uColor;
+}
--- /dev/null
+// Shader for simple textured geometry.
+
+#version 300 es
+
+precision mediump float;
+uniform mat4 uMvpMatrix;//by DALi
+uniform vec3 uSize; // by DALi
+in vec3 aPosition;
+
+void main()
+{
+ gl_Position = uMvpMatrix * vec4(aPosition * uSize, 1.f);
+}
--- /dev/null
+// Fragment shader for particles, which simulates depth of field using
+// a combination of procedural texturing, alpha testing and alpha blending.
+
+#version 300 es
+
+precision lowp float;
+uniform float uAlphaTestRefValue;
+uniform vec2 uFadeRange; // near, far
+in vec2 vUvUnit;
+flat in float vDepth;
+flat in float vFocalDistance;
+flat in float vOpacity;
+flat in vec3 vColor;
+out vec4 oFragColor;
+
+const float REF_VALUE_THRESHOLD = 1. / 64.;
+
+void main()
+{
+ // Softened disc pattern from normalized UVs
+ float value = 1.f - dot(vUvUnit, vUvUnit);
+
+ // Decrease area of particles 'in-focus'.
+ float refValue = (1.f - vFocalDistance) * .5f;
+ float threshold = REF_VALUE_THRESHOLD * (1.f + vDepth);
+ float alpha = pow(value, vFocalDistance) * smoothstep(refValue - threshold, refValue + threshold, value);
+ if (alpha < uAlphaTestRefValue)
+ {
+ discard;
+ }
+
+ // Apply opacity
+ alpha *= vOpacity;
+ alpha *= alpha;
+
+ // Fade particles out as they get close to the near and far clipping planes
+ alpha *= smoothstep(.0f, uFadeRange.x, vDepth) * smoothstep(1.f, uFadeRange.y, vDepth);
+
+ oFragColor = vec4(vColor, alpha);
+}
--- /dev/null
+// Shader for billboarded particles, where the vertices of the particles
+// are supplied as vec3 position (particle position) + vec2 sub-position.
+
+#version 300 es
+
+precision lowp float;
+uniform mat4 uModelView; // DALi
+uniform mat4 uProjection; // DALi
+uniform vec3 uSize; // DALi
+uniform vec4 uColor; // DALi
+
+uniform vec3 uSecondaryColor;
+uniform vec2 uDepthRange; // x is zNear, y is 1.f / (zFar - zNear)
+uniform float uTwinkleFrequency;
+uniform float uTwinkleSizeScale;
+uniform float uTwinkleOpacityWeight;
+uniform float uTime;
+uniform float uFocalLength;
+uniform float uAperture;
+uniform float uPopulation;
+
+struct Scatter
+{
+ float radiusSqr;
+ float amount;
+ vec3 ray;
+};
+
+const int SCATTER_VARS = 6; // Must match ParticleView::mScatterProps' size.
+uniform Scatter uScatter[SCATTER_VARS];
+
+const int POPULATION_GRANULARITY = 128;
+uniform float uOrderLookUp[POPULATION_GRANULARITY];
+
+in vec3 aPosition;
+in float aSeed;
+in vec4 aPath;
+in vec2 aSubPosition;
+in float aSize;
+
+flat out float vDepth;
+flat out float vFocalDistance;
+out vec2 vUvUnit;
+flat out float vOpacity;
+flat out vec3 vColor; // ignore alpha
+
+float bezier(vec3 control, float alpha)
+{
+ return mix(mix(control.x, control.y, alpha), mix(control.y, control.z, alpha), alpha);
+}
+
+void main() {
+ // Get random order from the look-up table, based on particle ID.
+ int particleId = gl_VertexID / 6;
+ float order = uOrderLookUp[particleId & (POPULATION_GRANULARITY - 1)];
+
+ // Get twinkle scalar
+ float twinkle = sin(uTime * floor(uTwinkleFrequency * aSeed) + fract(aSeed * 1.17137));
+
+ // Add Motion
+ float s = sin(uTime + aSeed) * .5f + .5f; // different phase for all
+ // NOTE: you'd think that taking the bezier() calls apart would save 4 mix() calls, since
+ // the mix()es (of xy / yz / zw / wx) are all calculated twice. It turns out that the MALI
+ // compiler is already doing this; leaving it as is for readability.
+ float bx0 = bezier(aPath.xyz, s);
+ float bx1 = bezier(aPath.zwx, s);
+ float by0 = bezier(aPath.yzw, s);
+ float by1 = bezier(aPath.wxy, s);
+ vec3 motion = vec3(mix(bx0, bx1, s), mix(by0, by1, s), 0.f);
+
+ // Model to view position
+ vec3 position3 = aPosition * uSize + motion;
+
+ vec4 position = uModelView * vec4(position3, 1.f);
+
+ // Add scatter - calculated in view space, using view ray
+ vec3 normalizedPos = position.xyz / uSize;
+ for (int i = 0; i < SCATTER_VARS; ++i)
+ {
+ vec2 scatterDist = (normalizedPos - uScatter[i].ray * dot(uScatter[i].ray, normalizedPos)).xy;
+
+ // NOTE: replacing the division with a multiplication (by inverse) oddly results in more instructions (MALI).
+ float scatter = max(0.f, uScatter[i].radiusSqr - dot(scatterDist, scatterDist)) *
+ uScatter[i].amount / aSize;
+ position.xy += scatter * normalize(scatterDist) * uSize.xy;
+ }
+
+ // Calculate normalised depth and distance from focal plane
+ float depth = (position.z - uDepthRange.x) * uDepthRange.y;
+ vDepth = depth;
+
+ float focalDist = (uFocalLength - depth) * uAperture;
+ focalDist *= focalDist;
+ vFocalDistance = max(focalDist, 1e-6f); // NOTE: was clamp(..., 1.f); side effect: out of focus particles get squashed at higher aperture values.
+
+ // Calculate expiring scale - for size and opacity.
+ float expiringScale = smoothstep(order + 1.f, order, uPopulation);
+
+ // Calculate billboard position and size
+ vec2 subPosition = aSubPosition * aSize *
+ (1.f + twinkle * aSeed * uTwinkleSizeScale) *
+ expiringScale;
+
+ // Insist on hacking the size? Do it here...
+ float sizeHack = depth + .5f;
+ // NOTE: sizeHack *= sizeHack looked slightly better.
+ subPosition *= sizeHack;
+
+ vec3 subPositionView = vec3(subPosition, 0.);
+
+ // Add billboards to view position.
+ position += vec4(subPositionView, 0.f);
+
+ // subPosition doubles as normalized (-1..1) UV.
+ vUvUnit = aSubPosition;
+
+ // Vary opacity (actor alpha) by time as well as expiring scale.
+ vOpacity = uColor.a * expiringScale *
+ (1.0f + aSeed + twinkle * uTwinkleOpacityWeight) / (2.0f + uTwinkleOpacityWeight);
+
+ // Randomize RGB using seed.
+ vec3 mixColor = vec3(fract(aSeed), fract(aSeed * 16.f), fract(aSeed * 256.f));
+ vColor = mix(uColor.rgb, uSecondaryColor, mixColor);
+
+ gl_Position = uProjection * position;
+}
#include <dali-toolkit/dali-toolkit.h>
#include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
#include "shared/utility.h"
+#include "generated/perf-scroll-vert.h"
+#include "generated/perf-scroll-frag.h"
using namespace Dali;
using namespace Dali::Toolkit;
Vector2 texCoord;
};
-// clang-format off
-
-const char* VERTEX_SHADER_TEXTURE = DALI_COMPOSE_SHADER(
- attribute mediump vec2 aPosition;\n
- attribute mediump vec2 aTexCoord;\n
- uniform mediump mat4 uMvpMatrix;\n
- uniform mediump vec3 uSize;\n
- varying mediump vec2 vTexCoord;\n
- void main()\n
- {\n
- vec4 position = vec4(aPosition,0.0,1.0)*vec4(uSize,1.0);\n
- gl_Position = uMvpMatrix * position;\n
- vTexCoord = aTexCoord;\n
- }\n
-);
-
-const char* FRAGMENT_SHADER_TEXTURE = DALI_COMPOSE_SHADER(
- uniform lowp vec4 uColor;\n
- uniform sampler2D sTexture;\n
- varying mediump vec2 vTexCoord;\n
-
- void main()\n
- {\n
- gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
- }\n
-);
-
-// clang-format on
-
bool gUseMesh(false);
bool gNinePatch(false);
unsigned int gRowsPerPage(15);
//Create all the renderers
std::vector<Renderer> renderers(numImages);
- Shader shader = Shader::New(VERTEX_SHADER_TEXTURE, FRAGMENT_SHADER_TEXTURE);
+ Shader shader = Shader::New(SHADER_PERF_SCROLL_VERT, SHADER_PERF_SCROLL_FRAG);
Geometry geometry = DemoHelper::CreateTexturedQuad();
for(unsigned int i(0); i < numImages; ++i)
{
--- /dev/null
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
+}
--- /dev/null
+attribute mediump vec2 aPosition;
+attribute mediump vec2 aTexCoord;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ vec4 position = vec4(aPosition,0.0,1.0)*vec4(uSize,1.0);
+ gl_Position = uMvpMatrix * position;
+ vTexCoord = aTexCoord;
+}
// INTERNAL INCLUDES
#include "shared/utility.h"
#include "shared/view.h"
+#include "generated/point-mesh-vert.h"
+#include "generated/point-mesh-frag.h"
using namespace Dali;
const char* MATERIAL_SAMPLE(DEMO_IMAGE_DIR "gallery-small-48.jpg");
const char* MATERIAL_SAMPLE2(DEMO_IMAGE_DIR "gallery-medium-19.jpg");
-#define MAKE_SHADER(A) #A
-
-const char* VERTEX_SHADER = MAKE_SHADER(
- attribute mediump vec2 aPosition;
- attribute highp float aHue;
- varying mediump vec2 vTexCoord;
- uniform mediump mat4 uMvpMatrix;
- uniform mediump vec3 uSize;
- uniform mediump float uPointSize;
- uniform lowp vec4 uFadeColor;
- varying mediump vec3 vVertexColor;
- varying mediump float vHue;
-
- vec3 hsv2rgb(vec3 c) {
- vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
- vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
- return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
- }
-
- void main() {
- mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
- vertexPosition.xyz *= (uSize - uPointSize);
- vertexPosition = uMvpMatrix * vertexPosition;
- vVertexColor = hsv2rgb(vec3(aHue, 0.7, 1.0));
- vHue = aHue;
- gl_PointSize = uPointSize;
- gl_Position = vertexPosition;
- });
-
-const char* FRAGMENT_SHADER = MAKE_SHADER(
- varying mediump vec3 vVertexColor;
- varying mediump float vHue;
- uniform lowp vec4 uColor;
- uniform sampler2D sTexture1;
- uniform sampler2D sTexture2;
- uniform lowp vec4 uFadeColor;
-
- void main() {
- mediump vec4 texCol1 = texture2D(sTexture1, gl_PointCoord);
- mediump vec4 texCol2 = texture2D(sTexture2, gl_PointCoord);
- gl_FragColor = vec4(vVertexColor, 1.0) * ((texCol1 * vHue) + (texCol2 * (1.0 - vHue)));
- });
-
Geometry CreateGeometry()
{
// Create vertices
Texture texture0 = DemoHelper::LoadTexture(MATERIAL_SAMPLE);
Texture texture1 = DemoHelper::LoadTexture(MATERIAL_SAMPLE2);
- Shader shader = Shader::New(VERTEX_SHADER, FRAGMENT_SHADER);
+ Shader shader = Shader::New(SHADER_POINT_MESH_VERT, SHADER_POINT_MESH_FRAG);
TextureSet textureSet = TextureSet::New();
textureSet.SetTexture(0u, texture0);
--- /dev/null
+varying mediump vec3 vVertexColor;
+varying mediump float vHue;
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture1;
+uniform sampler2D sTexture2;
+uniform lowp vec4 uFadeColor;
+
+void main()
+{
+ mediump vec4 texCol1 = texture2D(sTexture1, gl_PointCoord);
+ mediump vec4 texCol2 = texture2D(sTexture2, gl_PointCoord);
+ gl_FragColor = vec4(vVertexColor, 1.0) * ((texCol1 * vHue) + (texCol2 * (1.0 - vHue)));
+}
--- /dev/null
+attribute mediump vec2 aPosition;
+attribute highp float aHue;
+varying mediump vec2 vTexCoord;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+uniform mediump float uPointSize;
+uniform lowp vec4 uFadeColor;
+varying mediump vec3 vVertexColor;
+varying mediump float vHue;
+
+vec3 hsv2rgb(vec3 c)
+{
+ vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+ vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+ return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+
+void main()
+{
+ mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
+ vertexPosition.xyz *= (uSize - uPointSize);
+ vertexPosition = uMvpMatrix * vertexPosition;
+ vVertexColor = hsv2rgb(vec3(aHue, 0.7, 1.0));
+ vHue = aHue;
+ gl_PointSize = uPointSize;
+ gl_Position = vertexPosition;
+}
#include <map>
#include "gltf-scene.h"
+#include "generated/reflection-vert.h"
+#include "generated/reflection-frag.h"
+#include "generated/reflection-simple-frag.h"
+#include "generated/reflection-textured-frag.h"
+#include "generated/reflection-plasma-frag.h"
+#include "generated/reflection-tex-frag.h"
using namespace Dali;
namespace
{
-// clang-format off
-
-const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
- attribute mediump vec3 aPosition;\n
- attribute mediump vec3 aNormal;\n
- attribute mediump vec2 aTexCoord;\n
- uniform mediump mat4 uMvpMatrix;\n
- uniform mediump mat3 uNormalMatrix;\n
- uniform mediump vec3 uSize;\n
- \n
- varying mediump vec2 vTexCoord; \n
- varying mediump vec3 vNormal; \n
- varying mediump vec3 vPosition; \n
- void main()\n
-{\n
- mediump vec4 vertexPosition = vec4(aPosition, 1.0);\n
- vertexPosition.xyz *= uSize;\n
- vTexCoord = aTexCoord;\n
- vNormal = normalize(uNormalMatrix * aNormal);\n
- vPosition = aPosition; \n
- gl_Position = uMvpMatrix * vertexPosition;\n
-}\n
-);
-
-const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
- uniform lowp vec4 uColor;\n
- uniform sampler2D sTexture; \n
- varying mediump vec3 vNormal;\n
- varying mediump vec3 vPosition; \n
- varying mediump vec2 vTexCoord; \n
- \n
- void main()\n
-{\n
- gl_FragColor = texture2D(sTexture, vTexCoord) * 50.0;\n
-}\n
-);
-
-const char* FRAGMENT_SIMPLE_SHADER = DALI_COMPOSE_SHADER(
- uniform lowp vec4 uColor;\n
- uniform sampler2D sTexture; \n
- varying mediump vec3 vNormal;\n
- varying mediump vec3 vPosition; \n
- varying mediump vec2 vTexCoord; \n
- \n
- void main()\n
-{\n
- gl_FragColor = texture2D(sTexture, vTexCoord) * 2.0;\n
-}\n
-);
-
-const char* TEXTURED_FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
- uniform lowp vec4 uColor;\n
- uniform sampler2D sTexture; \n
- uniform mediump vec2 uScreenSize;\n
-
- uniform mediump vec3 eyePos;\n
- uniform mediump vec3 lightDir;\n
-
- varying mediump vec3 vNormal;\n
- varying mediump vec3 vPosition; \n
- varying mediump vec2 vTexCoord; \n
- \n
- void main()\n
-{\n
- mediump vec3 n = normalize( vNormal );\n
- mediump vec3 l = normalize( lightDir );\n
- mediump vec3 e = normalize( eyePos );\n
- mediump float intensity = max(dot(n,l), 0.0);\n
- gl_FragColor = texture2D(sTexture, vTexCoord) * intensity;\n
-}\n
-);
-
-const char* PLASMA_FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
- precision mediump float;\n
- uniform sampler2D sTexture; \n
-
- uniform float uTime;
- uniform float uKFactor;
- uniform mediump vec3 eyePos;\n
- uniform mediump vec3 lightDir;\n
- varying mediump vec3 vNormal;\n
- varying mediump vec3 vPosition; \n
- varying mediump vec2 vTexCoord; \n
- \n
- void main()\n
-{\n
- mediump vec3 n = normalize( vNormal );\n
- mediump vec3 l = normalize( lightDir );\n
- mediump vec3 e = normalize( eyePos );\n
- mediump float intensity = max(dot(n,l), 0.0);\n
-\n
- const mediump float PI = 3.1415926535897932384626433832795;\n
- mediump float v = 0.0;\n
- mediump vec2 c = vTexCoord * uKFactor - uKFactor/2.0;\n
- v += sin((c.x+uTime));\n
- v += sin((c.y+uTime)/2.0);\n
- v += sin((c.x+c.y+uTime)/2.0);\n
- c += uKFactor/2.0 * vec2(sin(uTime/3.0), cos(uTime/2.0));\n
- v += sin(sqrt(c.x*c.x+c.y*c.y+1.0)+uTime);\n
- v = v/2.0;\n
- mediump vec3 col = vec3(1, sin(PI*v), cos(PI*v));\n
- gl_FragColor = (texture2D(sTexture, vTexCoord)) * (((col.r+col.g+col.b)/3.0)+1.0+intensity);\n
-}\n
-);
-
-const char* TEX_FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
- uniform lowp vec4 uColor;\n
- uniform sampler2D sTexture0; \n
- uniform sampler2D sTexture1; \n
- uniform mediump vec3 eyePos;\n
- uniform mediump vec3 lightDir;\n
- uniform mediump vec2 uScreenSize;\n
- varying mediump vec3 vNormal;\n
- varying mediump vec3 vPosition; \n
- varying mediump vec2 vTexCoord; \n
- \n
-
- mediump float rand(mediump vec2 co){\n
- return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);\n
- }\n
- \n
- void main()\n
-{\n
- mediump vec2 tx = (gl_FragCoord.xy / uScreenSize.xy);\n
- mediump vec3 n = normalize( vNormal );\n
- mediump vec3 l = normalize( lightDir );\n
- mediump vec3 e = normalize( eyePos );\n
- mediump float factor = gl_FragCoord.y / uScreenSize.y;\n
- mediump float intensity = max(dot(n,l), 0.0);\n
- mediump vec2 uv = tx;\n
- gl_FragColor = ((texture2D(sTexture0, vTexCoord) * factor ) + \n
- (texture2D(sTexture1, uv))) * intensity;\n
-}\n
-);
-// clang-format on
struct Model
{
// change shader to use texture if material indicates that
if(mesh->material != 0xffffffff && gltf->GetMaterials()[mesh->material].pbrMetallicRoughness.enabled)
{
- models.emplace_back(CreateModel(*gltf, mesh, VERTEX_SHADER, TEXTURED_FRAGMENT_SHADER));
+ models.emplace_back(CreateModel(*gltf, mesh, SHADER_REFLECTION_VERT.data(), SHADER_REFLECTION_TEXTURED_FRAG.data()));
}
else
{
- models.emplace_back(CreateModel(*gltf, mesh, VERTEX_SHADER, FRAGMENT_SHADER));
+ models.emplace_back(CreateModel(*gltf, mesh, SHADER_REFLECTION_VERT.data(), SHADER_REFLECTION_FRAG.data()));
}
}
}
auto planeActor = mLayer3D.FindChildByName("Plane");
auto solarActor = mLayer3D.FindChildByName("solar_root");
auto backgroundActor = mLayer3D.FindChildByName("background");
- ReplaceShader(backgroundActor, VERTEX_SHADER, FRAGMENT_SIMPLE_SHADER);
+ ReplaceShader(backgroundActor, SHADER_REFLECTION_VERT.data(), SHADER_REFLECTION_SIMPLE_FRAG.data());
mCenterActor = mLayer3D.FindChildByName("center");
mCenterHorizActor = mLayer3D.FindChildByName("center2");
// Prepare Sun
auto sun = mLayer3D.FindChildByName("sun");
- ReplaceShader(sun, VERTEX_SHADER, PLASMA_FRAGMENT_SHADER);
+ ReplaceShader(sun, SHADER_REFLECTION_VERT.data(), SHADER_REFLECTION_PLASMA_FRAG.data());
mSunTimeUniformIndex = sun.RegisterProperty("uTime", 0.0f);
mSunKFactorUniformIndex = sun.RegisterProperty("uKFactor", 0.0f);
// Milkyway
auto milkyway = mLayer3D.FindChildByName("milkyway");
- ReplaceShader(milkyway, VERTEX_SHADER, FRAGMENT_SHADER);
+ ReplaceShader(milkyway, SHADER_REFLECTION_VERT.data(), SHADER_REFLECTION_FRAG.data());
auto renderTaskSourceActor = mLayer3D.FindChildByName("RenderTaskSource");
/**
* Change shader to textured
*/
- Shader texShader = CreateShader(VERTEX_SHADER, TEX_FRAGMENT_SHADER);
+ Shader texShader = CreateShader(SHADER_REFLECTION_VERT.data(), SHADER_REFLECTION_TEX_FRAG.data());
planeActor.RegisterProperty("uScreenSize", Vector2(windowWidth, windowHeight));
auto renderer = planeActor.GetRendererAt(0);
auto textureSet = renderer.GetTextures();
--- /dev/null
+precision mediump float;
+uniform sampler2D sTexture;
+
+uniform float uTime;
+uniform float uKFactor;
+uniform mediump vec3 eyePos;
+uniform mediump vec3 lightDir;
+varying mediump vec3 vNormal;
+varying mediump vec3 vPosition;
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ mediump vec3 n = normalize( vNormal );
+ mediump vec3 l = normalize( lightDir );
+ mediump vec3 e = normalize( eyePos );
+ mediump float intensity = max(dot(n,l), 0.0);
+
+ const mediump float PI = 3.1415926535897932384626433832795;
+ mediump float v = 0.0;
+ mediump vec2 c = vTexCoord * uKFactor - uKFactor/2.0;
+ v += sin((c.x+uTime));
+ v += sin((c.y+uTime)/2.0);
+ v += sin((c.x+c.y+uTime)/2.0);
+ c += uKFactor/2.0 * vec2(sin(uTime/3.0), cos(uTime/2.0));
+ v += sin(sqrt(c.x*c.x+c.y*c.y+1.0)+uTime);
+ v = v/2.0;
+ mediump vec3 col = vec3(1, sin(PI*v), cos(PI*v));
+ gl_FragColor = (texture2D(sTexture, vTexCoord)) * (((col.r+col.g+col.b)/3.0)+1.0+intensity);
+}
--- /dev/null
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+varying mediump vec3 vNormal;
+varying mediump vec3 vPosition;
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ gl_FragColor = texture2D(sTexture, vTexCoord) * 2.0;
+}
--- /dev/null
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture0;
+uniform sampler2D sTexture1;
+uniform mediump vec3 eyePos;
+uniform mediump vec3 lightDir;
+uniform mediump vec2 uScreenSize;
+varying mediump vec3 vNormal;
+varying mediump vec3 vPosition;
+varying mediump vec2 vTexCoord;
+
+mediump float rand(mediump vec2 co)
+{
+ return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+}
+
+void main()
+{
+ mediump vec2 tx = (gl_FragCoord.xy / uScreenSize.xy);
+ mediump vec3 n = normalize( vNormal );
+ mediump vec3 l = normalize( lightDir );
+ mediump vec3 e = normalize( eyePos );
+ mediump float factor = gl_FragCoord.y / uScreenSize.y;
+ mediump float intensity = max(dot(n,l), 0.0);
+ mediump vec2 uv = tx;
+ gl_FragColor = ((texture2D(sTexture0, vTexCoord) * factor ) +
+ (texture2D(sTexture1, uv))) * intensity;
+}
--- /dev/null
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+uniform mediump vec2 uScreenSize;
+
+uniform mediump vec3 eyePos;
+uniform mediump vec3 lightDir;
+
+varying mediump vec3 vNormal;
+varying mediump vec3 vPosition;
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ mediump vec3 n = normalize( vNormal );
+ mediump vec3 l = normalize( lightDir );
+ mediump vec3 e = normalize( eyePos );
+ mediump float intensity = max(dot(n,l), 0.0);
+ gl_FragColor = texture2D(sTexture, vTexCoord) * intensity;
+}
--- /dev/null
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+varying mediump vec3 vNormal;
+varying mediump vec3 vPosition;
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ gl_FragColor = texture2D(sTexture, vTexCoord) * 50.0;
+}
--- /dev/null
+attribute mediump vec3 aPosition;
+attribute mediump vec3 aNormal;
+attribute mediump vec2 aTexCoord;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump mat3 uNormalMatrix;
+uniform mediump vec3 uSize;
+
+varying mediump vec2 vTexCoord;
+varying mediump vec3 vNormal;
+varying mediump vec3 vPosition;
+
+void main()
+{
+ mediump vec4 vertexPosition = vec4(aPosition, 1.0);
+ vertexPosition.xyz *= uSize;
+ vTexCoord = aTexCoord;
+ vNormal = normalize(uNormalMatrix * aNormal);
+ vPosition = aPosition;
+ gl_Position = uMvpMatrix * vertexPosition;
+}
\ No newline at end of file
// INTERNAL INCLUDES
#include "shared/utility.h"
#include "shared/view.h"
+#include "generated/refraction-effect-flat-vert.h"
+#include "generated/refraction-effect-flat-frag.h"
+#include "generated/refraction-effect-refraction-vert.h"
+#include "generated/refraction-effect-refraction-frag.h"
using namespace Dali;
}
};
-/************************************************************************************************
- *** The shader source is used when the MeshActor is not touched***
- ************************************************************************************************/
-// clang-format off
-const char* VERTEX_SHADER_FLAT = DALI_COMPOSE_SHADER(
-attribute mediump vec3 aPosition;\n
-attribute mediump vec3 aNormal;\n
-attribute highp vec2 aTexCoord;\n
-uniform mediump mat4 uMvpMatrix;\n
-varying mediump vec2 vTexCoord;\n
-void main()\n
-{\n
- gl_Position = uMvpMatrix * vec4( aPosition.xy, 0.0, 1.0 );\n
- vTexCoord = aTexCoord.xy;\n
-}\n
-);
-
-const char* FRAGMENT_SHADER_FLAT = DALI_COMPOSE_SHADER(
-uniform lowp vec4 uColor;\n
-uniform sampler2D sTexture;\n
-varying mediump vec2 vTexCoord;\n
-void main()\n
-{\n
- gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
-}\n
-);
-
-/************************************************************
- ** Custom refraction effect shader***************************
- ************************************************************/
-const char* VERTEX_SHADER_REFRACTION = DALI_COMPOSE_SHADER(
-attribute mediump vec3 aPosition;\n
-attribute mediump vec3 aNormal;\n
-attribute highp vec2 aTexCoord;\n
-uniform mediump mat4 uMvpMatrix;\n
-varying mediump vec4 vVertex;\n
-varying mediump vec3 vNormal;\n
-varying mediump vec2 vTexCoord;\n
-varying mediump vec2 vTextureOffset;\n
-void main()\n
-{\n
- gl_Position = uMvpMatrix * vec4( aPosition.xy, 0.0, 1.0 );\n
- vTexCoord = aTexCoord.xy;\n
-
- vNormal = aNormal;\n
- vVertex = vec4( aPosition, 1.0 );\n
- float length = max(0.01, length(aNormal.xy)) * 40.0;\n
- vTextureOffset = aNormal.xy / length;\n
-}\n
-);
-
-const char* FRAGMENT_SHADER_REFRACTION = DALI_COMPOSE_SHADER(
-precision mediump float;\n
-uniform mediump float uEffectStrength;\n
-uniform mediump vec3 uLightPosition;\n
-uniform mediump vec2 uLightXYOffset;\n
-uniform mediump vec2 uLightSpinOffset;\n
-uniform mediump float uLightIntensity;\n
-uniform lowp vec4 uColor;\n
-uniform sampler2D sTexture;\n
-varying mediump vec4 vVertex;\n
-varying mediump vec3 vNormal;\n
-varying mediump vec2 vTexCoord;\n
-varying mediump vec2 vTextureOffset;\n
-
-vec3 rgb2hsl(vec3 rgb)\n
-{\n
- float epsilon = 1.0e-10;\n
- vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);\n
- vec4 P = mix(vec4(rgb.bg, K.wz), vec4(rgb.gb, K.xy), step(rgb.b, rgb.g));\n
- vec4 Q = mix(vec4(P.xyw, rgb.r), vec4(rgb.r, P.yzx), step(P.x, rgb.r));\n
- \n
- // RGB -> HCV
- float value = Q.x;\n
- float chroma = Q.x - min(Q.w, Q.y);\n
- float hue = abs(Q.z + (Q.w-Q.y) / (6.0*chroma+epsilon));\n
- // HCV -> HSL
- float lightness = value - chroma*0.5;\n
- return vec3( hue, chroma/max( 1.0-abs(lightness*2.0-1.0), 1.0e-1 ), lightness );\n
-}\n
-
-vec3 hsl2rgb( vec3 hsl )\n
-{\n
- // pure hue->RGB
- vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n
- vec3 p = abs(fract(hsl.xxx + K.xyz) * 6.0 - K.www);\n
- vec3 RGB = clamp(p - K.xxx, 0.0, 1.0);\n
- \n
- float chroma = ( 1.0 - abs( hsl.z*2.0-1.0 ) ) * hsl.y;\n
- return ( RGB - 0.5 ) * chroma + hsl.z;\n
-}\n
-
-void main()\n
-{\n
- vec3 normal = normalize( vNormal);\n
-
- vec3 lightPosition = uLightPosition + vec3(uLightXYOffset+uLightSpinOffset, 0.0);\n
- mediump vec3 vecToLight = normalize( (lightPosition - vVertex.xyz) * 0.01 );\n
- mediump float spotEffect = pow( max(0.05, vecToLight.z ) - 0.05, 8.0);\n
-
- spotEffect = spotEffect * uEffectStrength;\n
- mediump float lightDiffuse = ( ( dot( vecToLight, normal )-0.75 ) *uLightIntensity ) * spotEffect;\n
-
- lowp vec4 color = texture2D( sTexture, vTexCoord + vTextureOffset * spotEffect );\n
- vec3 lightedColor = hsl2rgb( rgb2hsl(color.rgb) + vec3(0.0,0.0,lightDiffuse) );\n
-
- gl_FragColor = vec4( lightedColor, color.a ) * uColor;\n
-}\n
-);
-// clang-format on
-
} // namespace
/*************************************************/
DemoHelper::DEFAULT_MODE_SWITCH_PADDING);
// shader used when the screen is not touched, render a flat surface
- mShaderFlat = Shader::New(VERTEX_SHADER_FLAT, FRAGMENT_SHADER_FLAT);
+ mShaderFlat = Shader::New(SHADER_REFRACTION_EFFECT_FLAT_VERT, SHADER_REFRACTION_EFFECT_FLAT_FRAG);
mGeometry = CreateGeometry(MESH_FILES[mCurrentMeshId]);
Texture texture = DemoHelper::LoadWindowFillingTexture(window.GetSize(), TEXTURE_IMAGES[mCurrentTextureId]);
mContent.TouchedSignal().Connect(this, &RefractionEffectExample::OnTouch);
// shader used when the finger is touching the screen. render refraction effect
- mShaderRefraction = Shader::New(VERTEX_SHADER_REFRACTION, FRAGMENT_SHADER_REFRACTION);
+ mShaderRefraction = Shader::New(SHADER_REFRACTION_EFFECT_REFRACTION_VERT, SHADER_REFRACTION_EFFECT_REFRACTION_FRAG);
// register uniforms
mLightXYOffsetIndex = mMeshActor.RegisterProperty("uLightXYOffset", Vector2::ZERO);
--- /dev/null
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
+}
--- /dev/null
+// The shader source is used when the MeshActor is not touched
+
+attribute mediump vec3 aPosition;
+attribute mediump vec3 aNormal;
+attribute highp vec2 aTexCoord;
+uniform mediump mat4 uMvpMatrix;
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ gl_Position = uMvpMatrix * vec4( aPosition.xy, 0.0, 1.0 );
+ vTexCoord = aTexCoord.xy;
+}
--- /dev/null
+precision mediump float;
+uniform mediump float uEffectStrength;
+uniform mediump vec3 uLightPosition;
+uniform mediump vec2 uLightXYOffset;
+uniform mediump vec2 uLightSpinOffset;
+uniform mediump float uLightIntensity;
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+varying mediump vec4 vVertex;
+varying mediump vec3 vNormal;
+varying mediump vec2 vTexCoord;
+varying mediump vec2 vTextureOffset;
+
+vec3 rgb2hsl(vec3 rgb)
+{
+ float epsilon = 1.0e-10;
+ vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+ vec4 P = mix(vec4(rgb.bg, K.wz), vec4(rgb.gb, K.xy), step(rgb.b, rgb.g));
+ vec4 Q = mix(vec4(P.xyw, rgb.r), vec4(rgb.r, P.yzx), step(P.x, rgb.r));
+
+ // RGB -> HCV
+ float value = Q.x;
+ float chroma = Q.x - min(Q.w, Q.y);
+ float hue = abs(Q.z + (Q.w-Q.y) / (6.0*chroma+epsilon));
+ // HCV -> HSL
+ float lightness = value - chroma*0.5;
+ return vec3( hue, chroma/max( 1.0-abs(lightness*2.0-1.0), 1.0e-1 ), lightness );
+}
+
+vec3 hsl2rgb( vec3 hsl )
+{
+ // pure hue->RGB
+ vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+ vec3 p = abs(fract(hsl.xxx + K.xyz) * 6.0 - K.www);
+ vec3 RGB = clamp(p - K.xxx, 0.0, 1.0);
+
+ float chroma = ( 1.0 - abs( hsl.z*2.0-1.0 ) ) * hsl.y;
+ return ( RGB - 0.5 ) * chroma + hsl.z;
+}
+
+void main()
+{
+ vec3 normal = normalize( vNormal);
+
+ vec3 lightPosition = uLightPosition + vec3(uLightXYOffset+uLightSpinOffset, 0.0);
+ mediump vec3 vecToLight = normalize( (lightPosition - vVertex.xyz) * 0.01 );
+ mediump float spotEffect = pow( max(0.05, vecToLight.z ) - 0.05, 8.0);
+
+ spotEffect = spotEffect * uEffectStrength;
+ mediump float lightDiffuse = ( ( dot( vecToLight, normal )-0.75 ) *uLightIntensity ) * spotEffect;
+
+ lowp vec4 color = texture2D( sTexture, vTexCoord + vTextureOffset * spotEffect );
+ vec3 lightedColor = hsl2rgb( rgb2hsl(color.rgb) + vec3(0.0,0.0,lightDiffuse) );
+
+ gl_FragColor = vec4( lightedColor, color.a ) * uColor;
+}
--- /dev/null
+attribute mediump vec3 aPosition;
+attribute mediump vec3 aNormal;
+attribute highp vec2 aTexCoord;
+uniform mediump mat4 uMvpMatrix;
+varying mediump vec4 vVertex;
+varying mediump vec3 vNormal;
+varying mediump vec2 vTexCoord;
+varying mediump vec2 vTextureOffset;
+
+void main()
+{
+ gl_Position = uMvpMatrix * vec4( aPosition.xy, 0.0, 1.0 );
+ vTexCoord = aTexCoord.xy;
+
+ vNormal = aNormal;
+ vVertex = vec4( aPosition, 1.0 );
+ float length = max(0.01, length(aNormal.xy)) * 40.0;
+ vTextureOffset = aNormal.xy / length;
+}
*/
// EXTERNAL INCLUDES
+#include <dali/public-api/rendering/shader.h>
#include <dali-toolkit/dali-toolkit.h>
// INTERNAL INCLUDES
-#include "renderer-stencil-shaders.h"
#include "shared/utility.h"
#include "shared/view.h"
+#include "generated/render-stencil-vert.h"
+#include "generated/render-stencil-frag.h"
+#include "generated/render-stencil-textured-vert.h"
+#include "generated/render-stencil-textured-frag.h"
using namespace Dali;
// We need to control the draw order as we are controlling both the stencil and depth buffer per renderer.
const int DEPTH_INDEX_GRANULARITY(10000); ///< This value is the gap in depth-index in-between each renderer.
+// Shader uniforms:
+const char* const COLOR_UNIFORM_NAME("uColor");
+const char* const OBJECT_DIMENSIONS_UNIFORM_NAME("uObjectDimensions");
+const char* const LIGHT_POSITION_UNIFORM_NAME = "uLightPosition";
+const char* const POSITION("aPosition");
+const char* const NORMAL("aNormal");
+const char* const TEXTURE("aTexCoord");
+
} // Anonymous namespace
/**
if(textured)
{
- shader = Shader::New(VERTEX_SHADER_TEXTURED, FRAGMENT_SHADER_TEXTURED);
+ shader = Shader::New(SHADER_RENDER_STENCIL_TEXTURED_VERT, SHADER_RENDER_STENCIL_TEXTURED_FRAG);
}
else
{
- shader = Shader::New(VERTEX_SHADER, FRAGMENT_SHADER);
+ shader = Shader::New(SHADER_RENDER_STENCIL_VERT, SHADER_RENDER_STENCIL_FRAG);
}
// Here we modify the light position based on half the window size as a pre-calculation step.
+++ /dev/null
-#ifndef DALI_DEMO_RENDERER_STENCIL_SHADERS_H
-#define DALI_DEMO_RENDERER_STENCIL_SHADERS_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.
- */
-
-// EXTERNAL INCLUDES
-#include <dali/public-api/rendering/shader.h>
-
-// Shader uniforms:
-const char* const COLOR_UNIFORM_NAME("uColor");
-const char* const OBJECT_DIMENSIONS_UNIFORM_NAME("uObjectDimensions");
-const char* const LIGHT_POSITION_UNIFORM_NAME = "uLightPosition";
-const char* const POSITION("aPosition");
-const char* const NORMAL("aNormal");
-const char* const TEXTURE("aTexCoord");
-
-// clang-format off
-
-// Shader for basic, per-vertex lighting (vertex):
-const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
- attribute mediump vec3 aPosition;
- attribute highp vec3 aNormal;
- attribute highp vec2 aTexCoord;
-
- varying mediump vec2 vTexCoord;
- uniform mediump mat4 uMvpMatrix;
- uniform mediump vec3 uSize;
- uniform mediump vec3 uObjectDimensions;
- varying mediump vec3 vIllumination;
- uniform mediump mat4 uModelView;
- uniform mediump mat4 uViewMatrix;
- uniform mediump mat3 uNormalMatrix;
- uniform mediump vec3 uLightPosition;
-
- void main()
- {
- mediump vec4 vertexPosition = vec4( aPosition * uObjectDimensions, 1.0 );
- vertexPosition = uMvpMatrix * vertexPosition;
-
- vec4 mvVertexPosition = uModelView * vertexPosition;
-
- vec3 vectorToLight = normalize( mat3( uViewMatrix ) * uLightPosition - mvVertexPosition.xyz );
-
- vec3 normal = uNormalMatrix * aNormal;
- float lightDiffuse = max( dot( vectorToLight, normal ), 0.0 );
- vIllumination = vec3( lightDiffuse * 0.5 + 0.5 );
-
- gl_Position = vertexPosition;
- }
-);
-
-// Fragment shader.
-const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
- varying mediump vec2 vTexCoord;
- varying mediump vec3 vIllumination;
- uniform lowp vec4 uColor;
- uniform sampler2D sTexture;
-
- void main()
- {
- gl_FragColor = vec4( vIllumination.rgb * uColor.rgb, uColor.a );
- }
-);
-
-// Shader for basic, per-vertex lighting with texture (vertex):
-const char* VERTEX_SHADER_TEXTURED = DALI_COMPOSE_SHADER(
- attribute mediump vec3 aPosition;
- attribute highp vec3 aNormal;
- attribute highp vec2 aTexCoord;
-
- varying mediump vec2 vTexCoord;
- uniform mediump mat4 uMvpMatrix;
- uniform mediump vec3 uSize;
- uniform mediump vec3 uObjectDimensions;
- varying mediump vec3 vIllumination;
- uniform mediump mat4 uModelView;
- uniform mediump mat4 uViewMatrix;
- uniform mediump mat3 uNormalMatrix;
- uniform mediump vec3 uLightPosition;
-
- void main()
- {
- mediump vec4 vertexPosition = vec4( aPosition * uObjectDimensions, 1.0 );
- vertexPosition = uMvpMatrix * vertexPosition;
-
- vec4 mvVertexPosition = uModelView * vertexPosition;
-
- vec3 vectorToLight = normalize( mat3( uViewMatrix ) * uLightPosition - mvVertexPosition.xyz );
-
- vec3 normal = uNormalMatrix * aNormal;
- float lightDiffuse = max( dot( vectorToLight, normal ), 0.0 );
- vIllumination = vec3( lightDiffuse * 0.5 + 0.5 );
-
- vTexCoord = aTexCoord;
- gl_Position = vertexPosition;
- }
-);
-
-// Fragment shader.
-const char* FRAGMENT_SHADER_TEXTURED = DALI_COMPOSE_SHADER(
- varying mediump vec2 vTexCoord;
- varying mediump vec3 vIllumination;
- uniform lowp vec4 uColor;
- uniform sampler2D sTexture;
-
- void main()
- {
- gl_FragColor = vec4( texture2D( sTexture, vTexCoord ).rgb * vIllumination.rgb * uColor.rgb, uColor.a );
- }
-);
-
-// clang-format on
-
-#endif // DALI_DEMO_RENDERER_STENCIL_SHADERS_H
--- /dev/null
+varying mediump vec2 vTexCoord;
+varying mediump vec3 vIllumination;
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+
+void main()
+{
+ gl_FragColor = vec4( texture2D( sTexture, vTexCoord ).rgb * vIllumination.rgb * uColor.rgb, uColor.a );
+}
--- /dev/null
+// Shader for basic, per-vertex lighting with texture (vertex):
+
+attribute mediump vec3 aPosition;
+attribute highp vec3 aNormal;
+attribute highp vec2 aTexCoord;
+
+varying mediump vec2 vTexCoord;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+uniform mediump vec3 uObjectDimensions;
+varying mediump vec3 vIllumination;
+uniform mediump mat4 uModelView;
+uniform mediump mat4 uViewMatrix;
+uniform mediump mat3 uNormalMatrix;
+uniform mediump vec3 uLightPosition;
+
+void main()
+{
+ mediump vec4 vertexPosition = vec4( aPosition * uObjectDimensions, 1.0 );
+ vertexPosition = uMvpMatrix * vertexPosition;
+
+ vec4 mvVertexPosition = uModelView * vertexPosition;
+
+ vec3 vectorToLight = normalize( mat3( uViewMatrix ) * uLightPosition - mvVertexPosition.xyz );
+
+ vec3 normal = uNormalMatrix * aNormal;
+ float lightDiffuse = max( dot( vectorToLight, normal ), 0.0 );
+ vIllumination = vec3( lightDiffuse * 0.5 + 0.5 );
+
+ vTexCoord = aTexCoord;
+ gl_Position = vertexPosition;
+}
--- /dev/null
+varying mediump vec2 vTexCoord;
+varying mediump vec3 vIllumination;
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+
+void main()
+{
+ gl_FragColor = vec4( vIllumination.rgb * uColor.rgb, uColor.a );
+}
--- /dev/null
+// Shader for basic, per-vertex lighting (vertex):
+
+attribute mediump vec3 aPosition;
+attribute highp vec3 aNormal;
+attribute highp vec2 aTexCoord;
+
+varying mediump vec2 vTexCoord;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+uniform mediump vec3 uObjectDimensions;
+varying mediump vec3 vIllumination;
+uniform mediump mat4 uModelView;
+uniform mediump mat4 uViewMatrix;
+uniform mediump mat3 uNormalMatrix;
+uniform mediump vec3 uLightPosition;
+
+void main()
+{
+ mediump vec4 vertexPosition = vec4( aPosition * uObjectDimensions, 1.0 );
+ vertexPosition = uMvpMatrix * vertexPosition;
+
+ vec4 mvVertexPosition = uModelView * vertexPosition;
+
+ vec3 vectorToLight = normalize( mat3( uViewMatrix ) * uLightPosition - mvVertexPosition.xyz );
+
+ vec3 normal = uNormalMatrix * aNormal;
+ float lightDiffuse = max( dot( vectorToLight, normal ), 0.0 );
+ vIllumination = vec3( lightDiffuse * 0.5 + 0.5 );
+
+ gl_Position = vertexPosition;
+}
#include <dali-toolkit/dali-toolkit.h>
#include <dali/dali.h>
+#include "generated/rendering-basic-light-vert.h"
+#include "generated/rendering-basic-light-frag.h"
+
using namespace Dali;
using namespace Toolkit;
int MaterialID = 0;
-// clang-format off
-
-/*
- * Vertex shader
- */
-const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
-attribute mediump vec3 aPosition;\n // DALi shader builtin
-attribute mediump vec3 aNormal;\n // DALi shader builtin
-uniform mediump mat4 uMvpMatrix;\n // DALi shader builtin
-uniform mediump vec3 uSize;\n // DALi shader builtin
-uniform mediump mat4 uModelView;\n // DALi shader builtin
-uniform mediump mat3 uNormalMatrix;\n // DALi shader builtin
-\n
-varying mediump vec3 vNormal;\n
-varying mediump vec3 vFragPos;\n
-\n
-void main()\n
-{\n
- mediump vec4 vertexPosition = vec4(aPosition, 1.0);\n
- vertexPosition.xyz *= uSize;\n
- vFragPos = vec3(uModelView * vertexPosition);\n
- vNormal = uNormalMatrix * aNormal;\n
- \n
- gl_Position = uMvpMatrix * vertexPosition;\n
-}\n
-);
-
-/*
- * Fragment shader
- */
-const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
-varying mediump vec3 vNormal;\n
-varying mediump vec3 vFragPos;\n
-uniform mediump vec3 viewPos;\n // custom uniform
-\n
-struct Material {\n
- mediump vec3 ambient;\n
- mediump vec3 diffuse;\n
- mediump vec3 specular;\n
- mediump float shininess;\n
-};\n
-struct Light {\n
- mediump vec3 position;\n
- mediump vec3 color;\n
-};\n
-uniform Material material;\n // custom uniform
-uniform Light light;\n // custom uniform
-\n
-void main()\n
-{\n
-\n // Ambient
- mediump vec3 ambient = material.ambient * light.color;\n
-\n // Diffuse
- mediump vec3 norm = normalize(vNormal);\n
- mediump vec3 lightDir = normalize(light.position - vFragPos);\n
- mediump float diff = max(dot(norm, lightDir), 0.0);\n
- mediump vec3 diffuse = material.diffuse * diff * light.color;\n
- \n
-\n // Specular
- mediump vec3 viewDir = normalize(viewPos - vFragPos);\n
- mediump vec3 reflectDir = reflect(-lightDir, norm); \n
- mediump float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);\n
- mediump vec3 specular = material.specular * spec * light.color; \n
- mediump vec3 result = (ambient + diffuse + specular);\n
- gl_FragColor = vec4(result, 1.0);\n
-}\n
-);
-// clang-format on
-
} // namespace
// This example shows per-pixel lighting of materials with different ambient, diffuse, specular and shininess parameters
}
/**
- * Creates a shader using inlined variable VERTEX_SHADER and FRAGMENT_SHADER
+ * Creates a shader using inlined variable SHADER_RENDERING_BASIC_LIGHT_VERT and SHADER_RENDERING_BASIC_LIGHT_FRAG
*
* Shaders are very basic and all they do is transforming vertices and interpolating
* input per-vertex color.
*/
void CreateCubeShader()
{
- mShader = Shader::New(VERTEX_SHADER, FRAGMENT_SHADER);
+ mShader = Shader::New(SHADER_RENDERING_BASIC_LIGHT_VERT, SHADER_RENDERING_BASIC_LIGHT_FRAG);
float scale = 120.0f;
mShader.RegisterProperty("light.position", Vector3(1.2 * scale, scale, 2.0 * scale));
--- /dev/null
+varying mediump vec3 vNormal;
+varying mediump vec3 vFragPos;
+uniform mediump vec3 viewPos; // custom uniform
+
+struct Material
+{
+ mediump vec3 ambient;
+ mediump vec3 diffuse;
+ mediump vec3 specular;
+ mediump float shininess;
+};
+
+struct Light
+{
+ mediump vec3 position;
+ mediump vec3 color;
+};
+
+uniform Material material; // custom uniform
+uniform Light light; // custom uniform
+
+void main()
+{
+ // Ambient
+ mediump vec3 ambient = material.ambient * light.color;
+ // Diffuse
+ mediump vec3 norm = normalize(vNormal);
+ mediump vec3 lightDir = normalize(light.position - vFragPos);
+ mediump float diff = max(dot(norm, lightDir), 0.0);
+ mediump vec3 diffuse = material.diffuse * diff * light.color;
+
+ // Specular
+ mediump vec3 viewDir = normalize(viewPos - vFragPos);
+ mediump vec3 reflectDir = reflect(-lightDir, norm);
+ mediump float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
+ mediump vec3 specular = material.specular * spec * light.color;
+ mediump vec3 result = (ambient + diffuse + specular);
+ gl_FragColor = vec4(result, 1.0);
+}
--- /dev/null
+attribute mediump vec3 aPosition; // DALi shader builtin
+attribute mediump vec3 aNormal; // DALi shader builtin
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+uniform mediump vec3 uSize; // DALi shader builtin
+uniform mediump mat4 uModelView; // DALi shader builtin
+uniform mediump mat3 uNormalMatrix; // DALi shader builtin
+
+varying mediump vec3 vNormal;
+varying mediump vec3 vFragPos;
+
+void main()
+{
+ mediump vec4 vertexPosition = vec4(aPosition, 1.0);
+ vertexPosition.xyz *= uSize;
+ vFragPos = vec3(uModelView * vertexPosition);
+ vNormal = uNormalMatrix * aNormal;
+
+ gl_Position = uMvpMatrix * vertexPosition;
+}
// INTERNAL INCLUDES
#include "obj-loader.h"
-
-namespace
-{
-// clang-format off
-
-/*
- * Vertex shader for a skybox
- */
-const char* VERTEX_SHADER_SKYBOX = DALI_COMPOSE_SHADER(
-attribute mediump vec3 aPosition;\n // DALi shader builtin
-uniform mediump mat4 uMvpMatrix;\n // DALi shader builtin
-\n
-varying mediump vec3 vTexCoord;\n
-void main()\n
-{\n
- vTexCoord = aPosition;\n
-
- mediump vec4 vertexPosition = vec4(aPosition, 1.0);\n
- vec4 clipSpacePosition = uMvpMatrix * vertexPosition;\n
- gl_Position = clipSpacePosition.xyww;\n // Writes 1.0, the maximum depth value, into the depth buffer.
- // This is an optimization to avoid running the fragment shader
- // for the pixels hidden by the scene's objects.
-}\n
-);
-
-/*
- * Fragment shader for a skybox
- */
-const char* FRAGMENT_SHADER_SKYBOX = DALI_COMPOSE_SHADER(
-uniform samplerCube uSkyBoxTexture;\n
-\n
-varying mediump vec3 vTexCoord;\n
-void main()\n
-{\n
- mediump vec4 texColor = textureCube( uSkyBoxTexture, vTexCoord, 0.0);\n
- gl_FragColor = texColor;\n
-}\n
-);
-// clang-format on
-
-} // namespace
+#include "generated/skybox-vert.h"
+#include "generated/skybox-frag.h"
ModelSkybox::ModelSkybox()
{
void ModelSkybox::Init(const Vector3& size)
{
Geometry geometry = CreateGeometry();
- Shader shader = Shader::New(VERTEX_SHADER_SKYBOX, FRAGMENT_SHADER_SKYBOX);
+ Shader shader = Shader::New(SHADER_SKYBOX_VERT, SHADER_SKYBOX_FRAG);
Renderer renderer = Renderer::New(geometry, shader);
--- /dev/null
+uniform samplerCube uSkyBoxTexture;
+varying mediump vec3 vTexCoord;
+
+void main()
+{
+ mediump vec4 texColor = textureCube( uSkyBoxTexture, vTexCoord, 0.0);
+ gl_FragColor = texColor;
+}
--- /dev/null
+attribute mediump vec3 aPosition; // DALi shader builtin
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+
+varying mediump vec3 vTexCoord;
+void main()
+{
+ vTexCoord = aPosition;
+
+ mediump vec4 vertexPosition = vec4(aPosition, 1.0);
+ vec4 clipSpacePosition = uMvpMatrix * vertexPosition;
+ gl_Position = clipSpacePosition.xyww; // Writes 1.0, the maximum depth value, into the depth buffer.
+ // This is an optimization to avoid running the fragment shader
+ // for the pixels hidden by the scene's objects.
+}
#include <dali-toolkit/dali-toolkit.h>
#include <dali/dali.h>
+#include "generated/rendering-cube-vert.h"
+#include "generated/rendering-cube-frag.h"
+
using namespace Dali;
using namespace Toolkit;
-namespace
-{
-// clang-format off
-
-/*
- * Vertex shader
- */
-const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
-attribute mediump vec3 aPosition;\n // DALi shader builtin
-attribute mediump vec3 aColor;\n // DALi shader builtin
-uniform mediump mat4 uMvpMatrix;\n // DALi shader builtin
-uniform mediump vec3 uSize;\n // DALi shader builtin
-\n
-varying mediump vec4 vColor;\n
-\n
-void main()\n
-{\n
- mediump vec4 vertexPosition = vec4(aPosition, 1.0);\n
- vertexPosition.xyz *= uSize;\n
- vColor = vec4( aColor, 1.0 );\n
- gl_Position = uMvpMatrix * vertexPosition;\n
-}\n
-);
-
-/*
- * Fragment shader
- */
-const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
-varying mediump vec4 vColor;\n
-\n
-void main()\n
-{\n
- gl_FragColor = vColor;\n
-}\n
-);
-// clang-format on
-
-} // namespace
-
// This example shows how to create a cube with colors on each side
//
class DrawCubeController : public ConnectionTracker
}
/**
- * Creates a shader using inlined variable VERTEX_SHADER and FRAGMENT_SHADER
+ * Creates a shader using inlined variable SHADER_RENDERING_CUBE_VERT and SHADER_RENDERING_CUBE_FRAG
*
* Shaders are very basic and all they do is transforming vertices and interpolating
* input per-vertex color.
*/
void CreateCubeShader()
{
- mShader = Shader::New(VERTEX_SHADER, FRAGMENT_SHADER);
+ mShader = Shader::New(SHADER_RENDERING_CUBE_VERT, SHADER_RENDERING_CUBE_FRAG);
}
/**
--- /dev/null
+varying mediump vec4 vColor;
+
+void main()
+{
+ gl_FragColor = vColor;
+}
--- /dev/null
+attribute mediump vec3 aPosition; // DALi shader builtin
+attribute mediump vec3 aColor; // DALi shader builtin
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+uniform mediump vec3 uSize; // DALi shader builtin
+
+varying mediump vec4 vColor;
+
+void main()
+{
+ mediump vec4 vertexPosition = vec4(aPosition, 1.0);
+ vertexPosition.xyz *= uSize;
+ vColor = vec4( aColor, 1.0 );
+ gl_Position = uMvpMatrix * vertexPosition;
+}
#include <dali-toolkit/dali-toolkit.h>
#include <dali/dali.h>
+#include "generated/rendering-line-vert.h"
+#include "generated/rendering-line-frag.h"
+
using namespace Dali;
using namespace Toolkit;
-namespace
-{
-// clang-format off
-
-/*
- * Vertex shader
- */
-const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
-attribute mediump vec2 aPosition;\n // DALi shader builtin
-uniform mediump mat4 uMvpMatrix;\n // DALi shader builtin
-uniform mediump vec3 uSize;\n // DALi shader builtin
-\n
-void main()\n
-{\n
- mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
- vertexPosition.xyz *= uSize;\n
- gl_Position = uMvpMatrix * vertexPosition;\n
-}\n
-);
-
-/*
- * Fragment shader
- */
-const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
-uniform mediump vec4 uColor;\n
-\n
-void main()\n
-{\n
- gl_FragColor = uColor;\n
-}\n
-);
-// clang-format on
-
-} // namespace
-
// This example shows how to draw a line in actor's color
//
class DrawLineController : public ConnectionTracker
}
/**
- * Creates a shader using inlined variable VERTEX_SHADER and FRAGMENT_SHADER
+ * Creates a shader using inlined variable SHADER_RENDERING_LINE_VERT and SHADER_RENDERING_LINE_FRAG
*
* Shaders are very basic and all they do is transforming vertices and applying actor's colour.
*/
void CreateLineShader()
{
- mShader = Shader::New(VERTEX_SHADER, FRAGMENT_SHADER);
+ mShader = Shader::New(SHADER_RENDERING_LINE_VERT, SHADER_RENDERING_LINE_FRAG);
}
/**
--- /dev/null
+uniform mediump vec4 uColor;
+
+void main()
+{
+ gl_FragColor = uColor;
+}
--- /dev/null
+attribute mediump vec2 aPosition; // DALi shader builtin
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+uniform mediump vec3 uSize; // DALi shader builtin
+
+void main()
+{
+ mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
+ vertexPosition.xyz *= uSize;
+ gl_Position = uMvpMatrix * vertexPosition;
+}
#include <dali-toolkit/dali-toolkit.h>
#include <dali/dali.h>
+#include "generated/radial-progress-basic-vert.h"
+#include "generated/radial-progress-basic-frag.h"
+#include "generated/radial-progress-textured-vert.h"
+#include "generated/radial-progress-textured-frag.h"
+
using namespace Dali;
namespace // unnamed namespace
const float INITIAL_DELAY(2.0f); // initial delay before showing the circle
const float PROGRESS_DURATION(0.5f); // number of seconds to fully show the circle
-// clang-format off
-
-/*
- * Vertex shader for textured quad
- */
-const char* VERTEX_SHADER_TEXTURED = DALI_COMPOSE_SHADER(
-attribute mediump vec2 aPosition;\n
-uniform mediump mat4 uMvpMatrix;\n // DALi shader builtin
-uniform mediump vec3 uSize;\n // DALi shader builtin
-\n
-varying mediump vec2 vTexCoord;\n
-void main()\n
-{\n
- mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
- vertexPosition.xyz *= uSize;\n
- vTexCoord = vec2(1.0, 1.0)*(aPosition + vec2(0.5) );\n
- gl_Position = uMvpMatrix * vertexPosition;\n
-}\n
-);
-
-/*
- * Fragment shaderfor textured quad
- */
-const char* FRAGMENT_SHADER_TEXTURED = DALI_COMPOSE_SHADER(
-uniform sampler2D uTexture;\n
-\n
-varying mediump vec2 vTexCoord;\n
-void main()\n
-{\n
- mediump vec4 texColor = texture2D( uTexture, vTexCoord );\n
- gl_FragColor = texColor;\n
-}\n
-);
-
-/*
- * Vertex shader for polygon
- */
-const char* VERTEX_SHADER_BASIC = DALI_COMPOSE_SHADER(
-attribute mediump vec3 aPosition;\n
-uniform mediump mat4 uMvpMatrix;\n // DALi shader builtin
-uniform mediump vec3 uSize;\n // DALi shader builtin
-uniform mediump float uProgress;\n
-\n
-varying mediump vec2 vTexCoord;\n
-void main()\n
-{\n
- mediump vec4 vertexPosition = vec4(aPosition.x, aPosition.y, 0.0, 1.0);\n
-\n
- float index = aPosition.z;\n
- if( uProgress < index )\n
- {\n
- vertexPosition = vec4(0.0, 0.0, 0.0, 1.0);\n
- }\n
-\n
- vertexPosition.xyz *= uSize;\n
- gl_Position = uMvpMatrix * vertexPosition;\n
-}\n
-);
-
-/*
- * Fragment shader for polygon
- */
-const char* FRAGMENT_SHADER_BASIC = DALI_COMPOSE_SHADER(
-
-void main()\n
-{\n
- gl_FragColor = vec4( 1.0, 1.0, 1.0, 1.0 );\n
-}\n
-);
-// clang-format on
-
} // unnamed namespace
// This example shows how to render a radial progress indicator
geometry.AddVertexBuffer(vertexBuffer);
geometry.SetType(Geometry::TRIANGLE_FAN);
- Shader shader = Shader::New(VERTEX_SHADER_BASIC, FRAGMENT_SHADER_BASIC);
+ Shader shader = Shader::New(SHADER_RADIAL_PROGRESS_BASIC_VERT, SHADER_RADIAL_PROGRESS_BASIC_FRAG);
Renderer renderer = Renderer::New(geometry, shader);
// Setting stencil data. We don't want to render to the color buffer so
{
// Create shader & geometry needed by Renderer
- Shader shader = Shader::New(VERTEX_SHADER_TEXTURED, FRAGMENT_SHADER_TEXTURED);
+ Shader shader = Shader::New(SHADER_RADIAL_PROGRESS_TEXTURED_VERT, SHADER_RADIAL_PROGRESS_TEXTURED_FRAG);
Property::Map vertexFormat;
vertexFormat["aPosition"] = Property::VECTOR2;
--- /dev/null
+// Fragment shader for polygon
+
+void main()
+{
+ gl_FragColor = vec4( 1.0, 1.0, 1.0, 1.0 );
+}
--- /dev/null
+// Vertex shader for polygon
+
+attribute mediump vec3 aPosition;
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+uniform mediump vec3 uSize; // DALi shader builtin
+uniform mediump float uProgress;
+
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ mediump vec4 vertexPosition = vec4(aPosition.x, aPosition.y, 0.0, 1.0);
+
+ float index = aPosition.z;
+ if( uProgress < index )
+ {
+ vertexPosition = vec4(0.0, 0.0, 0.0, 1.0);
+ }
+
+ vertexPosition.xyz *= uSize;
+ gl_Position = uMvpMatrix * vertexPosition;
+}
--- /dev/null
+// Fragment shaderfor textured quad
+
+uniform sampler2D uTexture;
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ mediump vec4 texColor = texture2D( uTexture, vTexCoord );
+ gl_FragColor = texColor;
+}
--- /dev/null
+// Vertex shader for textured quad
+
+attribute mediump vec2 aPosition;
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+uniform mediump vec3 uSize; // DALi shader builtin
+
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
+ vertexPosition.xyz *= uSize;
+ vTexCoord = vec2(1.0, 1.0)*(aPosition + vec2(0.5) );
+ gl_Position = uMvpMatrix * vertexPosition;
+}
#include <dali/dali.h>
#include "look-camera.h"
+#include "generated/rendering-skybox-vert.h"
+#include "generated/rendering-skybox-frag.h"
+#include "generated/rendering-skybox-cube-vert.h"
+#include "generated/rendering-skybox-cube-frag.h"
using namespace Dali;
using namespace Toolkit;
namespace
{
-// clang-format off
-/*
- * Vertex shader for a textured cube
- */
-const char* VERTEX_SHADER_CUBE = DALI_COMPOSE_SHADER(
-attribute mediump vec3 aPosition;\n // DALi shader builtin
-attribute mediump vec2 aTexCoord;\n // DALi shader builtin
-uniform mediump mat4 uMvpMatrix;\n // DALi shader builtin
-uniform mediump vec3 uSize;\n // DALi shader builtin
-\n
-varying mediump vec2 vTexCoord;\n
-void main()\n
-{\n
- mediump vec4 vertexPosition = vec4(aPosition, 1.0);\n
- vertexPosition.xyz *= uSize;\n
- vTexCoord = aTexCoord;\n
- gl_Position = uMvpMatrix * vertexPosition;\n
-}\n
-);
-
-/*
- * Fragment shader for a textured cube
- */
-const char* FRAGMENT_SHADER_CUBE = DALI_COMPOSE_SHADER(
-uniform sampler2D uTexture;\n
-\n
-varying mediump vec2 vTexCoord;\n
-void main()\n
-{\n
- mediump vec4 texColor = texture2D( uTexture, vTexCoord );\n
- gl_FragColor = texColor;\n
-}\n
-);
-
-/*
- * Vertex shader for a skybox
- */
-const char* VERTEX_SHADER_SKYBOX = DALI_COMPOSE_SHADER(
-attribute mediump vec3 aPosition;\n // DALi shader builtin
-uniform mediump mat4 uMvpMatrix;\n // DALi shader builtin
-\n
-varying mediump vec3 vTexCoord;\n
-void main()\n
-{\n
- vTexCoord.x = aPosition.x;\n
- vTexCoord.y = -aPosition.y;\n // convert to GL coords
- vTexCoord.z = aPosition.z;\n
-
- mediump vec4 vertexPosition = vec4(aPosition, 1.0);\n
- vec4 clipSpacePosition = uMvpMatrix * vertexPosition;\n
- gl_Position = clipSpacePosition.xyww;\n // Writes 1.0, the maximum depth value, into the depth buffer.
- // This is an optimization to avoid running the fragment shader
- // for the pixels hidden by the scene's objects.
-}\n
-);
-
-/*
- * Fragment shader for a skybox
- */
-const char* FRAGMENT_SHADER_SKYBOX = DALI_COMPOSE_SHADER(
-uniform samplerCube uSkyBoxTexture;\n
-\n
-varying mediump vec3 vTexCoord;\n
-void main()\n
-{\n
- mediump vec4 texColor = textureCube( uSkyBoxTexture, vTexCoord );\n
- gl_FragColor = texColor;\n
-}\n
-);
-// clang-format on
const float CAMERA_DEFAULT_FOV(60.0f);
const float CAMERA_DEFAULT_NEAR(0.1f);
*/
void CreateShaders()
{
- mShaderCube = Shader::New(VERTEX_SHADER_CUBE, FRAGMENT_SHADER_CUBE);
- mShaderSkybox = Shader::New(VERTEX_SHADER_SKYBOX, FRAGMENT_SHADER_SKYBOX);
+ mShaderCube = Shader::New(SHADER_RENDERING_SKYBOX_CUBE_VERT, SHADER_RENDERING_SKYBOX_CUBE_FRAG);
+ mShaderSkybox = Shader::New(SHADER_RENDERING_SKYBOX_CUBE_VERT, SHADER_RENDERING_SKYBOX_CUBE_FRAG);
}
/**
--- /dev/null
+// Fragment shader for a textured cube
+
+uniform sampler2D uTexture;
+
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ mediump vec4 texColor = texture2D( uTexture, vTexCoord );
+ gl_FragColor = texColor;
+}
--- /dev/null
+// Vertex shader for a textured cube
+
+attribute mediump vec3 aPosition; // DALi shader builtin
+attribute mediump vec2 aTexCoord; // DALi shader builtin
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+uniform mediump vec3 uSize; // DALi shader builtin
+
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ mediump vec4 vertexPosition = vec4(aPosition, 1.0);
+ vertexPosition.xyz *= uSize;
+ vTexCoord = aTexCoord;
+ gl_Position = uMvpMatrix * vertexPosition;
+}
--- /dev/null
+// Fragment shader for a skybox
+
+uniform samplerCube uSkyBoxTexture;
+
+varying mediump vec3 vTexCoord;
+
+void main()
+{
+ mediump vec4 texColor = textureCube( uSkyBoxTexture, vTexCoord );
+ gl_FragColor = texColor;
+}
--- /dev/null
+// Vertex shader for a skybox
+
+attribute mediump vec3 aPosition; // DALi shader builtin
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+
+varying mediump vec3 vTexCoord;
+
+void main()
+{
+ vTexCoord.x = aPosition.x;
+ vTexCoord.y = -aPosition.y; // convert to GL coords
+ vTexCoord.z = aPosition.z;
+
+ mediump vec4 vertexPosition = vec4(aPosition, 1.0);
+ vec4 clipSpacePosition = uMvpMatrix * vertexPosition;
+ gl_Position = clipSpacePosition.xyww; // Writes 1.0, the maximum depth value, into the depth buffer.
+ // This is an optimization to avoid running the fragment shader
+ // for the pixels hidden by the scene's objects.
+}
#include <dali-toolkit/dali-toolkit.h>
#include <dali/dali.h>
+#include "generated/rendering-textured-cube-vert.h"
+#include "generated/rendering-textured-cube-frag.h"
+
using namespace Dali;
using namespace Toolkit;
namespace
{
-// clang-format off
-
-/*
- * Vertex shader
- */
-const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
-attribute mediump vec3 aPosition;\n // DALi shader builtin
-attribute mediump vec2 aTexCoord;\n // DALi shader builtin
-uniform mediump mat4 uMvpMatrix;\n // DALi shader builtin
-uniform mediump vec3 uSize;\n // DALi shader builtin
-\n
-varying mediump vec2 vTexCoord;\n
-void main()\n
-{\n
- mediump vec4 vertexPosition = vec4(aPosition, 1.0);\n
- vertexPosition.xyz *= uSize;\n
- vTexCoord = aTexCoord;\n
- gl_Position = uMvpMatrix * vertexPosition;\n
-}\n
-);
-
-/*
- * Fragment shader
- */
-const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
-uniform sampler2D uTexture;\n
-\n
-varying mediump vec2 vTexCoord;\n
-void main()\n
-{\n
- mediump vec4 texColor = texture2D( uTexture, vTexCoord );\n
- gl_FragColor = texColor;\n
-}\n
-);
-// clang-format on
const char* TEXTURE_URL = DEMO_IMAGE_DIR "wood.png";
}
/**
- * Creates a shader using inlined variable VERTEX_SHADER and FRAGMENT_SHADER
+ * Creates a shader using SHADER_RENDERING_TEXTURED_CUBE_VERT and SHADER_RENDERING_TEXTURED_CUBE_FRAG
*
* Shaders are very basic and all they do is transforming vertices and sampling
* a texture.
*/
void CreateCubeShader()
{
- mShader = Shader::New(VERTEX_SHADER, FRAGMENT_SHADER);
+ mShader = Shader::New(SHADER_RENDERING_TEXTURED_CUBE_VERT, SHADER_RENDERING_TEXTURED_CUBE_FRAG);
}
/**
--- /dev/null
+uniform sampler2D uTexture;
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ mediump vec4 texColor = texture2D( uTexture, vTexCoord );
+ gl_FragColor = texColor;
+}
--- /dev/null
+attribute mediump vec3 aPosition; // DALi shader builtin
+attribute mediump vec2 aTexCoord; // DALi shader builtin
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+uniform mediump vec3 uSize; // DALi shader builtin
+
+varying mediump vec2 vTexCoord;
+
+void main()
+{
+ mediump vec4 vertexPosition = vec4(aPosition, 1.0);
+ vertexPosition.xyz *= uSize;
+ vTexCoord = aTexCoord;
+ gl_Position = uMvpMatrix * vertexPosition;
+}
#include <dali-toolkit/dali-toolkit.h>
#include <dali/dali.h>
+#include "generated/rendering-triangle-vert.h"
+#include "generated/rendering-triangle-frag.h"
+
using namespace Dali;
using namespace Toolkit;
-namespace
-{
-// clang-format off
-
-/*
- * Vertex shader
- */
-const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
-attribute mediump vec2 aPosition;\n // DALi shader builtin
-uniform mediump mat4 uMvpMatrix;\n // DALi shader builtin
-uniform mediump vec3 uSize;\n // DALi shader builtin
-\n
-void main()\n
-{\n
- mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
- vertexPosition.xyz *= uSize;\n
- gl_Position = uMvpMatrix * vertexPosition;\n
-}\n
-);
-
-/*
- * Fragment shader
- */
-const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
-uniform mediump vec4 uColor;\n
-\n
-void main()\n
-{\n
- gl_FragColor = uColor;\n
-}\n
-);
-// clang-format on
-
-} // namespace
-
// This example shows how to draw a triangle in actor's color
//
class DrawTriangleController : public ConnectionTracker
*/
void CreateTriangleShader()
{
- mShader = Shader::New(VERTEX_SHADER, FRAGMENT_SHADER);
+ mShader = Shader::New(SHADER_RENDERING_TRIANGLE_VERT, SHADER_RENDERING_TRIANGLE_FRAG);
}
/**
--- /dev/null
+uniform mediump vec4 uColor;
+
+void main()
+{
+ gl_FragColor = uColor;
+}
--- /dev/null
+attribute mediump vec2 aPosition; // DALi shader builtin
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+uniform mediump vec3 uSize; // DALi shader builtin
+
+void main()
+{
+ mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
+ vertexPosition.xyz *= uSize;
+ gl_Position = uMvpMatrix * vertexPosition;
+}
--- /dev/null
+#version 300 es
+
+precision mediump float;
+
+in vec2 vUV;
+out vec4 FragColor;
+
+uniform sampler2D sAlbedo;
+uniform vec4 uColor;
+
+void main()
+{
+ vec4 color = texture(sAlbedo, vUV);
+ FragColor = vec4(color.rgb, uColor.a * color.a);
+}
--- /dev/null
+#version 300 es
+
+precision mediump float;
+
+in vec2 aPosition;
+in vec2 aTexCoord;
+
+out vec2 vUV;
+
+uniform vec3 uSize;
+uniform mat4 uMvpMatrix;
+
+void main()
+{
+ vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
+ vertexPosition.xyz *= uSize;
+ gl_Position = uMvpMatrix * vertexPosition;
+
+ vUV = aTexCoord;
+}
#include <dali/devel-api/adaptor-framework/image-loading.h>
#include <dali/devel-api/adaptor-framework/pixel-buffer.h>
+// INTERNAL INCLUDES
+#include "generated/simple-text-renderer-vert.h"
+#include "generated/simple-text-renderer-frag.h"
+
using namespace std;
using namespace Dali;
using namespace Dali::Toolkit;
const std::string IMAGE1 = DEMO_IMAGE_DIR "application-icon-1.png";
const std::string IMAGE2 = DEMO_IMAGE_DIR "application-icon-6.png";
-#define MAKE_SHADER(A) #A
-
-const std::string VERSION_3_ES = "#version 300 es\n";
-
-const char* VERTEX_SHADER = MAKE_SHADER(
- precision mediump float;
-
- in vec2 aPosition;
- in vec2 aTexCoord;
-
- out vec2 vUV;
-
- uniform vec3 uSize;
- uniform mat4 uMvpMatrix;
-
- void main() {
- vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
- vertexPosition.xyz *= uSize;
- gl_Position = uMvpMatrix * vertexPosition;
-
- vUV = aTexCoord;
- });
-
-const char* FRAGMENT_SHADER = MAKE_SHADER(
- precision mediump float;
-
- in vec2 vUV;
-
- out vec4 FragColor;
-
- uniform sampler2D sAlbedo;
- uniform vec4 uColor;
-
- void main() {
- vec4 color = texture(sAlbedo, vUV);
- FragColor = vec4(color.rgb, uColor.a * color.a);
- });
-
Renderer CreateRenderer()
{
// Create the geometry.
geometry.SetType(Geometry::TRIANGLE_STRIP);
// Create the shader
- Shader shader = Shader::New(VERSION_3_ES + VERTEX_SHADER, VERSION_3_ES + FRAGMENT_SHADER);
+ Shader shader = Shader::New(SHADER_SIMPLE_TEXT_RENDERER_VERT, SHADER_SIMPLE_TEXT_RENDERER_FRAG);
// Create the renderer
--- /dev/null
+precision highp float;
+uniform sampler2D sTexture;
+varying vec2 vTexCoord;
+
+varying lowp vec4 vColor;
+
+void main()
+{
+ gl_FragColor = vColor;
+ gl_FragColor.a *= texture2D(sTexture, vTexCoord).a;
+}
--- /dev/null
+precision highp float;
+
+attribute vec2 aTexCoord;
+uniform mat4 uMvpMatrix;
+varying vec2 vTexCoord;
+
+attribute vec2 aParticlePath0;
+attribute vec2 aParticlePath1;
+attribute vec2 aParticlePath2;
+attribute vec2 aParticlePath3;
+attribute vec2 aParticlePath4;
+attribute vec2 aParticlePath5;
+
+uniform float uPercentage;
+uniform float uPercentageMarked;
+uniform vec3 uParticleColors[NUM_COLOR];
+uniform float uOpacity[NUM_PARTICLE];
+uniform vec2 uTapIndices;
+uniform float uTapOffset[MAXIMUM_ANIMATION_COUNT];
+uniform vec2 uTapPoint[MAXIMUM_ANIMATION_COUNT];
+uniform float uAcceleration;
+uniform float uRadius;
+uniform float uScale;
+uniform float uBreak;
+
+varying lowp vec4 vColor;
+
+void main()
+{
+ // we store the particle index inside texCoord attribute
+ float idx = abs(aTexCoord.y)-1.0;
+
+ // early out if the particle is invisible
+ if(uOpacity[int(idx)]<1e-5)
+ {
+ gl_Position = vec4(0.0);
+ vColor = vec4(0.0);
+ return;
+ }
+
+ // As the movement along the b-curve has nonuniform speed with a uniform increasing parameter 'uPercentage'
+ // we give different particles the different 'percentage' to make them looks more random
+ float increment = idx / float(NUM_PARTICLE)*5.0;
+ float percentage = mod(uPercentage +uAcceleration+increment, 1.0);
+
+ vec2 p0; vec2 p1; vec2 p2; vec2 p3;
+ // calculate the particle position by using the cubic b-curve equation
+ if(percentage<0.5) // particle on the first b-curve
+ {
+ p0 = aParticlePath0;
+ p1 = aParticlePath1;
+ p2 = aParticlePath2;
+ p3 = aParticlePath3;
+ }
+ else
+ {
+ p0 = aParticlePath3;
+ p1 = aParticlePath4;
+ p2 = aParticlePath5;
+ p3 = aParticlePath0;
+ }
+ float t = mod( percentage*2.0, 1.0);
+ vec2 position = (1.0-t)*(1.0-t)*(1.0-t)*p0 + 3.0*(1.0-t)*(1.0-t)*t*p1+3.0*(1.0-t)*t*t*p2 + t*t*t*p3;
+
+ vec2 referencePoint = mix(p0,p3,0.5);
+ float maxAnimationCount = float(MAXIMUM_ANIMATION_COUNT);
+
+ for( float i=uTapIndices.x; i<uTapIndices.y; i+=1.0 )
+ {
+ int id = int( mod(i+0.5,maxAnimationCount ) );
+ vec2 edgePoint = normalize(referencePoint-uTapPoint[id])*uRadius+vec2(uRadius);
+ position = mix( position, edgePoint, uTapOffset[id] ) ;
+ }
+
+ position = mix( position, vec2( 250.0,250.0 ),uBreak*(1.0-uOpacity[int(idx)]) ) ;
+
+ // vertex position on the mesh: (sign(aTexCoord.x), sign(aTexCoord.y))*PARTICLE_HALF_SIZE
+ gl_Position = uMvpMatrix * vec4( position.x+sign(aTexCoord.x)*PARTICLE_HALF_SIZE/uScale,
+ position.y+sign(aTexCoord.y)*PARTICLE_HALF_SIZE/uScale,
+ 0.0, 1.0 );
+
+ // we store the color index inside texCoord attribute
+ float colorIndex = abs(aTexCoord.x);
+ vColor.rgb = uParticleColors[int(colorIndex)-1];
+ vColor.a = fract(colorIndex) * uOpacity[int(idx)];
+
+ // produce a 'seemingly' random fade in/out
+ percentage = mod(uPercentage+increment+0.15, 1.0);
+ float ramdomOpacity = (min(percentage, 0.25)-0.15+0.9-max(percentage,0.9))*10.0;
+ vColor.a *=ramdomOpacity;
+
+ vTexCoord = clamp(aTexCoord, 0.0, 1.0);
+}
#include <dali-toolkit/dali-toolkit.h>
#include <dali/dali.h>
+#include "generated/sparkle-effect-vert.h"
+#include "generated/sparkle-effect-frag.h"
+
using namespace Dali;
using Dali::Toolkit::ImageView;
*/
Shader New()
{
- // clang-format off
- std::string vertexShader = DALI_COMPOSE_SHADER(
- precision highp float;\n
- \n
- attribute vec2 aTexCoord;\n
- uniform mat4 uMvpMatrix;\n
- varying vec2 vTexCoord;\n
- \n
- attribute vec2 aParticlePath0;\n
- attribute vec2 aParticlePath1;\n
- attribute vec2 aParticlePath2;\n
- attribute vec2 aParticlePath3;\n
- attribute vec2 aParticlePath4;\n
- attribute vec2 aParticlePath5;\n
- \n
- uniform float uPercentage;\n
- uniform float uPercentageMarked;\n
- uniform vec3 uParticleColors[NUM_COLOR];\n
- uniform float uOpacity[NUM_PARTICLE];\n
- uniform vec2 uTapIndices;
- uniform float uTapOffset[MAXIMUM_ANIMATION_COUNT];\n
- uniform vec2 uTapPoint[MAXIMUM_ANIMATION_COUNT];\n
- uniform float uAcceleration;\n
- uniform float uRadius;\n
- uniform float uScale;\n
- uniform float uBreak;\n
- \n
- varying lowp vec4 vColor;\n
- \n
- void main()\n
- {\n
- // we store the particle index inside texCoord attribute
- float idx = abs(aTexCoord.y)-1.0;\n
- \n
- // early out if the particle is invisible
- if(uOpacity[int(idx)]<1e-5)\n
- {\n
- gl_Position = vec4(0.0);\n
- vColor = vec4(0.0);\n
- return;\n
- }\n
- \n
- // As the movement along the b-curve has nonuniform speed with a uniform increasing parameter 'uPercentage'
- // we give different particles the different 'percentage' to make them looks more random
- float increment = idx / float(NUM_PARTICLE)*5.0;
- float percentage = mod(uPercentage +uAcceleration+increment, 1.0);
- \n
- vec2 p0; vec2 p1; vec2 p2; vec2 p3;
- // calculate the particle position by using the cubic b-curve equation
- if(percentage<0.5)\n // particle on the first b-curve
- {\n
- p0 = aParticlePath0;\n
- p1 = aParticlePath1;\n
- p2 = aParticlePath2;\n
- p3 = aParticlePath3;\n
- }\n
- else\n
- {\n
- p0 = aParticlePath3;\n
- p1 = aParticlePath4;\n
- p2 = aParticlePath5;\n
- p3 = aParticlePath0;\n
- }\n
- float t = mod( percentage*2.0, 1.0);\n
- vec2 position = (1.0-t)*(1.0-t)*(1.0-t)*p0 + 3.0*(1.0-t)*(1.0-t)*t*p1+3.0*(1.0-t)*t*t*p2 + t*t*t*p3;\n
- \n
- vec2 referencePoint = mix(p0,p3,0.5);\n
- float maxAnimationCount = float(MAXIMUM_ANIMATION_COUNT);\n
- \n
- for( float i=uTapIndices.x; i<uTapIndices.y; i+=1.0 )\n
- {
- int id = int( mod(i+0.5,maxAnimationCount ) );\n
- vec2 edgePoint = normalize(referencePoint-uTapPoint[id])*uRadius+vec2(uRadius);\n
- position = mix( position, edgePoint, uTapOffset[id] ) ;\n
- }\n
- \n
- position = mix( position, vec2( 250.0,250.0 ),uBreak*(1.0-uOpacity[int(idx)]) ) ;
- \n
- // vertex position on the mesh: (sign(aTexCoord.x), sign(aTexCoord.y))*PARTICLE_HALF_SIZE
- gl_Position = uMvpMatrix * vec4( position.x+sign(aTexCoord.x)*PARTICLE_HALF_SIZE/uScale,
- position.y+sign(aTexCoord.y)*PARTICLE_HALF_SIZE/uScale,
- 0.0, 1.0 );\n
- \n
- // we store the color index inside texCoord attribute
- float colorIndex = abs(aTexCoord.x);
- vColor.rgb = uParticleColors[int(colorIndex)-1];\n
- vColor.a = fract(colorIndex) * uOpacity[int(idx)];\n
- \n
- // produce a 'seemingly' random fade in/out
- percentage = mod(uPercentage+increment+0.15, 1.0);\n
- float ramdomOpacity = (min(percentage, 0.25)-0.15+0.9-max(percentage,0.9))*10.0;\n
- vColor.a *=ramdomOpacity;\n
- \n
- vTexCoord = clamp(aTexCoord, 0.0, 1.0);\n
- }\n
- );
-
- std::string fragmentShader = DALI_COMPOSE_SHADER(
- precision highp float;\n
- uniform sampler2D sTexture;\n
- varying vec2 vTexCoord;\n
- \n
- varying lowp vec4 vColor;\n
- \n
- void main()\n
- {\n
- gl_FragColor = vColor;\n
- gl_FragColor.a *= texture2D(sTexture, vTexCoord).a;\n
- }\n
- );
- // clang-format on
-
std::ostringstream vertexShaderStringStream;
vertexShaderStringStream << "#define NUM_COLOR " << NUM_COLOR << "\n"
<< "#define NUM_PARTICLE " << NUM_PARTICLE << "\n"
<< "#define PARTICLE_HALF_SIZE " << PARTICLE_SIZE * ACTOR_SCALE / 2.f << "\n"
<< "#define MAXIMUM_ANIMATION_COUNT " << MAXIMUM_ANIMATION_COUNT << "\n"
- << vertexShader;
+ << SHADER_SPARKLE_EFFECT_VERT;
- Shader handle = Shader::New(vertexShaderStringStream.str(), fragmentShader);
+ Shader handle = Shader::New(vertexShaderStringStream.str(), SHADER_SPARKLE_EFFECT_FRAG);
// set the particle colors
std::ostringstream oss;
#include <dali-toolkit/devel-api/controls/control-devel.h>
#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
+#include "generated/image-channel-control-frag.h"
+
#include <cstdio>
using namespace Dali; // Needed for macros
{
namespace
{
-// clang-format off
-
-const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
- varying mediump vec2 vTexCoord;\n
- uniform sampler2D sTexture;\n
- uniform mediump vec4 uColor;\n
- uniform mediump vec3 mixColor;\n
- uniform mediump vec3 uChannels;\n
- \n
- void main()\n
- {\n
- gl_FragColor = texture2D( sTexture, vTexCoord ) * vec4(mixColor,1.0) * uColor * vec4(uChannels, 1.0) ;\n
- }\n
-);
-// clang-format on
Dali::BaseHandle Create()
{
Property::Map properties;
Property::Map shader;
- shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = FRAGMENT_SHADER;
+ shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = SHADER_IMAGE_CHANNEL_CONTROL_FRAG.data();
properties[Dali::Toolkit::Visual::Property::TYPE] = Dali::Toolkit::Visual::IMAGE;
properties[Dali::Toolkit::Visual::Property::SHADER] = shader;
properties[Dali::Toolkit::ImageVisual::Property::URL] = url;
--- /dev/null
+varying mediump vec2 vTexCoord;
+uniform sampler2D sTexture;
+uniform mediump vec4 uColor;
+uniform mediump vec3 mixColor;
+uniform mediump vec3 uChannels;
+
+void main()
+{
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * vec4(mixColor,1.0) * uColor * vec4(uChannels, 1.0) ;
+}
--- /dev/null
+varying mediump vec2 vTexCoord;
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+uniform lowp vec4 uFadeColor;
+
+void main()
+{
+ gl_FragColor = texture2D(sTexture, vTexCoord) * uColor * uFadeColor;
+}
--- /dev/null
+attribute mediump vec2 aPosition;
+attribute highp vec2 aTexCoord;
+varying mediump vec2 vTexCoord;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+uniform lowp vec4 uFadeColor;
+
+void main()
+{
+ mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
+ vertexPosition.xyz *= uSize;
+ vertexPosition = uMvpMatrix * vertexPosition;
+ vTexCoord = aTexCoord;
+ gl_Position = vertexPosition;
+}
// INTERNAL INCLUDES
#include "shared/utility.h"
#include "shared/view.h"
+#include "generated/textured-mesh-vert.h"
+#include "generated/textured-mesh-frag.h"
using namespace Dali;
const char* MATERIAL_SAMPLE(DEMO_IMAGE_DIR "gallery-small-48.jpg");
const char* MATERIAL_SAMPLE2(DEMO_IMAGE_DIR "gallery-medium-19.jpg");
-#define MAKE_SHADER(A) #A
-
-const char* VERTEX_SHADER = MAKE_SHADER(
- attribute mediump vec2 aPosition;
- attribute highp vec2 aTexCoord;
- varying mediump vec2 vTexCoord;
- uniform mediump mat4 uMvpMatrix;
- uniform mediump vec3 uSize;
- uniform lowp vec4 uFadeColor;
-
- void main() {
- mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
- vertexPosition.xyz *= uSize;
- vertexPosition = uMvpMatrix * vertexPosition;
- vTexCoord = aTexCoord;
- gl_Position = vertexPosition;
- });
-
-const char* FRAGMENT_SHADER = MAKE_SHADER(
- varying mediump vec2 vTexCoord;
- uniform lowp vec4 uColor;
- uniform sampler2D sTexture;
- uniform lowp vec4 uFadeColor;
-
- void main() {
- gl_FragColor = texture2D(sTexture, vTexCoord) * uColor * uFadeColor;
- });
-
/**
* Sinusoidal curve starting at zero with 2 cycles
*/
Texture texture1 = DemoHelper::LoadTexture(MATERIAL_SAMPLE);
Texture texture2 = DemoHelper::LoadTexture(MATERIAL_SAMPLE2);
- mShader = Shader::New(VERTEX_SHADER, FRAGMENT_SHADER);
+ mShader = Shader::New(SHADER_TEXTURED_MESH_VERT, SHADER_TEXTURED_MESH_FRAG);
mTextureSet1 = TextureSet::New();
mTextureSet1.SetTexture(0u, texture1);
--- /dev/null
+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.);
+}
--- /dev/null
+#define FMA(a, b, c) ((a) * (b) + (c)) // fused multiply-add
+
+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;
+}
#include <iostream>
#include <numeric>
+#include "generated/waves-vert.h"
+#include "generated/waves-frag.h"
+
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";
specularity = mWaveShader.GetProperty(mUSpecularity).Get<float>();
}
- Shader shader = Shader::New(WAVES_VSH.data(), WAVES_FSH.data(), Shader::Hint::MODIFIES_GEOMETRY);
+ Shader shader = Shader::New(SHADER_WAVES_VERT, SHADER_WAVES_FRAG, 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);
projects / platform / core / uifw / dali-demo.git / commitdiff