2 * Copyright (c) 2014 Samsung Electronics Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 #include "bloom-view-impl.h"
24 #include <dali/public-api/animation/constraint.h>
25 #include <dali/public-api/animation/constraints.h>
26 #include <dali/public-api/common/stage.h>
27 #include <dali/public-api/object/property-map.h>
28 #include <dali/public-api/object/type-registry.h>
29 #include <dali/public-api/object/type-registry-helper.h>
30 #include <dali/public-api/render-tasks/render-task-list.h>
31 #include <dali/devel-api/rendering/renderer.h>
34 #include <dali-toolkit/public-api/controls/gaussian-blur-view/gaussian-blur-view.h>
35 #include <dali-toolkit/devel-api/controls/bloom-view/bloom-view.h>
36 #include "../gaussian-blur-view/gaussian-blur-view-impl.h"
54 return Toolkit::BloomView::New();
57 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::BloomView, Toolkit::Control, Create )
58 DALI_TYPE_REGISTRATION_END()
61 const float BLOOM_THRESHOLD_DEFAULT = 0.25f;
62 const float BLOOM_BLUR_STRENGTH_DEFAULT = 1.0f;
63 const float BLOOM_INTENSITY_DEFAULT = 1.0f;
64 const float IMAGE_INTENSITY_DEFAULT = 1.0f;
65 const float BLOOM_SATURATION_DEFAULT = 1.0f;
66 const float IMAGE_SATURATION_DEFAULT = 1.0f;
69 const unsigned int BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_NUM_SAMPLES = 5;
70 const float BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_BELL_CURVE_WIDTH = 1.5f;
71 const Pixel::Format BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_RENDER_TARGET_PIXEL_FORMAT = Pixel::RGBA8888;
72 const float BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_FADE_IN = 1.0f; // default, fully blurred
73 const float BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_WIDTH_SCALE = 0.5f;
74 const float BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_HEIGHT_SCALE = 0.5f;
76 const float ARBITRARY_FIELD_OF_VIEW = Math::PI / 4.0f;
78 const char* const BLOOM_BLUR_STRENGTH_PROPERTY_NAME = "BlurStrengthProperty";
79 const char* const BLOOM_THRESHOLD_PROPERTY_NAME = "uBloomThreshold";
80 const char* const RECIP_ONE_MINUS_BLOOM_THRESHOLD_PROPERTY_NAME = "uRecipOneMinusBloomThreshold";
81 const char* const BLOOM_INTENSITY_PROPERTY_NAME = "uBloomIntensity";
82 const char* const BLOOM_SATURATION_PROPERTY_NAME = "uBloomSaturation";
83 const char* const IMAGE_INTENSITY_PROPERTY_NAME = "uImageIntensity";
84 const char* const IMAGE_SATURATION_PROPERTY_NAME = "uImageSaturation";
86 ///////////////////////////////////////////////////////
91 const char* const BLOOM_EXTRACT_FRAGMENT_SOURCE =
92 "varying mediump vec2 vTexCoord;\n"
93 "uniform sampler2D sTexture;\n"
94 "uniform lowp vec4 uColor;\n"
95 "uniform mediump float uBloomThreshold;\n"
96 "uniform mediump float uRecipOneMinusBloomThreshold;\n"
99 " mediump vec4 col;\n"
100 " col = texture2D(sTexture, vTexCoord);\n"
101 " col = (col - uBloomThreshold) * uRecipOneMinusBloomThreshold;\n" // remove intensities lower than the thresold and remap intensities above the threshold to [0..1]
102 " gl_FragColor = clamp(col, 0.0, 1.0);\n"
105 const char* const COMPOSITE_FRAGMENT_SOURCE =
106 "precision mediump float;\n"
107 "varying mediump vec2 vTexCoord;\n"
108 "uniform sampler2D sTexture;\n"
109 "uniform sampler2D sEffect;\n"
110 "uniform lowp vec4 uColor;\n"
111 "uniform float uBloomIntensity;\n"
112 "uniform float uImageIntensity;\n"
113 "uniform float uBloomSaturation;\n"
114 "uniform float uImageSaturation;\n"
116 "vec4 ChangeSaturation(vec4 col, float sat)\n"
118 " float grey = dot(col.rgb, vec3(0.3, 0.6, 0.1));\n"
119 " return mix(vec4(grey, grey, grey, 1.0), col, sat);\n"
124 " mediump vec4 image;\n"
125 " mediump vec4 bloom;\n"
126 " image = texture2D(sTexture, vTexCoord);\n"
127 " bloom = texture2D(sEffect, vTexCoord);\n"
128 " image = ChangeSaturation(image, uImageSaturation) * uImageIntensity;\n"
129 " bloom = ChangeSaturation(bloom, uBloomSaturation) * uBloomIntensity;\n"
130 " image *= 1.0 - clamp(bloom, 0.0, 1.0);\n" // darken base where bloom is strong, to prevent excessive burn-out of result
131 " gl_FragColor = image + bloom;\n"
138 BloomView::BloomView()
139 : Control( ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) )
140 , mBlurNumSamples(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_NUM_SAMPLES)
141 , mBlurBellCurveWidth(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_BELL_CURVE_WIDTH)
142 , mPixelFormat(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_RENDER_TARGET_PIXEL_FORMAT)
143 , mDownsampleWidthScale(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_WIDTH_SCALE)
144 , mDownsampleHeightScale(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_HEIGHT_SCALE)
145 , mDownsampledWidth( 0.0f )
146 , mDownsampledHeight( 0.0f )
147 , mTargetSize(Vector2::ZERO)
148 , mLastSize(Vector2::ZERO)
149 , mChildrenRoot(Actor::New())
150 , mInternalRoot(Actor::New() )
151 , mBloomThresholdPropertyIndex(Property::INVALID_INDEX)
152 , mBlurStrengthPropertyIndex(Property::INVALID_INDEX)
153 , mBloomIntensityPropertyIndex(Property::INVALID_INDEX)
154 , mBloomSaturationPropertyIndex(Property::INVALID_INDEX)
155 , mImageIntensityPropertyIndex(Property::INVALID_INDEX)
156 , mImageSaturationPropertyIndex(Property::INVALID_INDEX)
157 , mActivated( false )
161 BloomView::BloomView( const unsigned int blurNumSamples, const float blurBellCurveWidth, const Pixel::Format renderTargetPixelFormat,
162 const float downsampleWidthScale, const float downsampleHeightScale)
163 : Control( ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) )
164 , mBlurNumSamples(blurNumSamples)
165 , mBlurBellCurveWidth(blurBellCurveWidth)
166 , mPixelFormat(renderTargetPixelFormat)
167 , mDownsampleWidthScale(downsampleWidthScale)
168 , mDownsampleHeightScale(downsampleHeightScale)
169 , mDownsampledWidth( 0.0f )
170 , mDownsampledHeight( 0.0f )
171 , mTargetSize(Vector2::ZERO)
172 , mLastSize(Vector2::ZERO)
173 , mChildrenRoot(Actor::New())
174 , mInternalRoot(Actor::New())
175 , mBloomThresholdPropertyIndex(Property::INVALID_INDEX)
176 , mBlurStrengthPropertyIndex(Property::INVALID_INDEX)
177 , mBloomIntensityPropertyIndex(Property::INVALID_INDEX)
178 , mBloomSaturationPropertyIndex(Property::INVALID_INDEX)
179 , mImageIntensityPropertyIndex(Property::INVALID_INDEX)
180 , mImageSaturationPropertyIndex(Property::INVALID_INDEX)
181 , mActivated( false )
185 BloomView::~BloomView()
189 Toolkit::BloomView BloomView::New()
191 BloomView* impl = new BloomView();
193 Dali::Toolkit::BloomView handle = Dali::Toolkit::BloomView( *impl );
195 // Second-phase init of the implementation
196 // This can only be done after the CustomActor connection has been made...
202 Toolkit::BloomView BloomView::New(const unsigned int blurNumSamples, const float blurBellCurveWidth, const Pixel::Format renderTargetPixelFormat,
203 const float downsampleWidthScale, const float downsampleHeightScale)
205 BloomView* impl = new BloomView( blurNumSamples, blurBellCurveWidth, renderTargetPixelFormat, downsampleWidthScale, downsampleHeightScale);
207 Dali::Toolkit::BloomView handle = Dali::Toolkit::BloomView( *impl );
209 // Second-phase init of the implementation
210 // This can only be done after the CustomActor connection has been made...
216 ///////////////////////////////////////////////////////////
221 void BloomView::OnInitialize()
223 // root actor to parent all user added actors, needed to allow us to set that subtree as exclusive for our child render task
224 mChildrenRoot.SetParentOrigin( ParentOrigin::CENTER );
225 mInternalRoot.SetParentOrigin( ParentOrigin::CENTER );
227 //////////////////////////////////////////////////////
230 // Create an ImageActor for rendering from the scene texture to the bloom texture
231 mBloomExtractImageActor = Toolkit::ImageView::New();
232 mBloomExtractImageActor.SetParentOrigin( ParentOrigin::CENTER );
234 // Create shader used for extracting the bright parts of an image
235 Property::Map customShader;
236 customShader[ "fragmentShader" ] = BLOOM_EXTRACT_FRAGMENT_SOURCE;
237 Property::Map rendererMap;
238 rendererMap.Insert( "rendererType", "image" );
239 rendererMap.Insert( "shader", customShader );
240 mBloomExtractImageActor.SetProperty( Toolkit::ImageView::Property::IMAGE, rendererMap );
242 // Create an ImageActor for compositing the result (scene and bloom textures) to output
243 mCompositeImageActor = Toolkit::ImageView::New();
244 mCompositeImageActor.SetParentOrigin( ParentOrigin::CENTER );
246 // Create shader used to composite bloom and original image to output render target
247 customShader[ "fragmentShader" ] = COMPOSITE_FRAGMENT_SOURCE;
248 rendererMap[ "shader" ] = customShader;
249 mCompositeImageActor.SetProperty( Toolkit::ImageView::Property::IMAGE, rendererMap );
251 // Create an ImageActor for holding final result, i.e. the blurred image. This will get rendered to screen later, via default / user render task
252 mTargetImageActor = Toolkit::ImageView::New();
253 mTargetImageActor.SetParentOrigin( ParentOrigin::CENTER );
255 // Create the Gaussian Blur object + render tasks
256 // Note that we use mBloomExtractTarget as the source image and also re-use this as the gaussian blur final render target. This saves the gaussian blur code from creating it
257 // render targets etc internally, so we make better use of resources
258 // Note, this also internally creates the render tasks used by the Gaussian blur, this must occur after the bloom extraction and before the compositing
259 mGaussianBlurView = Dali::Toolkit::GaussianBlurView::New(mBlurNumSamples, mBlurBellCurveWidth, mPixelFormat, mDownsampleWidthScale, mDownsampleHeightScale, true);
260 mGaussianBlurView.SetParentOrigin( ParentOrigin::CENTER );
263 //////////////////////////////////////////////////////
264 // Create cameras for the renders corresponding to the (potentially downsampled) render targets' size
265 mRenderDownsampledCamera = CameraActor::New();
266 mRenderDownsampledCamera.SetParentOrigin(ParentOrigin::CENTER);
267 mRenderDownsampledCamera.SetInvertYAxis( true );
269 mRenderFullSizeCamera = CameraActor::New();
270 mRenderFullSizeCamera.SetParentOrigin(ParentOrigin::CENTER);
271 mRenderFullSizeCamera.SetInvertYAxis( true );
274 ////////////////////////////////
275 // Connect to actor tree
276 Self().Add( mChildrenRoot );
277 Self().Add( mInternalRoot );
278 mInternalRoot.Add( mBloomExtractImageActor );
279 mInternalRoot.Add( mGaussianBlurView );
280 mInternalRoot.Add( mCompositeImageActor );
281 mInternalRoot.Add( mTargetImageActor );
282 mInternalRoot.Add( mRenderDownsampledCamera );
283 mInternalRoot.Add( mRenderFullSizeCamera );
285 // bind properties for / set shader constants to defaults
289 void BloomView::OnSizeSet(const Vector3& targetSize)
291 Control::OnSizeSet( targetSize );
293 mTargetSize = Vector2(targetSize);
294 mChildrenRoot.SetSize(targetSize);
295 mCompositeImageActor.SetSize(targetSize);
296 mTargetImageActor.SetSize(targetSize);
298 // Children render camera must move when GaussianBlurView object is
299 // resized. This is since we cannot change render target size - so we need
300 // to remap the child actors' rendering accordingly so they still exactly
301 // fill the render target. Note that this means the effective resolution of
302 // the child render changes as the GaussianBlurView object changes size,
303 // this is the trade off for not being able to modify render target size
304 // Change camera z position based on GaussianBlurView actor height
305 float cameraPosConstraintScale = 0.5f / tanf(ARBITRARY_FIELD_OF_VIEW * 0.5f);
306 mRenderFullSizeCamera.SetZ( mTargetSize.height * cameraPosConstraintScale);
308 // if we have already activated the blur, need to update render target sizes now to reflect the new size of this actor
316 void BloomView::OnChildAdd( Actor& child )
318 Control::OnChildAdd( child );
320 if( child != mChildrenRoot && child != mInternalRoot)
322 mChildrenRoot.Add( child );
326 void BloomView::OnChildRemove( Actor& child )
328 mChildrenRoot.Remove( child );
330 Control::OnChildRemove( child );
333 void BloomView::AllocateResources()
335 // size of render targets etc is based on the size of this actor, ignoring z
336 if(mTargetSize != mLastSize || !mActivated)
338 mLastSize = mTargetSize;
340 // get size of downsampled render targets
341 mDownsampledWidth = mTargetSize.width * mDownsampleWidthScale;
342 mDownsampledHeight = mTargetSize.height * mDownsampleHeightScale;
345 //////////////////////////////////////////////////////
348 // Create and place a camera for the renders corresponding to the (potentially downsampled) render targets' size
349 mRenderDownsampledCamera.SetFieldOfView(ARBITRARY_FIELD_OF_VIEW);
350 // TODO: how do we pick a reasonable value for near clip? Needs to relate to normal camera the user renders with, but we don't have a handle on it
351 mRenderDownsampledCamera.SetNearClippingPlane(1.0f);
352 mRenderDownsampledCamera.SetAspectRatio(mDownsampledWidth / mDownsampledHeight);
353 mRenderDownsampledCamera.SetType(Dali::Camera::FREE_LOOK); // camera orientation based solely on actor
355 mRenderDownsampledCamera.SetPosition(0.0f, 0.0f, ((mDownsampledHeight * 0.5f) / tanf(ARBITRARY_FIELD_OF_VIEW * 0.5f)));
357 // Create and place a camera for the children render, corresponding to its render target size
358 mRenderFullSizeCamera.SetFieldOfView(ARBITRARY_FIELD_OF_VIEW);
359 // TODO: how do we pick a reasonable value for near clip? Needs to relate to normal camera the user renders with, but we don't have a handle on it
360 mRenderFullSizeCamera.SetNearClippingPlane(1.0f);
361 mRenderFullSizeCamera.SetAspectRatio(mTargetSize.width / mTargetSize.height);
362 mRenderFullSizeCamera.SetType(Dali::Camera::FREE_LOOK); // camera orientation based solely on actor
364 float cameraPosConstraintScale = 0.5f / tanf(ARBITRARY_FIELD_OF_VIEW * 0.5f);
365 mRenderFullSizeCamera.SetPosition(0.0f, 0.0f, mTargetSize.height * cameraPosConstraintScale);
367 //////////////////////////////////////////////////////
368 // Pass size change onto GaussianBlurView, so it matches
369 mGaussianBlurView.SetSize(mTargetSize);
370 GetImpl(mGaussianBlurView).AllocateResources();
373 //////////////////////////////////////////////////////
374 // Create render targets
376 // create off screen buffer of new size to render our child actors to
377 mRenderTargetForRenderingChildren = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::UNUSED );
378 mBloomExtractTarget = FrameBufferImage::New( mDownsampledWidth, mDownsampledHeight, mPixelFormat, Dali::Image::UNUSED );
379 FrameBufferImage mBlurExtractTarget = FrameBufferImage::New( mDownsampledWidth, mDownsampledHeight, mPixelFormat, Dali::Image::UNUSED );
380 mOutputRenderTarget = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::UNUSED);
383 //////////////////////////////////////////////////////
384 // Point actors and render tasks at new render targets
386 mBloomExtractImageActor.SetImage( mRenderTargetForRenderingChildren );
387 mBloomExtractImageActor.SetSize(mDownsampledWidth, mDownsampledHeight); // size needs to match render target
389 // set GaussianBlurView to blur our extracted bloom
390 mGaussianBlurView.SetUserImageAndOutputRenderTarget(mBloomExtractTarget, mBlurExtractTarget);
392 // use the completed blur in the first buffer and composite with the original child actors render
393 mCompositeImageActor.SetImage( mRenderTargetForRenderingChildren );
394 TextureSet textureSet = mCompositeImageActor.GetRendererAt(0).GetTextures();
395 textureSet.SetImage( 1u, mBlurExtractTarget );
397 // set up target actor for rendering result, i.e. the blurred image
398 mTargetImageActor.SetImage(mOutputRenderTarget);
402 void BloomView::CreateRenderTasks()
404 RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
406 // create render task to render our child actors to offscreen buffer
407 mRenderChildrenTask = taskList.CreateTask();
408 mRenderChildrenTask.SetSourceActor( mChildrenRoot );
409 mRenderChildrenTask.SetExclusive(true);
410 mRenderChildrenTask.SetInputEnabled( false );
411 mRenderChildrenTask.SetClearEnabled( true );
412 mRenderChildrenTask.SetCameraActor(mRenderFullSizeCamera); // use camera that covers render target exactly
413 mRenderChildrenTask.SetTargetFrameBuffer( mRenderTargetForRenderingChildren );
415 // Extract the bright part of the image and render to a new buffer. Downsampling also occurs at this stage to save pixel fill, if it is set up.
416 mBloomExtractTask = taskList.CreateTask();
417 mBloomExtractTask.SetSourceActor( mBloomExtractImageActor );
418 mBloomExtractTask.SetExclusive(true);
419 mBloomExtractTask.SetInputEnabled( false );
420 mBloomExtractTask.SetClearEnabled( true );
421 mBloomExtractTask.SetCameraActor(mRenderDownsampledCamera);
422 mBloomExtractTask.SetTargetFrameBuffer( mBloomExtractTarget );
424 // GaussianBlurView tasks must be created here, so they are executed in the correct order with respect to BloomView tasks
425 GetImpl(mGaussianBlurView).CreateRenderTasks();
427 // Use an image actor displaying the children render and composite it with the blurred bloom buffer, targeting the output
428 mCompositeTask = taskList.CreateTask();
429 mCompositeTask.SetSourceActor( mCompositeImageActor );
430 mCompositeTask.SetExclusive(true);
431 mCompositeTask.SetInputEnabled( false );
432 mCompositeTask.SetClearEnabled( true );
433 mCompositeTask.SetCameraActor(mRenderFullSizeCamera);
434 mCompositeTask.SetTargetFrameBuffer( mOutputRenderTarget );
437 void BloomView::RemoveRenderTasks()
439 RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
441 taskList.RemoveTask(mRenderChildrenTask);
442 taskList.RemoveTask(mBloomExtractTask);
444 GetImpl(mGaussianBlurView).RemoveRenderTasks();
446 taskList.RemoveTask(mCompositeTask);
449 void BloomView::Activate()
451 // make sure resources are allocated and start the render tasks processing
457 void BloomView::Deactivate()
459 // stop render tasks processing
460 // Note: render target resources are automatically freed since we set the Image::Unused flag
462 mRenderTargetForRenderingChildren.Reset();
463 mBloomExtractTarget.Reset();
464 mOutputRenderTarget.Reset();
469 * RecipOneMinusConstraint
471 * f(current, property) = property
473 struct RecipOneMinusConstraint
475 RecipOneMinusConstraint(){}
477 void operator()( float& current, const PropertyInputContainer& inputs )
479 current = 1.0f / ( 1.0f - inputs[0]->GetFloat() );
483 // create properties and constraints to tie internal shader etc settings to BloomView object. User can therefore animate / set them via BloomView object without knowing about
484 // internal implementation classes
485 void BloomView::SetupProperties()
487 CustomActor self = Self();
490 ///////////////////////////////////////////
493 // set defaults, makes sure properties are registered with shader
494 mBloomExtractImageActor.RegisterProperty( BLOOM_THRESHOLD_PROPERTY_NAME, BLOOM_THRESHOLD_DEFAULT );
495 mBloomExtractImageActor.RegisterProperty( RECIP_ONE_MINUS_BLOOM_THRESHOLD_PROPERTY_NAME, 1.0f / (1.0f - BLOOM_THRESHOLD_DEFAULT) );
497 // Register a property that the user can control to change the bloom threshold
498 mBloomThresholdPropertyIndex = self.RegisterProperty(BLOOM_THRESHOLD_PROPERTY_NAME, BLOOM_THRESHOLD_DEFAULT);
499 Property::Index shaderBloomThresholdPropertyIndex = mBloomExtractImageActor.GetPropertyIndex(BLOOM_THRESHOLD_PROPERTY_NAME);
500 Constraint bloomThresholdConstraint = Constraint::New<float>( mBloomExtractImageActor, shaderBloomThresholdPropertyIndex, EqualToConstraint());
501 bloomThresholdConstraint.AddSource( Source(self, mBloomThresholdPropertyIndex) );
502 bloomThresholdConstraint.Apply();
504 // precalc 1.0 / (1.0 - threshold) on CPU to save shader insns, using constraint to tie to the normal threshold property
505 Property::Index shaderRecipOneMinusBloomThresholdPropertyIndex = mBloomExtractImageActor.GetPropertyIndex(RECIP_ONE_MINUS_BLOOM_THRESHOLD_PROPERTY_NAME);
506 Constraint thresholdConstraint = Constraint::New<float>( mBloomExtractImageActor, shaderRecipOneMinusBloomThresholdPropertyIndex, RecipOneMinusConstraint());
507 thresholdConstraint.AddSource( LocalSource(shaderBloomThresholdPropertyIndex) );
508 thresholdConstraint.Apply();
511 ////////////////////////////////////////////
514 // Register a property that the user can control to fade the blur in / out via internal GaussianBlurView object
515 mBlurStrengthPropertyIndex = self.RegisterProperty(BLOOM_BLUR_STRENGTH_PROPERTY_NAME, BLOOM_BLUR_STRENGTH_DEFAULT);
516 Constraint blurStrengthConstraint = Constraint::New<float>( mGaussianBlurView, mGaussianBlurView.GetBlurStrengthPropertyIndex(), EqualToConstraint());
517 blurStrengthConstraint.AddSource( Source(self, mBlurStrengthPropertyIndex) );
518 blurStrengthConstraint.Apply();
521 ////////////////////////////////////////////
524 // Register a property that the user can control to fade the bloom intensity via internally hidden shader
525 mBloomIntensityPropertyIndex = self.RegisterProperty(BLOOM_INTENSITY_PROPERTY_NAME, BLOOM_INTENSITY_DEFAULT);
526 mCompositeImageActor.RegisterProperty( BLOOM_INTENSITY_PROPERTY_NAME, BLOOM_INTENSITY_DEFAULT );
527 Property::Index shaderBloomIntensityPropertyIndex = mCompositeImageActor.GetPropertyIndex(BLOOM_INTENSITY_PROPERTY_NAME);
528 Constraint bloomIntensityConstraint = Constraint::New<float>( mCompositeImageActor, shaderBloomIntensityPropertyIndex, EqualToConstraint());
529 bloomIntensityConstraint.AddSource( Source(self, mBloomIntensityPropertyIndex) );
530 bloomIntensityConstraint.Apply();
533 ////////////////////////////////////////////
536 // Register a property that the user can control to fade the bloom saturation via internally hidden shader
537 mBloomSaturationPropertyIndex = self.RegisterProperty(BLOOM_SATURATION_PROPERTY_NAME, BLOOM_SATURATION_DEFAULT);
538 mCompositeImageActor.RegisterProperty( BLOOM_SATURATION_PROPERTY_NAME, BLOOM_SATURATION_DEFAULT );
539 Property::Index shaderBloomSaturationPropertyIndex = mCompositeImageActor.GetPropertyIndex(BLOOM_SATURATION_PROPERTY_NAME);
540 Constraint bloomSaturationConstraint = Constraint::New<float>( mCompositeImageActor, shaderBloomSaturationPropertyIndex, EqualToConstraint());
541 bloomSaturationConstraint.AddSource( Source(self, mBloomSaturationPropertyIndex) );
542 bloomSaturationConstraint.Apply();
545 ////////////////////////////////////////////
548 // Register a property that the user can control to fade the image intensity via internally hidden shader
549 mImageIntensityPropertyIndex = self.RegisterProperty(IMAGE_INTENSITY_PROPERTY_NAME, IMAGE_INTENSITY_DEFAULT);
550 mCompositeImageActor.RegisterProperty( IMAGE_INTENSITY_PROPERTY_NAME, IMAGE_INTENSITY_DEFAULT );
551 Property::Index shaderImageIntensityPropertyIndex = mCompositeImageActor.GetPropertyIndex(IMAGE_INTENSITY_PROPERTY_NAME);
552 Constraint imageIntensityConstraint = Constraint::New<float>( mCompositeImageActor, shaderImageIntensityPropertyIndex, EqualToConstraint());
553 imageIntensityConstraint.AddSource( Source(self, mImageIntensityPropertyIndex) );
554 imageIntensityConstraint.Apply();
557 ////////////////////////////////////////////
560 // Register a property that the user can control to fade the image saturation via internally hidden shader
561 mImageSaturationPropertyIndex = self.RegisterProperty(IMAGE_SATURATION_PROPERTY_NAME, IMAGE_SATURATION_DEFAULT);
562 mCompositeImageActor.RegisterProperty( IMAGE_SATURATION_PROPERTY_NAME, IMAGE_SATURATION_DEFAULT );
563 Property::Index shaderImageSaturationPropertyIndex = mCompositeImageActor.GetPropertyIndex(IMAGE_SATURATION_PROPERTY_NAME);
564 Constraint imageSaturationConstraint = Constraint::New<float>( mCompositeImageActor, shaderImageSaturationPropertyIndex, EqualToConstraint());
565 imageSaturationConstraint.AddSource( Source(self, mImageSaturationPropertyIndex) );
566 imageSaturationConstraint.Apply();
569 } // namespace Internal
571 } // namespace Toolkit