optional/dali-toolkit/internal/controls/bloom-view/bloom-view-impl.cpp

   1 //
   2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.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
   7 //
   8 //     http://floralicense.org/license/
   9 //
  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.
  15 //
  16
  17 // CLASS HEADER
  18 #include "bloom-view-impl.h"
  19 #include "../gaussian-blur-view/gaussian-blur-view-impl.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <sstream>
  23 #include <iomanip>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali-toolkit/public-api/controls/gaussian-blur-view/gaussian-blur-view.h>
  27 #include <dali-toolkit/public-api/controls/bloom-view/bloom-view.h>
  28
  29 namespace Dali
  30 {
  31
  32 namespace Toolkit
  33 {
  34
  35 namespace Internal
  36 {
  37
  38 namespace
  39 {
  40
  41 using namespace Dali;
  42
  43 BaseHandle Create()
  44 {
  45   return Toolkit::BloomView::New();
  46 }
  47
  48 TypeRegistration mType( typeid(Toolkit::BloomView), typeid(Toolkit::Control), Create );
  49
  50 // default parameters
  51 const float BLOOM_THRESHOLD_DEFAULT = 0.25f;
  52 const float BLOOM_BLUR_STRENGTH_DEFAULT = 1.0f;
  53 const float BLOOM_INTENSITY_DEFAULT = 1.0f;
  54 const float IMAGE_INTENSITY_DEFAULT = 1.0f;
  55 const float BLOOM_SATURATION_DEFAULT = 1.0f;
  56 const float IMAGE_SATURATION_DEFAULT = 1.0f;
  57
  58 // gaussian blur
  59 const unsigned int BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_NUM_SAMPLES = 5;
  60 const float BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_BELL_CURVE_WIDTH = 1.5f;
  61 const Pixel::Format BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_RENDER_TARGET_PIXEL_FORMAT = Pixel::RGBA8888;
  62 const float BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_FADE_IN = 1.0f;                                       // default, fully blurred
  63 const float BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_WIDTH_SCALE = 0.5f;
  64 const float BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_HEIGHT_SCALE = 0.5f;
  65
  66 const float ARBITRARY_FIELD_OF_VIEW = Math::PI / 4.0f;
  67
  68 const std::string BLOOM_BLUR_STRENGTH_PROPERTY_NAME( "BlurStrengthProperty" );
  69
  70 const std::string BLOOM_THRESHOLD_PROPERTY_NAME( "uBloomThreshold" );
  71 const std::string RECIP_ONE_MINUS_BLOOM_THRESHOLD_PROPERTY_NAME( "uRecipOneMinusBloomThreshold" );
  72 const std::string BLOOM_INTENSITY_PROPERTY_NAME( "uBloomIntensity" );
  73 const std::string BLOOM_SATURATION_PROPERTY_NAME( "uBloomSaturation" );
  74 const std::string IMAGE_INTENSITY_PROPERTY_NAME( "uImageIntensity" );
  75 const std::string IMAGE_SATURATION_PROPERTY_NAME( "uImageSaturation" );
  76
  77 ///////////////////////////////////////////////////////
  78 //
  79 // Bloom shaders
  80 //
  81
  82 const char* const BLOOM_EXTRACT_FRAGMENT_SOURCE =
  83   "uniform float uBloomThreshold;\n"
  84   "uniform float uRecipOneMinusBloomThreshold;\n"
  85   "void main()\n"
  86   "{\n"
  87   "  mediump vec4 col;\n"
  88   "  col = texture2D(sTexture, vec2(vTexCoord.x, vTexCoord.y));\n"
  89   "  col = (col - uBloomThreshold) * uRecipOneMinusBloomThreshold;\n" // remove intensities lower than the thresold and remap intensities above the threshold to [0..1]
  90   "  gl_FragColor = clamp(col, 0.0, 1.0);\n"
  91   "}\n";
  92
  93 const char* const COMPOSITE_FRAGMENT_SOURCE =
  94   "uniform float uBloomIntensity;\n"
  95   "uniform float uImageIntensity;\n"
  96   "uniform float uBloomSaturation;\n"
  97   "uniform float uImageSaturation;\n"
  98
  99   "vec4 ChangeSaturation(vec4 col, float sat)\n"
 100   "{\n"
 101   "  float grey = dot(col.rgb, vec3(0.3, 0.6, 0.1));\n"
 102   "  return mix(vec4(grey, grey, grey, 1.0), col, sat);\n"
 103   "}\n"
 104
 105   "void main()\n"
 106   "{\n"
 107   "  mediump vec4 image;\n"
 108   "  mediump vec4 bloom;\n"
 109   "  image = texture2D(sTexture, vec2(vTexCoord.x, vTexCoord.y));\n"
 110   "  bloom = texture2D(sEffect, vec2(vTexCoord.x, vTexCoord.y));\n"
 111   "  image = ChangeSaturation(image, uImageSaturation) * uImageIntensity;\n"
 112   "  bloom = ChangeSaturation(bloom, uBloomSaturation) * uBloomIntensity;\n"
 113   "  image *= 1.0 - clamp(bloom, 0.0, 1.0);\n" // darken base where bloom is strong, to prevent excessive burn-out of result
 114   "  gl_FragColor = image + bloom;\n"
 115   "}\n";
 116
 117 } // namespace
 118
 119
 120
 121 BloomView::BloomView()
 122   : ControlImpl( false )  // doesn't require touch events
 123   , mBlurNumSamples(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_NUM_SAMPLES)
 124   , mBlurBellCurveWidth(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_BELL_CURVE_WIDTH)
 125   , mPixelFormat(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_RENDER_TARGET_PIXEL_FORMAT)
 126   , mDownsampleWidthScale(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_WIDTH_SCALE)
 127   , mDownsampleHeightScale(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_HEIGHT_SCALE)
 128   , mDownsampledWidth( 0.0f )
 129   , mDownsampledHeight( 0.0f )
 130   , mTargetSize(Vector2::ZERO)
 131   , mLastSize(Vector2::ZERO)
 132   , mChildrenRoot(Actor::New())
 133   , mBloomThresholdPropertyIndex(Property::INVALID_INDEX)
 134   , mBlurStrengthPropertyIndex(Property::INVALID_INDEX)
 135   , mBloomIntensityPropertyIndex(Property::INVALID_INDEX)
 136   , mBloomSaturationPropertyIndex(Property::INVALID_INDEX)
 137   , mImageIntensityPropertyIndex(Property::INVALID_INDEX)
 138   , mImageSaturationPropertyIndex(Property::INVALID_INDEX)
 139 {
 140 }
 141
 142 BloomView::BloomView( const unsigned int blurNumSamples, const float blurBellCurveWidth, const Pixel::Format renderTargetPixelFormat,
 143                                     const float downsampleWidthScale, const float downsampleHeightScale)
 144   : ControlImpl( false )  // doesn't require touch events
 145   , mBlurNumSamples(blurNumSamples)
 146   , mBlurBellCurveWidth(blurBellCurveWidth)
 147   , mPixelFormat(renderTargetPixelFormat)
 148   , mDownsampleWidthScale(downsampleWidthScale)
 149   , mDownsampleHeightScale(downsampleHeightScale)
 150   , mDownsampledWidth( 0.0f )
 151   , mDownsampledHeight( 0.0f )
 152   , mTargetSize(Vector2::ZERO)
 153   , mLastSize(Vector2::ZERO)
 154   , mChildrenRoot(Actor::New())
 155   , mBloomThresholdPropertyIndex(Property::INVALID_INDEX)
 156   , mBlurStrengthPropertyIndex(Property::INVALID_INDEX)
 157   , mBloomIntensityPropertyIndex(Property::INVALID_INDEX)
 158   , mBloomSaturationPropertyIndex(Property::INVALID_INDEX)
 159   , mImageIntensityPropertyIndex(Property::INVALID_INDEX)
 160   , mImageSaturationPropertyIndex(Property::INVALID_INDEX)
 161 {
 162 }
 163
 164 BloomView::~BloomView()
 165 {
 166 }
 167
 168 Toolkit::BloomView BloomView::New()
 169 {
 170   BloomView* impl = new BloomView();
 171
 172   Dali::Toolkit::BloomView handle = Dali::Toolkit::BloomView( *impl );
 173
 174   // Second-phase init of the implementation
 175   // This can only be done after the CustomActor connection has been made...
 176   impl->Initialize();
 177
 178   return handle;
 179 }
 180
 181 Toolkit::BloomView BloomView::New(const unsigned int blurNumSamples, const float blurBellCurveWidth, const Pixel::Format renderTargetPixelFormat,
 182                                                 const float downsampleWidthScale, const float downsampleHeightScale)
 183 {
 184   BloomView* impl = new BloomView( blurNumSamples, blurBellCurveWidth, renderTargetPixelFormat, downsampleWidthScale, downsampleHeightScale);
 185
 186   Dali::Toolkit::BloomView handle = Dali::Toolkit::BloomView( *impl );
 187
 188   // Second-phase init of the implementation
 189   // This can only be done after the CustomActor connection has been made...
 190   impl->Initialize();
 191
 192   return handle;
 193 }
 194
 195 /////////////////////////////////////////////////////////////
 196 // for creating a subtree for all user added child actors, so that we can have them exclusive to the mRenderChildrenTask and our other actors exclusive to our other tasks
 197 // TODO: overloading Actor::Add()/Remove() not nice since breaks polymorphism. Need another method to pass ownership of added child actors to our internal actor root.
 198 void BloomView::Add(Actor child)
 199 {
 200   mChildrenRoot.Add(child);
 201 }
 202
 203 void BloomView::Remove(Actor child)
 204 {
 205   mChildrenRoot.Remove(child);
 206 }
 207
 208
 209
 210
 211
 212
 213 ///////////////////////////////////////////////////////////
 214 //
 215 // Private methods
 216 //
 217
 218 void BloomView::OnInitialize()
 219 {
 220   // root actor to parent all user added actors, needed to allow us to set that subtree as exclusive for our child render task
 221   mChildrenRoot.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION );
 222   mChildrenRoot.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) ); // same size as BloomView object
 223
 224
 225   //////////////////////////////////////////////////////
 226   // Create shaders
 227
 228   // Create shader used for extracting the bright parts of an image
 229   mBloomExtractShader = ShaderEffect::New( "", BLOOM_EXTRACT_FRAGMENT_SOURCE );
 230
 231   // Create shader used to composite bloom and original image to output render target
 232   mCompositeShader = ShaderEffect::New( "", COMPOSITE_FRAGMENT_SOURCE );
 233
 234
 235   //////////////////////////////////////////////////////
 236   // Create actors
 237
 238   // Create an ImageActor for rendering from the scene texture to the bloom texture
 239   mBloomExtractImageActor = ImageActor::New();
 240   mBloomExtractImageActor.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION );
 241   mBloomExtractImageActor.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) ); // FIXME
 242   mBloomExtractImageActor.SetShaderEffect( mBloomExtractShader );
 243
 244   // Create an ImageActor for compositing the result (scene and bloom textures) to output
 245   mCompositeImageActor = ImageActor::New();
 246   mCompositeImageActor.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION );
 247   mCompositeImageActor.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) ); // same size as BloomView object
 248   mCompositeImageActor.SetShaderEffect( mCompositeShader );
 249   mCompositeImageActor.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) ); // FIXME
 250
 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 = ImageActor::New();
 253   mTargetImageActor.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION );
 254   mTargetImageActor.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) ); // same size as BloomView object
 255   mTargetImageActor.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) ); // FIXME
 256
 257
 258   // Create the Gaussian Blur object + render tasks
 259   // 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
 260   // render targets etc internally, so we make better use of resources
 261   // Note, this also internally creates the render tasks used by the Gaussian blur, this must occur after the bloom extraction and before the compositing
 262   mGaussianBlurView = Dali::Toolkit::GaussianBlurView::New(mBlurNumSamples, mBlurBellCurveWidth, mPixelFormat, mDownsampleWidthScale, mDownsampleHeightScale, true);
 263   mGaussianBlurView.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION );
 264
 265
 266   //////////////////////////////////////////////////////
 267   // Create cameras for the renders corresponding to the (potentially downsampled) render targets' size
 268   mRenderDownsampledCamera = CameraActor::New();
 269   mRenderDownsampledCamera.SetParentOrigin(ParentOrigin::CENTER);
 270
 271   mRenderFullSizeCamera = CameraActor::New();
 272   mRenderFullSizeCamera.SetParentOrigin(ParentOrigin::CENTER);
 273
 274
 275   ////////////////////////////////
 276   // Connect to actor tree
 277   Self().Add( mChildrenRoot );
 278   Self().Add( mBloomExtractImageActor );
 279   Self().Add( mGaussianBlurView );
 280   Self().Add( mCompositeImageActor );
 281   Self().Add( mTargetImageActor );
 282   Self().Add( mRenderDownsampledCamera );
 283   Self().Add( mRenderFullSizeCamera );
 284
 285   // bind properties for / set shader constants to defaults
 286   SetupProperties();
 287 }
 288
 289 /**
 290  * ZrelativeToYconstraint
 291  *
 292  * f(current, property, scale) = Vector3(current.x, current.y, property.y * scale)
 293  */
 294 struct ZrelativeToYconstraint
 295 {
 296   ZrelativeToYconstraint( float scale )
 297     : mScale( scale )
 298   {}
 299
 300   Vector3 operator()(const Vector3&    current,
 301                      const PropertyInput& property)
 302   {
 303     Vector3 v;
 304
 305     v.x = current.x;
 306     v.y = current.y;
 307     v.z = property.GetVector3().y * mScale;
 308
 309     return v;
 310   }
 311
 312   float mScale;
 313 };
 314
 315 void BloomView::OnControlSizeSet(const Vector3& targetSize)
 316 {
 317   mTargetSize = Vector2(targetSize);
 318
 319   // if we are already on stage, need to update render target sizes now to reflect the new size of this actor
 320   if(Self().OnStage())
 321   {
 322     AllocateResources();
 323   }
 324 }
 325
 326 void BloomView::AllocateResources()
 327 {
 328   // size of render targets etc is based on the size of this actor, ignoring z
 329   if(mTargetSize != mLastSize)
 330   {
 331     mLastSize = mTargetSize;
 332
 333     // get size of downsampled render targets
 334     mDownsampledWidth = mTargetSize.width * mDownsampleWidthScale;
 335     mDownsampledHeight = mTargetSize.height * mDownsampleHeightScale;
 336
 337
 338     //////////////////////////////////////////////////////
 339     // Create cameras
 340
 341     // Create and place a camera for the renders corresponding to the (potentially downsampled) render targets' size
 342     mRenderDownsampledCamera.SetFieldOfView(ARBITRARY_FIELD_OF_VIEW);
 343     // 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
 344     mRenderDownsampledCamera.SetNearClippingPlane(1.0f);
 345     mRenderDownsampledCamera.SetAspectRatio(mDownsampledWidth / mDownsampledHeight);
 346     mRenderDownsampledCamera.SetType(Dali::Camera::FREE_LOOK); // camera orientation based solely on actor
 347     mRenderDownsampledCamera.SetRotation(Quaternion(M_PI, Vector3::YAXIS)); // Rotate to look at origin
 348
 349     mRenderDownsampledCamera.SetPosition(0.0f, 0.0f, ((mDownsampledHeight * 0.5f) / tanf(ARBITRARY_FIELD_OF_VIEW * 0.5f)));
 350
 351     // Create and place a camera for the children render, corresponding to its render target size
 352     mRenderFullSizeCamera.SetFieldOfView(ARBITRARY_FIELD_OF_VIEW);
 353     // 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
 354     mRenderFullSizeCamera.SetNearClippingPlane(1.0f);
 355     mRenderFullSizeCamera.SetAspectRatio(mTargetSize.width / mTargetSize.height);
 356     mRenderFullSizeCamera.SetType(Dali::Camera::FREE_LOOK); // camera orientation based solely on actor
 357     mRenderFullSizeCamera.SetRotation(Quaternion(M_PI, Vector3::YAXIS)); // Rotate to look at origin
 358
 359     float cameraPosConstraintScale = 0.5f / tanf(ARBITRARY_FIELD_OF_VIEW * 0.5f);
 360     mRenderFullSizeCamera.SetPosition(0.0f, 0.0f, mTargetSize.height * cameraPosConstraintScale);
 361
 362
 363     // Children render camera must move when GaussianBlurView object is
 364     // resized. This is since we cannot change render target size - so we need
 365     // to remap the child actors' rendering accordingly so they still exactly
 366     // fill the render target. Note that this means the effective resolution of
 367     // the child render changes as the GaussianBlurView object changes size,
 368     // this is the trade off for not being able to modify render target size
 369     // Change camera z position based on GaussianBlurView actor height
 370
 371     mRenderFullSizeCamera.RemoveConstraints();
 372     mRenderFullSizeCamera.ApplyConstraint( Constraint::New<Vector3>( Actor::POSITION, ParentSource( Actor::SIZE ), ZrelativeToYconstraint(cameraPosConstraintScale) ) );
 373
 374
 375     //////////////////////////////////////////////////////
 376     // Pass size change onto GaussianBlurView, so it matches
 377     mGaussianBlurView.SetSize(mTargetSize);
 378     GetImpl(mGaussianBlurView).AllocateResources();
 379
 380
 381     //////////////////////////////////////////////////////
 382     // Create render targets
 383
 384     // create off screen buffer of new size to render our child actors to
 385     mRenderTargetForRenderingChildren = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::Unused );
 386     mBloomExtractTarget = FrameBufferImage::New( mDownsampledWidth, mDownsampledHeight, mPixelFormat, Dali::Image::Unused );
 387     mOutputRenderTarget = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::Unused );
 388
 389
 390     //////////////////////////////////////////////////////
 391     // Point actors and render tasks at new render targets
 392
 393     mBloomExtractImageActor.SetImage( mRenderTargetForRenderingChildren );
 394     mBloomExtractImageActor.SetSize(mDownsampledWidth, mDownsampledHeight); // size needs to match render target
 395
 396     // set GaussianBlurView to blur our extracted bloom
 397     mGaussianBlurView.SetUserImageAndOutputRenderTarget(mBloomExtractTarget, mBloomExtractTarget);
 398
 399     // use the completed blur in the first buffer and composite with the original child actors render
 400     mCompositeImageActor.SetImage( mRenderTargetForRenderingChildren );
 401     mCompositeShader.SetEffectImage( mBloomExtractTarget );
 402
 403     // set up target actor for rendering result, i.e. the blurred image
 404     mTargetImageActor.SetImage(mOutputRenderTarget);
 405   }
 406 }
 407
 408 void BloomView::CreateRenderTasks()
 409 {
 410   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 411
 412   // create render task to render our child actors to offscreen buffer
 413   mRenderChildrenTask = taskList.CreateTask();
 414   mRenderChildrenTask.SetSourceActor( mChildrenRoot );
 415   mRenderChildrenTask.SetExclusive(true);
 416   mRenderChildrenTask.SetInputEnabled( false );
 417   mRenderChildrenTask.SetClearEnabled( true );
 418
 419   // 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.
 420   mBloomExtractTask = taskList.CreateTask();
 421   mBloomExtractTask.SetSourceActor( mBloomExtractImageActor );
 422   mBloomExtractTask.SetExclusive(true);
 423   mBloomExtractTask.SetInputEnabled( false );
 424   mBloomExtractTask.SetClearEnabled( true );
 425
 426   // GaussianBlurView tasks must be created here, so they are executed in the correct order with respect to BloomView tasks
 427   GetImpl(mGaussianBlurView).CreateRenderTasks();
 428
 429   // Use an image actor displaying the children render and composite it with the blurred bloom buffer, targeting the output
 430   mCompositeTask = taskList.CreateTask();
 431   mCompositeTask.SetSourceActor( mCompositeImageActor );
 432   mCompositeTask.SetExclusive(true);
 433   mCompositeTask.SetInputEnabled( false );
 434   mCompositeTask.SetClearEnabled( true );
 435
 436   mRenderChildrenTask.SetCameraActor(mRenderFullSizeCamera); // use camera that covers render target exactly
 437   mBloomExtractTask.SetCameraActor(mRenderDownsampledCamera);
 438   mCompositeTask.SetCameraActor(mRenderFullSizeCamera);
 439
 440   mRenderChildrenTask.SetTargetFrameBuffer( mRenderTargetForRenderingChildren );
 441   mBloomExtractTask.SetTargetFrameBuffer( mBloomExtractTarget );
 442   mCompositeTask.SetTargetFrameBuffer( mOutputRenderTarget );
 443 }
 444
 445 void BloomView::RemoveRenderTasks()
 446 {
 447   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 448
 449   taskList.RemoveTask(mRenderChildrenTask);
 450   taskList.RemoveTask(mBloomExtractTask);
 451
 452   GetImpl(mGaussianBlurView).RemoveRenderTasks();
 453
 454   taskList.RemoveTask(mCompositeTask);
 455 }
 456
 457 void BloomView::OnStageDisconnection()
 458 {
 459   // TODO: can't call this here, since SetImage() calls fails similarly to above
 460   // Need to fix the stage connection so this callback can be used arbitrarily. At that point we  can simplify the API by removing the need for Activate() / Deactivate()
 461   //Deactivate();
 462 }
 463
 464 void BloomView::OnControlStageConnection()
 465 {
 466   // TODO: can't call this here, since SetImage() calls fail to connect images to stage, since parent chain not fully on stage yet
 467   // Need to fix the stage connection so this callback can be used arbitrarily. At that point we  can simplify the API by removing the need for Activate() / Deactivate()
 468   //Activate();
 469 }
 470
 471 void BloomView::Activate()
 472 {
 473   // make sure resources are allocated and start the render tasks processing
 474   AllocateResources();
 475   CreateRenderTasks();
 476 }
 477
 478 void BloomView::Deactivate()
 479 {
 480   // stop render tasks processing
 481   // Note: render target resources are automatically freed since we set the Image::Unused flag
 482   RemoveRenderTasks();
 483 }
 484
 485 /**
 486  * EqualToConstraintFloat
 487  *
 488  * f(current, property) = property
 489  */
 490 struct EqualToConstraintFloat
 491 {
 492   EqualToConstraintFloat(){}
 493
 494   float operator()(const float current, const PropertyInput& property) {return property.GetFloat();}
 495 };
 496
 497 /**
 498  * RecipOneMinusConstraint
 499  *
 500  * f(current, property) = property
 501  */
 502 struct RecipOneMinusConstraint
 503 {
 504   RecipOneMinusConstraint(){}
 505
 506   float operator()(const float current, const PropertyInput& property)
 507   {
 508     return 1.0f / (1.0f - property.GetFloat());
 509   }
 510 };
 511
 512 // 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
 513 // internal implementation classes
 514 void BloomView::SetupProperties()
 515 {
 516   CustomActor self = Self();
 517
 518
 519   ///////////////////////////////////////////
 520   // bloom threshold
 521
 522   // set defaults, makes sure properties are registered with shader
 523   mBloomExtractShader.SetUniform( BLOOM_THRESHOLD_PROPERTY_NAME, BLOOM_THRESHOLD_DEFAULT );
 524   mBloomExtractShader.SetUniform( RECIP_ONE_MINUS_BLOOM_THRESHOLD_PROPERTY_NAME, 1.0f / (1.0f - BLOOM_THRESHOLD_DEFAULT) );
 525
 526   // Register a property that the user can control to change the bloom threshold
 527   mBloomThresholdPropertyIndex = self.RegisterProperty(BLOOM_THRESHOLD_PROPERTY_NAME, BLOOM_THRESHOLD_DEFAULT);
 528   Property::Index shaderBloomThresholdPropertyIndex = mBloomExtractShader.GetPropertyIndex(BLOOM_THRESHOLD_PROPERTY_NAME);
 529   Constraint bloomThresholdConstraint = Constraint::New<float>(shaderBloomThresholdPropertyIndex, Source(self, mBloomThresholdPropertyIndex), EqualToConstraintFloat());
 530   mBloomExtractShader.ApplyConstraint(bloomThresholdConstraint);
 531
 532   // precalc 1.0 / (1.0 - threshold) on CPU to save shader insns, using constraint to tie to the normal threshold property
 533   Property::Index shaderRecipOneMinusBloomThresholdPropertyIndex = mBloomExtractShader.GetPropertyIndex(RECIP_ONE_MINUS_BLOOM_THRESHOLD_PROPERTY_NAME);
 534   Constraint thresholdConstraint = Constraint::New<float>( shaderRecipOneMinusBloomThresholdPropertyIndex, LocalSource(shaderBloomThresholdPropertyIndex), RecipOneMinusConstraint());
 535   mBloomExtractShader.ApplyConstraint(thresholdConstraint);
 536
 537
 538   ////////////////////////////////////////////
 539   // bloom strength
 540
 541   // Register a property that the user can control to fade the blur in / out via internal GaussianBlurView object
 542   mBlurStrengthPropertyIndex = self.RegisterProperty(BLOOM_BLUR_STRENGTH_PROPERTY_NAME, BLOOM_BLUR_STRENGTH_DEFAULT);
 543   Constraint blurStrengthConstraint = Constraint::New<float>( mGaussianBlurView.GetBlurStrengthPropertyIndex(), Source(self, mBlurStrengthPropertyIndex), EqualToConstraintFloat());
 544   mGaussianBlurView.ApplyConstraint(blurStrengthConstraint);
 545
 546
 547   ////////////////////////////////////////////
 548   // bloom intensity
 549
 550   // Register a property that the user can control to fade the bloom intensity via internally hidden shader
 551   mBloomIntensityPropertyIndex = self.RegisterProperty(BLOOM_INTENSITY_PROPERTY_NAME, BLOOM_INTENSITY_DEFAULT);
 552   mCompositeShader.SetUniform( BLOOM_INTENSITY_PROPERTY_NAME, BLOOM_INTENSITY_DEFAULT );
 553   Property::Index shaderBloomIntensityPropertyIndex = mCompositeShader.GetPropertyIndex(BLOOM_INTENSITY_PROPERTY_NAME);
 554   Constraint bloomIntensityConstraint = Constraint::New<float>( shaderBloomIntensityPropertyIndex, Source(self, mBloomIntensityPropertyIndex), EqualToConstraintFloat());
 555   mCompositeShader.ApplyConstraint(bloomIntensityConstraint);
 556
 557
 558   ////////////////////////////////////////////
 559   // bloom saturation
 560
 561   // Register a property that the user can control to fade the bloom saturation via internally hidden shader
 562   mBloomSaturationPropertyIndex = self.RegisterProperty(BLOOM_SATURATION_PROPERTY_NAME, BLOOM_SATURATION_DEFAULT);
 563   mCompositeShader.SetUniform( BLOOM_SATURATION_PROPERTY_NAME, BLOOM_SATURATION_DEFAULT );
 564   Property::Index shaderBloomSaturationPropertyIndex = mCompositeShader.GetPropertyIndex(BLOOM_SATURATION_PROPERTY_NAME);
 565   Constraint bloomSaturationConstraint = Constraint::New<float>( shaderBloomSaturationPropertyIndex, Source(self, mBloomSaturationPropertyIndex), EqualToConstraintFloat());
 566   mCompositeShader.ApplyConstraint(bloomSaturationConstraint);
 567
 568
 569   ////////////////////////////////////////////
 570   // image intensity
 571
 572   // Register a property that the user can control to fade the image intensity via internally hidden shader
 573   mImageIntensityPropertyIndex = self.RegisterProperty(IMAGE_INTENSITY_PROPERTY_NAME, IMAGE_INTENSITY_DEFAULT);
 574   mCompositeShader.SetUniform( IMAGE_INTENSITY_PROPERTY_NAME, IMAGE_INTENSITY_DEFAULT );
 575   Property::Index shaderImageIntensityPropertyIndex = mCompositeShader.GetPropertyIndex(IMAGE_INTENSITY_PROPERTY_NAME);
 576   Constraint imageIntensityConstraint = Constraint::New<float>( shaderImageIntensityPropertyIndex, Source(self, mImageIntensityPropertyIndex), EqualToConstraintFloat());
 577   mCompositeShader.ApplyConstraint(imageIntensityConstraint);
 578
 579
 580   ////////////////////////////////////////////
 581   // image saturation
 582
 583   // Register a property that the user can control to fade the image saturation via internally hidden shader
 584   mImageSaturationPropertyIndex = self.RegisterProperty(IMAGE_SATURATION_PROPERTY_NAME, IMAGE_SATURATION_DEFAULT);
 585   mCompositeShader.SetUniform( IMAGE_SATURATION_PROPERTY_NAME, IMAGE_SATURATION_DEFAULT );
 586   Property::Index shaderImageSaturationPropertyIndex = mCompositeShader.GetPropertyIndex(IMAGE_SATURATION_PROPERTY_NAME);
 587   Constraint imageSaturationConstraint = Constraint::New<float>( shaderImageSaturationPropertyIndex, Source(self, mImageSaturationPropertyIndex), EqualToConstraintFloat());
 588   mCompositeShader.ApplyConstraint(imageSaturationConstraint);
 589 }
 590
 591 } // namespace Internal
 592
 593 } // namespace Toolkit
 594
 595 } // namespace Dali