END_TEST;
}
-int UtcDaliBuilderFrameBufferP(void)
-{
- ToolkitTestApplication application;
-
- // JSON with a quit event when the actor is touched
- std::string json(
- "{\n"
- " \"constants\":\n"
- " {\n"
- " \"FB_WIDTH\": 200.0,\n"
- " \"FB_HEIGHT\": 200.0,\n"
- " \"FB_SIZE\": [200,200],\n"
- " \"FB_ASPECT_RATIO\": 1\n"
- " },\n"
- " \"stage\": [\n"
- " {\n"
- " \"type\": \"ImageView\",\n"
- " \"name\": \"fbOnStage\",\n"
- " \"position\": [\n"
- " 0.40461349487305,\n"
- " 0.9150390625,\n"
- " 0.0\n"
- " ],\n"
- " \"parentOrigin\": [0.5, 0.5, 0.5],\n"
- " \"size\": [300, 300, 0],\n"
- " \"image\": \"fb0\",\n"
- " \"clearColor\": [1,0,0,1]\n"
- " },\n"
- " {\n"
- " \"type\": \"ImageView\",\n"
- " \"name\": \"Image1\",\n"
- " \"size\": [200, 200, 0],\n"
- " \"parentOrigin\": [0.5, 0.5, 0.5],\n"
- " \"effect\": \"Ripple2D\",\n"
- " \"image\": {\n"
- " \"url\": \"{DALI_IMAGE_DIR}gallery-medium-25.jpg\"\n"
- " },\n"
- " \"signals\": [\n"
- " {\n"
- " \"name\": \"onStage\",\n"
- " \"action\": \"play\",\n"
- " \"animation\": \"Animation_1\"\n"
- " }\n"
- " ]\n"
- " },\n"
- " {\n"
- " \"type\":\"CameraActor\",\n"
- " \"name\":\"fbCam\",\n"
- " \"aspectRatio\": \"{FB_ASPECT_RATIO}\",\n"
- " \"projectionMode\": \"PERSPECTIVE_PROJECTION\",\n"
- " \"fieldOfView\": 0.785,\n"
- " \"invertYAxis\": true\n"
- " }\n"
- " ],\n"
- " \"frameBufferImages\":\n"
- " {\n"
- " \"fb0\":\n"
- " {\n"
- " \"type\": \"FrameBufferImage\",\n"
- " \"width\": { \"typeCast\":\"float\", \"value\":\"{FB_WIDTH}\" },\n"
- " \"height\": { \"typeCast\":\"float\", \"value\":\"{FB_HEIGHT}\" }\n"
- " }\n"
- " },\n"
- " \"renderTasks\":\n"
- " {\n"
- " \"stage\":\n"
- " [\n"
- " {\n"
- " \"sourceActor\": \"fbOnStage\"\n"
- " },\n"
- " {\n"
- " \"sourceActor\": \"Image1\",\n"
- " \"targetFrameBuffer\": \"fb0\",\n"
- " \"viewportSize\":\"{FB_SIZE}\",\n"
- " \"cameraActor\":\"fbCam\"\n"
- " }\n"
- " ]\n"
- " },\n"
- " \"paths\": {},\n"
- " \"animations\": {\n"
- " \"Animation_1\": {\n"
- " \"loop\":true,\n"
- " \"properties\": [\n"
- " {\n"
- " \"actor\": \"Image1\",\n"
- " \"property\": \"uTime\",\n"
- " \"value\": 10.0,\n"
- " \"alphaFunction\": \"LINEAR\",\n"
- " \"timePeriod\": {\n"
- " \"delay\": 0,\n"
- " \"duration\": 10.0\n"
- " },\n"
- " \"gui-builder-timeline-color\": \"#8dc0da\"\n"
- " }\n"
- " ]\n"
- " }\n"
- " }\n"
- "}\n");
-
- Builder builder = Builder::New();
-
- // frame buffer coverage
- builder.LoadFromString( json );
-
- // Render and notify
- application.SendNotification();
- application.Render();
-
- Dali::FrameBufferImage frameBuffer = builder.GetFrameBufferImage( "fb0" );
- DALI_TEST_CHECK( frameBuffer );
-
- Dali::FrameBufferImage frameBuffer2 = builder.GetFrameBufferImage( "fb0" );
- DALI_TEST_CHECK( frameBuffer2 );
- DALI_TEST_CHECK( frameBuffer == frameBuffer2 );
-
- DALI_TEST_CHECK( true );
-
- END_TEST;
-}
-
int UtcDaliBuilderPathConstraintsP(void)
{
ToolkitTestApplication application;
GetImpl(*this).CreateRenderTask( name );
}
-FrameBufferImage Builder::GetFrameBufferImage( const std::string &name )
-{
- return GetImpl(*this).GetFrameBufferImage( name );
-}
-
Path Builder::GetPath( const std::string &name )
{
return GetImpl(*this).GetPath( name );
void CreateRenderTask( const std::string &name );
/**
- * Get or create FrameBufferImage from the FrameBufferImage instance library.
- * An empty handle is returned otherwise.
- * @pre The Builder has been initialized.
- * @param name The name of a FrameBufferImage in the loaded representation
- * @return A handle to a FrameBufferImage if found, otherwise empty
- */
- FrameBufferImage GetFrameBufferImage( const std::string &name );
-
- /**
* Get or create Path from the Path instance library.
* An empty handle is returned otherwise.
* @pre The Builder has been initialized.
}
}
-FrameBufferImage Builder::GetFrameBufferImage( const std::string &name )
-{
- Replacement constant( mReplacementMap );
- return GetFrameBufferImage(name, constant);
-}
-
-FrameBufferImage Builder::GetFrameBufferImage( const std::string &name, const Replacement& constant )
-{
- DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
-
- FrameBufferImage ret;
-
- ImageLut::const_iterator iter( mFrameBufferImageLut.find( name ) );
- if( iter != mFrameBufferImageLut.end() )
- {
- ret = iter->second;
- }
- else
- {
- if( OptionalChild images = IsChild( *mParser.GetRoot(), "frameBufferImages") )
- {
- if( OptionalChild image = IsChild( *images, name ) )
- {
- Dali::Property::Value property(Property::MAP);
- if( DeterminePropertyFromNode( *image, Property::MAP, property, constant ) )
- {
- Property::Map* map = property.GetMap();
-
- if( map )
- {
- (*map)[ KEYNAME_TYPE ] = Property::Value(std::string("FrameBufferImage") );
- ret = FrameBufferImage::DownCast( Dali::Scripting::NewImage( property ) );
- mFrameBufferImageLut[ name ] = ret;
- }
- }
- }
- }
- }
-
- return ret;
-}
-
Path Builder::GetPath( const std::string& name )
{
DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
}
}
- if( OptionalString s = constant.IsString( IsChild(node, "targetFrameBuffer") ) )
- {
- FrameBufferImage fb = GetFrameBufferImage( *s, constant );
- if(fb)
- {
- task.SetTargetFrameBuffer( fb );
- }
- else
- {
- DALI_SCRIPT_WARNING("Cannot find target frame buffer '%s'\n", (*s).c_str() );
- }
- }
-
if( OptionalString s = constant.IsString( IsChild(node, "screenToFrameBufferFunction") ) )
{
if("DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION" == *s)
void CreateRenderTask( const std::string &name );
/**
- * @copydoc Toolkit::Builder::GetFrameBufferImage
- */
- FrameBufferImage GetFrameBufferImage( const std::string &name );
-
- /**
- * @copydoc Toolkit::Builder::GetFrameBufferImage
- */
- FrameBufferImage GetFrameBufferImage( const std::string &name, const Replacement& constant );
-
- /**
* @copydoc Toolkit::Builder::GetPath
*/
Path GetPath( const std::string &name );
typedef struct{ std::string name; Dali::PathConstrainer pathConstrainer; } PathConstrainerEntry;
typedef std::vector<PathConstrainerEntry> PathConstrainerLut;
typedef std::map<const std::string, Path> PathLut;
- typedef std::map<const std::string, FrameBufferImage> ImageLut;
private:
// Undefined
private:
Toolkit::JsonParser mParser;
- ImageLut mFrameBufferImageLut;
PathLut mPathLut;
PathConstrainerLut mPathConstrainerLut;
LinearConstrainerLut mLinearConstrainerLut;
#include <dali/public-api/object/type-registry-helper.h>
#include <dali/public-api/render-tasks/render-task-list.h>
#include <dali/public-api/rendering/renderer.h>
-#include <dali/devel-api/images/texture-set-image.h>
// INTERNAL INCLUDES
#include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
#include <dali-toolkit/devel-api/controls/bloom-view/bloom-view.h>
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
#include <dali-toolkit/internal/controls/gaussian-blur-view/gaussian-blur-view-impl.h>
+#include <dali-toolkit/internal/controls/control/control-renderers.h>
namespace Dali
{
// Create actors
// Create an image view for rendering from the scene texture to the bloom texture
- mBloomExtractImageView = Toolkit::ImageView::New();
- mBloomExtractImageView.SetParentOrigin( ParentOrigin::CENTER );
+ mBloomExtractActor = Actor::New();
+ mBloomExtractActor.SetParentOrigin( ParentOrigin::CENTER );
// Create an image view for compositing the result (scene and bloom textures) to output
- mCompositeImageView = Toolkit::ImageView::New();
- mCompositeImageView.SetParentOrigin( ParentOrigin::CENTER );
+ mCompositeActor = Actor::New();
+ mCompositeActor.SetParentOrigin( ParentOrigin::CENTER );
// Create an image view for holding final result, i.e. the blurred image. This will get rendered to screen later, via default / user render task
- mTargetImageView = Toolkit::ImageView::New();
- mTargetImageView.SetParentOrigin( ParentOrigin::CENTER );
+ mTargetActor = Actor::New();
+ mTargetActor.SetParentOrigin( ParentOrigin::CENTER );
// Create the Gaussian Blur object + render tasks
// 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
// Connect to actor tree
Self().Add( mChildrenRoot );
Self().Add( mInternalRoot );
- mInternalRoot.Add( mBloomExtractImageView );
+ mInternalRoot.Add( mBloomExtractActor );
mInternalRoot.Add( mGaussianBlurView );
- mInternalRoot.Add( mCompositeImageView );
- mInternalRoot.Add( mTargetImageView );
+ mInternalRoot.Add( mCompositeActor );
+ mInternalRoot.Add( mTargetActor );
mInternalRoot.Add( mRenderDownsampledCamera );
mInternalRoot.Add( mRenderFullSizeCamera );
{
mTargetSize = Vector2(targetSize);
mChildrenRoot.SetSize(targetSize);
- mCompositeImageView.SetSize(targetSize);
- mTargetImageView.SetSize(targetSize);
+ mCompositeActor.SetSize(targetSize);
+ mTargetActor.SetSize(targetSize);
// Children render camera must move when GaussianBlurView object is
// resized. This is since we cannot change render target size - so we need
// Create and place a camera for the renders corresponding to the (potentially downsampled) render targets' size
mRenderDownsampledCamera.SetFieldOfView(ARBITRARY_FIELD_OF_VIEW);
- // 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
mRenderDownsampledCamera.SetNearClippingPlane(1.0f);
mRenderDownsampledCamera.SetAspectRatio(mDownsampledWidth / mDownsampledHeight);
mRenderDownsampledCamera.SetType(Dali::Camera::FREE_LOOK); // camera orientation based solely on actor
// Create and place a camera for the children render, corresponding to its render target size
mRenderFullSizeCamera.SetFieldOfView(ARBITRARY_FIELD_OF_VIEW);
- // 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
mRenderFullSizeCamera.SetNearClippingPlane(1.0f);
mRenderFullSizeCamera.SetAspectRatio(mTargetSize.width / mTargetSize.height);
mRenderFullSizeCamera.SetType(Dali::Camera::FREE_LOOK); // camera orientation based solely on actor
// Create render targets
// create off screen buffer of new size to render our child actors to
- mRenderTargetForRenderingChildren = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat );
+ mRenderTargetForRenderingChildren = FrameBuffer::New( mTargetSize.width, mTargetSize.height, FrameBuffer::Attachment::NONE );
+ Texture textureForChildren = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mTargetSize.width), unsigned(mTargetSize.height) );
+ mRenderTargetForRenderingChildren.AttachColorTexture( textureForChildren );
mBloomExtractTarget = FrameBuffer::New( mDownsampledWidth, mDownsampledHeight, FrameBuffer::Attachment::NONE );
Texture texture = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mDownsampledWidth), unsigned(mDownsampledHeight) );
texture = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mDownsampledWidth), unsigned(mDownsampledHeight) );
blurExtractTarget.AttachColorTexture( texture );
- mOutputRenderTarget = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat );
+ mOutputRenderTarget = FrameBuffer::New( mTargetSize.width, mTargetSize.height, FrameBuffer::Attachment::NONE );
+ Texture outputTexture = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mTargetSize.width), unsigned(mTargetSize.height) );
+ mOutputRenderTarget.AttachColorTexture( outputTexture );
//////////////////////////////////////////////////////
// Point actors and render tasks at new render targets
- mBloomExtractImageView.SetImage( mRenderTargetForRenderingChildren );
- mBloomExtractImageView.SetSize(mDownsampledWidth, mDownsampledHeight); // size needs to match render target
- // Create shader used for extracting the bright parts of an image
- Property::Map customShader;
- customShader[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = BLOOM_EXTRACT_FRAGMENT_SOURCE;
- Property::Map visualMap;
- visualMap.Insert( Toolkit::Visual::Property::SHADER, customShader );
- mBloomExtractImageView.SetProperty( Toolkit::ImageView::Property::IMAGE, visualMap );
+ Renderer bloomRenderer = CreateRenderer( BASIC_VERTEX_SOURCE, BLOOM_EXTRACT_FRAGMENT_SOURCE );
+ SetRendererTexture( bloomRenderer, mRenderTargetForRenderingChildren );
+ mBloomExtractActor.AddRenderer( bloomRenderer );
+ mBloomExtractActor.SetSize( mDownsampledWidth, mDownsampledHeight ); // size needs to match render target
// set GaussianBlurView to blur our extracted bloom
mGaussianBlurView.SetUserImageAndOutputRenderTarget( mBloomExtractTarget.GetColorTexture(), blurExtractTarget );
// use the completed blur in the first buffer and composite with the original child actors render
- mCompositeImageView.SetImage( mRenderTargetForRenderingChildren );
- // Create shader used to composite bloom and original image to output render target
- customShader[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = COMPOSITE_FRAGMENT_SOURCE;
- visualMap[ Toolkit::Visual::Property::SHADER ] = customShader;
- mCompositeImageView.SetProperty( Toolkit::ImageView::Property::IMAGE, visualMap );
- TextureSet textureSet = mCompositeImageView.GetRendererAt(0).GetTextures();
+ Renderer compositeRenderer = CreateRenderer( BASIC_VERTEX_SOURCE, COMPOSITE_FRAGMENT_SOURCE );
+ SetRendererTexture( compositeRenderer, mRenderTargetForRenderingChildren );
+ TextureSet textureSet = compositeRenderer.GetTextures();
+ textureSet.SetTexture( 0u, mRenderTargetForRenderingChildren.GetColorTexture() );
textureSet.SetTexture( 1u, blurExtractTarget.GetColorTexture() );
+ mCompositeActor.AddRenderer( compositeRenderer );
// set up target actor for rendering result, i.e. the blurred image
- mTargetImageView.SetImage(mOutputRenderTarget);
+ Renderer targetRenderer = CreateRenderer( BASIC_VERTEX_SOURCE, BASIC_FRAGMENT_SOURCE );
+ SetRendererTexture( targetRenderer, mOutputRenderTarget );
+ mTargetActor.AddRenderer( targetRenderer );
}
}
mRenderChildrenTask.SetInputEnabled( false );
mRenderChildrenTask.SetClearEnabled( true );
mRenderChildrenTask.SetCameraActor(mRenderFullSizeCamera); // use camera that covers render target exactly
- mRenderChildrenTask.SetTargetFrameBuffer( mRenderTargetForRenderingChildren );
+ mRenderChildrenTask.SetFrameBuffer( mRenderTargetForRenderingChildren );
// 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.
mBloomExtractTask = taskList.CreateTask();
- mBloomExtractTask.SetSourceActor( mBloomExtractImageView );
+ mBloomExtractTask.SetSourceActor( mBloomExtractActor );
mBloomExtractTask.SetExclusive(true);
mBloomExtractTask.SetInputEnabled( false );
mBloomExtractTask.SetClearEnabled( true );
// Use an image view displaying the children render and composite it with the blurred bloom buffer, targeting the output
mCompositeTask = taskList.CreateTask();
- mCompositeTask.SetSourceActor( mCompositeImageView );
+ mCompositeTask.SetSourceActor( mCompositeActor );
mCompositeTask.SetExclusive(true);
mCompositeTask.SetInputEnabled( false );
mCompositeTask.SetClearEnabled( true );
mCompositeTask.SetCameraActor(mRenderFullSizeCamera);
- mCompositeTask.SetTargetFrameBuffer( mOutputRenderTarget );
+ mCompositeTask.SetFrameBuffer( mOutputRenderTarget );
}
void BloomView::RemoveRenderTasks()
mOutputRenderTarget.Reset();
// Reset children
- mBloomExtractImageView.SetImage( "" );
- mTargetImageView.SetImage( "" );
- mCompositeImageView.SetImage( "" );
+ mBloomExtractActor.RemoveRenderer( 0u );
+ mTargetActor.RemoveRenderer( 0u );
+ mCompositeActor.RemoveRenderer( 0u );
mGaussianBlurView.SetVisible( false );
// bloom threshold
// set defaults, makes sure properties are registered with shader
- mBloomExtractImageView.RegisterProperty( BLOOM_THRESHOLD_PROPERTY_NAME, BLOOM_THRESHOLD_DEFAULT );
- mBloomExtractImageView.RegisterProperty( RECIP_ONE_MINUS_BLOOM_THRESHOLD_PROPERTY_NAME, 1.0f / (1.0f - BLOOM_THRESHOLD_DEFAULT) );
+ mBloomExtractActor.RegisterProperty( BLOOM_THRESHOLD_PROPERTY_NAME, BLOOM_THRESHOLD_DEFAULT );
+ mBloomExtractActor.RegisterProperty( RECIP_ONE_MINUS_BLOOM_THRESHOLD_PROPERTY_NAME, 1.0f / (1.0f - BLOOM_THRESHOLD_DEFAULT) );
// Register a property that the user can control to change the bloom threshold
mBloomThresholdPropertyIndex = self.RegisterProperty(BLOOM_THRESHOLD_PROPERTY_NAME, BLOOM_THRESHOLD_DEFAULT);
- Property::Index shaderBloomThresholdPropertyIndex = mBloomExtractImageView.GetPropertyIndex(BLOOM_THRESHOLD_PROPERTY_NAME);
- Constraint bloomThresholdConstraint = Constraint::New<float>( mBloomExtractImageView, shaderBloomThresholdPropertyIndex, EqualToConstraint());
+ Property::Index shaderBloomThresholdPropertyIndex = mBloomExtractActor.GetPropertyIndex(BLOOM_THRESHOLD_PROPERTY_NAME);
+ Constraint bloomThresholdConstraint = Constraint::New<float>( mBloomExtractActor, shaderBloomThresholdPropertyIndex, EqualToConstraint());
bloomThresholdConstraint.AddSource( Source(self, mBloomThresholdPropertyIndex) );
bloomThresholdConstraint.Apply();
// precalc 1.0 / (1.0 - threshold) on CPU to save shader insns, using constraint to tie to the normal threshold property
- Property::Index shaderRecipOneMinusBloomThresholdPropertyIndex = mBloomExtractImageView.GetPropertyIndex(RECIP_ONE_MINUS_BLOOM_THRESHOLD_PROPERTY_NAME);
- Constraint thresholdConstraint = Constraint::New<float>( mBloomExtractImageView, shaderRecipOneMinusBloomThresholdPropertyIndex, RecipOneMinusConstraint());
+ Property::Index shaderRecipOneMinusBloomThresholdPropertyIndex = mBloomExtractActor.GetPropertyIndex(RECIP_ONE_MINUS_BLOOM_THRESHOLD_PROPERTY_NAME);
+ Constraint thresholdConstraint = Constraint::New<float>( mBloomExtractActor, shaderRecipOneMinusBloomThresholdPropertyIndex, RecipOneMinusConstraint());
thresholdConstraint.AddSource( LocalSource(shaderBloomThresholdPropertyIndex) );
thresholdConstraint.Apply();
// Register a property that the user can control to fade the bloom intensity via internally hidden shader
mBloomIntensityPropertyIndex = self.RegisterProperty(BLOOM_INTENSITY_PROPERTY_NAME, BLOOM_INTENSITY_DEFAULT);
- mCompositeImageView.RegisterProperty( BLOOM_INTENSITY_PROPERTY_NAME, BLOOM_INTENSITY_DEFAULT );
- Property::Index shaderBloomIntensityPropertyIndex = mCompositeImageView.GetPropertyIndex(BLOOM_INTENSITY_PROPERTY_NAME);
- Constraint bloomIntensityConstraint = Constraint::New<float>( mCompositeImageView, shaderBloomIntensityPropertyIndex, EqualToConstraint());
+ mCompositeActor.RegisterProperty( BLOOM_INTENSITY_PROPERTY_NAME, BLOOM_INTENSITY_DEFAULT );
+ Property::Index shaderBloomIntensityPropertyIndex = mCompositeActor.GetPropertyIndex(BLOOM_INTENSITY_PROPERTY_NAME);
+ Constraint bloomIntensityConstraint = Constraint::New<float>( mCompositeActor, shaderBloomIntensityPropertyIndex, EqualToConstraint());
bloomIntensityConstraint.AddSource( Source(self, mBloomIntensityPropertyIndex) );
bloomIntensityConstraint.Apply();
// Register a property that the user can control to fade the bloom saturation via internally hidden shader
mBloomSaturationPropertyIndex = self.RegisterProperty(BLOOM_SATURATION_PROPERTY_NAME, BLOOM_SATURATION_DEFAULT);
- mCompositeImageView.RegisterProperty( BLOOM_SATURATION_PROPERTY_NAME, BLOOM_SATURATION_DEFAULT );
- Property::Index shaderBloomSaturationPropertyIndex = mCompositeImageView.GetPropertyIndex(BLOOM_SATURATION_PROPERTY_NAME);
- Constraint bloomSaturationConstraint = Constraint::New<float>( mCompositeImageView, shaderBloomSaturationPropertyIndex, EqualToConstraint());
+ mCompositeActor.RegisterProperty( BLOOM_SATURATION_PROPERTY_NAME, BLOOM_SATURATION_DEFAULT );
+ Property::Index shaderBloomSaturationPropertyIndex = mCompositeActor.GetPropertyIndex(BLOOM_SATURATION_PROPERTY_NAME);
+ Constraint bloomSaturationConstraint = Constraint::New<float>( mCompositeActor, shaderBloomSaturationPropertyIndex, EqualToConstraint());
bloomSaturationConstraint.AddSource( Source(self, mBloomSaturationPropertyIndex) );
bloomSaturationConstraint.Apply();
// Register a property that the user can control to fade the image intensity via internally hidden shader
mImageIntensityPropertyIndex = self.RegisterProperty(IMAGE_INTENSITY_PROPERTY_NAME, IMAGE_INTENSITY_DEFAULT);
- mCompositeImageView.RegisterProperty( IMAGE_INTENSITY_PROPERTY_NAME, IMAGE_INTENSITY_DEFAULT );
- Property::Index shaderImageIntensityPropertyIndex = mCompositeImageView.GetPropertyIndex(IMAGE_INTENSITY_PROPERTY_NAME);
- Constraint imageIntensityConstraint = Constraint::New<float>( mCompositeImageView, shaderImageIntensityPropertyIndex, EqualToConstraint());
+ mCompositeActor.RegisterProperty( IMAGE_INTENSITY_PROPERTY_NAME, IMAGE_INTENSITY_DEFAULT );
+ Property::Index shaderImageIntensityPropertyIndex = mCompositeActor.GetPropertyIndex(IMAGE_INTENSITY_PROPERTY_NAME);
+ Constraint imageIntensityConstraint = Constraint::New<float>( mCompositeActor, shaderImageIntensityPropertyIndex, EqualToConstraint());
imageIntensityConstraint.AddSource( Source(self, mImageIntensityPropertyIndex) );
imageIntensityConstraint.Apply();
// Register a property that the user can control to fade the image saturation via internally hidden shader
mImageSaturationPropertyIndex = self.RegisterProperty(IMAGE_SATURATION_PROPERTY_NAME, IMAGE_SATURATION_DEFAULT);
- mCompositeImageView.RegisterProperty( IMAGE_SATURATION_PROPERTY_NAME, IMAGE_SATURATION_DEFAULT );
- Property::Index shaderImageSaturationPropertyIndex = mCompositeImageView.GetPropertyIndex(IMAGE_SATURATION_PROPERTY_NAME);
- Constraint imageSaturationConstraint = Constraint::New<float>( mCompositeImageView, shaderImageSaturationPropertyIndex, EqualToConstraint());
+ mCompositeActor.RegisterProperty( IMAGE_SATURATION_PROPERTY_NAME, IMAGE_SATURATION_DEFAULT );
+ Property::Index shaderImageSaturationPropertyIndex = mCompositeActor.GetPropertyIndex(IMAGE_SATURATION_PROPERTY_NAME);
+ Constraint imageSaturationConstraint = Constraint::New<float>( mCompositeActor, shaderImageSaturationPropertyIndex, EqualToConstraint());
imageSaturationConstraint.AddSource( Source(self, mImageSaturationPropertyIndex) );
imageSaturationConstraint.Apply();
}
#include <cmath>
#include <dali/public-api/actors/camera-actor.h>
#include <dali/public-api/render-tasks/render-task.h>
-#include <dali/public-api/images/frame-buffer-image.h>
+#include <dali/public-api/rendering/frame-buffer.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control-impl.h>
/////////////////////////////////////////////////////////////
// for rendering all user added children to offscreen target
- FrameBufferImage mRenderTargetForRenderingChildren;
+ FrameBuffer mRenderTargetForRenderingChildren;
RenderTask mRenderChildrenTask;
/////////////////////////////////////////////////////////////
// for extracting bright parts of image to an offscreen target
FrameBuffer mBloomExtractTarget; // for rendering bright parts of image into separate texture, also used as target for gaussian blur
RenderTask mBloomExtractTask;
- Toolkit::ImageView mBloomExtractImageView;
+ Actor mBloomExtractActor;
/////////////////////////////////////////////////////////////
// for blurring extracted bloom
// for compositing bloom and children renders to offscreen target
RenderTask mCompositeTask;
- Toolkit::ImageView mCompositeImageView;
+ Actor mCompositeActor;
/////////////////////////////////////////////////////////////
// for holding blurred result
- FrameBufferImage mOutputRenderTarget;
- Toolkit::ImageView mTargetImageView;
+ FrameBuffer mOutputRenderTarget;
+ Actor mTargetActor;
/////////////////////////////////////////////////////////////
// Properties for setting by user, e.g. by animations
--- /dev/null
+/*
+ * Copyright (c) 2019 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.
+ */
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/internal/controls/control/control-renderers.h>
+
+namespace Dali
+{
+namespace Toolkit
+{
+namespace Internal
+{
+
+#define DALI_COMPOSE_SHADER(STR) #STR
+
+const char * const BASIC_VERTEX_SOURCE = DALI_COMPOSE_SHADER(
+ precision mediump float;\n
+ attribute mediump vec2 aPosition;\n
+ varying mediump vec2 vTexCoord;\n
+ uniform mediump mat4 uMvpMatrix;\n
+ uniform mediump vec3 uSize;\n
+ \n
+ void main()\n
+ {\n
+ mediump vec4 vertexPosition = vec4(aPosition * uSize.xy, 0.0, 1.0);\n
+ vTexCoord = aPosition + vec2(0.5);
+ gl_Position = uMvpMatrix * vertexPosition;\n
+ }\n
+);
+
+const char * const BASIC_FRAGMENT_SOURCE = DALI_COMPOSE_SHADER(
+ precision mediump float;\n
+ varying mediump vec2 vTexCoord;\n
+ uniform sampler2D sTexture;\n
+ uniform vec4 uColor;\n
+ \n
+ void main()\n
+ {\n
+ gl_FragColor = texture2D(sTexture, vTexCoord);\n
+ gl_FragColor *= uColor;
+ }\n
+);
+
+Geometry CreateGridGeometry( Uint16Pair gridSize )
+{
+ uint16_t gridWidth = gridSize.GetWidth();
+ uint16_t gridHeight = gridSize.GetHeight();
+
+ // Create vertices
+ Vector< Vector2 > vertices;
+ vertices.Reserve( ( gridWidth + 1 ) * ( gridHeight + 1 ) );
+
+ for( int y = 0; y < gridHeight + 1; ++y )
+ {
+ for( int x = 0; x < gridWidth + 1; ++x )
+ {
+ vertices.PushBack( Vector2( (float)x/gridWidth - 0.5f, (float)y/gridHeight - 0.5f) );
+ }
+ }
+
+ // Create indices
+ Vector< unsigned short > indices;
+ indices.Reserve( (gridWidth+2)*gridHeight*2 - 2);
+
+ for( unsigned int row = 0u; row < gridHeight; ++row )
+ {
+ unsigned int rowStartIndex = row*(gridWidth+1u);
+ unsigned int nextRowStartIndex = rowStartIndex + gridWidth +1u;
+
+ if( row != 0u ) // degenerate index on non-first row
+ {
+ indices.PushBack( rowStartIndex );
+ }
+
+ for( unsigned int column = 0u; column < gridWidth+1u; column++) // main strip
+ {
+ indices.PushBack( rowStartIndex + column);
+ indices.PushBack( nextRowStartIndex + column);
+ }
+
+ if( row != gridHeight-1u ) // degenerate index on non-last row
+ {
+ indices.PushBack( nextRowStartIndex + gridWidth );
+ }
+ }
+
+ Property::Map vertexFormat;
+ vertexFormat[ "aPosition" ] = Property::VECTOR2;
+ PropertyBuffer vertexPropertyBuffer = PropertyBuffer::New( vertexFormat );
+ if( vertices.Size() > 0 )
+ {
+ vertexPropertyBuffer.SetData( &vertices[ 0 ], vertices.Size() );
+ }
+
+ // Create the geometry object
+ Geometry geometry = Geometry::New();
+ geometry.AddVertexBuffer( vertexPropertyBuffer );
+ if( indices.Size() > 0 )
+ {
+ geometry.SetIndexBuffer( &indices[ 0 ], indices.Size() );
+ }
+
+ geometry.SetType( Geometry::TRIANGLE_STRIP );
+
+ return geometry;
+}
+
+Dali::Renderer CreateRenderer( const char* vertexSrc, const char* fragmentSrc )
+{
+ Dali::Shader shader = Dali::Shader::New( vertexSrc, fragmentSrc );
+
+ Dali::Geometry texturedQuadGeometry = Dali::Geometry::New();
+
+ struct VertexPosition { Dali::Vector2 position; };
+ struct VertexTexture { Dali::Vector2 texture; };
+
+ VertexPosition positionArray[] =
+ {
+ { Dali::Vector2( -0.5f, -0.5f ) },
+ { Dali::Vector2( 0.5f, -0.5f ) },
+ { Dali::Vector2( -0.5f, 0.5f ) },
+ { Dali::Vector2( 0.5f, 0.5f ) }
+ };
+ uint32_t numberOfVertices = sizeof(positionArray)/sizeof(VertexPosition);
+
+ Dali::Property::Map positionVertexFormat;
+ positionVertexFormat["aPosition"] = Dali::Property::VECTOR2;
+ Dali::PropertyBuffer positionVertices = Dali::PropertyBuffer::New( positionVertexFormat );
+ positionVertices.SetData( positionArray, numberOfVertices );
+ texturedQuadGeometry.AddVertexBuffer( positionVertices );
+
+ const uint16_t indices[] = { 0, 3, 1, 0, 2, 3 };
+ texturedQuadGeometry.SetIndexBuffer ( &indices[0], sizeof( indices )/ sizeof( indices[0] ) );
+
+ Dali::Renderer renderer = Dali::Renderer::New( texturedQuadGeometry, shader );
+
+ Dali::TextureSet textureSet = Dali::TextureSet::New();
+ renderer.SetTextures( textureSet );
+
+ return renderer;
+}
+
+Dali::Renderer CreateRenderer( const char* vertexSrc, const char* fragmentSrc, Dali::Shader::Hint::Value hints, Uint16Pair gridSize )
+{
+ Dali::Shader shader = Dali::Shader::New( vertexSrc, fragmentSrc, hints );
+
+ Dali::Geometry gridGeometry = CreateGridGeometry( gridSize );
+
+ Dali::Renderer renderer = Dali::Renderer::New( gridGeometry, shader );
+
+ Dali::TextureSet textureSet = Dali::TextureSet::New();
+ renderer.SetTextures( textureSet );
+
+ return renderer;
+}
+
+void SetRendererTexture( Dali::Renderer renderer, Dali::Texture texture )
+{
+ if( renderer )
+ {
+ Dali::TextureSet textureSet = renderer.GetTextures();
+ textureSet.SetTexture( 0u, texture );
+ }
+}
+
+void SetRendererTexture( Dali::Renderer renderer, Dali::FrameBuffer frameBuffer )
+{
+ if( frameBuffer )
+ {
+ Dali::Texture texture = frameBuffer.GetColorTexture();
+ SetRendererTexture( renderer, texture );
+ }
+}
+
+} // namespace Internal
+} // namespace Toolkit
+} // namespace Dali
--- /dev/null
+#ifndef DALI_TOOLKIT_INTERNAL_CONTROL_RENDERERS_H
+#define DALI_TOOLKIT_INTERNAL_CONTROL_RENDERERS_H
+
+/*
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <dali/dali.h>
+
+namespace Dali
+{
+namespace Toolkit
+{
+namespace Internal
+{
+
+extern const char* const BASIC_VERTEX_SOURCE;
+
+extern const char* const BASIC_FRAGMENT_SOURCE;
+
+/**
+ * Helper method for rendering an image with custom shader.
+ * @param[in] vertextSrc The custom vertex shader.
+ * @param[in] fragmentSrc The custom fragment shader.
+ * @return A newly created renderer.
+ */
+Dali::Renderer CreateRenderer( const char* vertexSrc, const char* fragmentSrc );
+
+/**
+ * Helper method for rendering an image with custom shader.
+ * @param[in] vertextSrc The custom vertex shader.
+ * @param[in] fragmentSrc The custom fragment shader.
+ * @param[in] gridSize The number of grid sub-divisions required.
+ * @return A newly created renderer.
+ */
+Dali::Renderer CreateRenderer( const char* vertexSrc, const char* fragmentSrc, Dali::Shader::Hint::Value hints, Dali::Uint16Pair gridSize );
+
+/**
+ * Helper method for setting the first texture passed to a renderer.
+ * @param[in] renderer The renderer using the texture.
+ * @param[in] texture The texture to set.
+ */
+void SetRendererTexture( Dali::Renderer renderer, Dali::Texture texture );
+
+/**
+ * Helper method for setting the first texture passed to a renderer.
+ * @param[in] renderer The renderer using the texture.
+ * @param[in] framebuffer A frame buffer color texture attached.
+ */
+void SetRendererTexture( Dali::Renderer renderer, Dali::FrameBuffer frameBuffer );
+
+} // namespace Internal
+} // namespace Toolkit
+} // namespace Dali
+
+#endif // DALI_TOOLKIT_INTERNAL_CONTROL_RENDERERS_H
#include <dali/public-api/object/type-registry-helper.h>
#include <dali/public-api/render-tasks/render-task-list.h>
#include <dali/public-api/rendering/renderer.h>
-#include <dali/devel-api/images/texture-set-image.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
#include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
#include <dali-toolkit/devel-api/controls/control-devel.h>
-#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
#include <dali-toolkit/internal/filters/blur-two-pass-filter.h>
#include <dali-toolkit/internal/filters/emboss-filter.h>
#include <dali-toolkit/internal/filters/spread-filter.h>
-#include <dali-toolkit/internal/visuals/visual-base-impl.h>
-#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
+#include <dali-toolkit/internal/controls/control/control-renderers.h>
namespace Dali
{
const Vector4 EFFECTS_VIEW_DEFAULT_BACKGROUND_COLOR( 0.0f, 0.0f, 0.0f, 0.0 );
const bool EFFECTS_VIEW_REFRESH_ON_DEMAND(false);
-// Visuals are not stylable or public
-const Property::Index CHILD_VISUAL( Toolkit::EffectsView::ANIMATABLE_PROPERTY_START_INDEX - 1);
-const Property::Index POST_FILTER_VISUAL( CHILD_VISUAL-1 );
-
#define DALI_COMPOSE_SHADER(STR) #STR
const char* EFFECTS_VIEW_VERTEX_SOURCE = DALI_COMPOSE_SHADER(
mEffectType( Toolkit::EffectsView::INVALID_TYPE ),
mPixelFormat( EFFECTS_VIEW_DEFAULT_PIXEL_FORMAT ),
mEnabled( false ),
- mRefreshOnDemand(EFFECTS_VIEW_REFRESH_ON_DEMAND)
+ mRefreshOnDemand( EFFECTS_VIEW_REFRESH_ON_DEMAND )
{
}
}
}
- FrameBufferImage dummyImage = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat );
-
- Internal::InitializeVisual( self, mVisualPostFilter, dummyImage );
- DevelControl::RegisterVisual( *this, POST_FILTER_VISUAL, mVisualPostFilter );
-
- Property::Map customShader;
- customShader[ Toolkit::Visual::Shader::Property::VERTEX_SHADER ] = EFFECTS_VIEW_VERTEX_SOURCE;
- customShader[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = EFFECTS_VIEW_FRAGMENT_SOURCE;
- Toolkit::GetImplementation( mVisualPostFilter ).SetCustomShader( customShader );
-
mEffectType = type;
}
}
void EffectsView::Disable()
{
// stop render tasks processing
- // Note: render target resources are automatically freed since we set the Image::Unused flag
RemoveRenderTasks();
mLastSize = Vector2::ZERO; // Ensure resources are reallocated on subsequent enable
mEnabled = false;
void EffectsView::OnStageConnection( int depth )
{
+ Actor self( Self() );
+
+ // Create renderers
+ mRendererPostFilter = CreateRenderer( EFFECTS_VIEW_VERTEX_SOURCE, EFFECTS_VIEW_FRAGMENT_SOURCE );
+ mRendererPostFilter.SetProperty( Dali::Renderer::Property::DEPTH_INDEX, DepthIndex::CONTENT );
+ self.AddRenderer( mRendererPostFilter );
+
+ mRendererForChildren = CreateRenderer( BASIC_VERTEX_SOURCE, BASIC_FRAGMENT_SOURCE );
+ mRendererForChildren.SetProperty( Dali::Renderer::Property::DEPTH_INDEX, DepthIndex::CONTENT + 1 );
+ self.AddRenderer( mRendererForChildren );
+
Enable();
Control::OnStageConnection( depth );
void EffectsView::OnStageDisconnection()
{
+ Actor self( Self() );
+
Disable();
const size_t numFilters( mFilters.Size() );
mFilters[i]->Disable();
}
+ // Remove renderers
+ self.RemoveRenderer( mRendererForChildren );
+ mRendererForChildren.Reset();
+
+ self.RemoveRenderer( mRendererPostFilter );
+ mRendererPostFilter.Reset();
+
Control::OnStageDisconnection();
}
case Toolkit::EffectsView::DROP_SHADOW:
{
SpreadFilter* spreadFilter = static_cast< SpreadFilter* >( mFilters[0] );
- spreadFilter->SetInputImage( mImageForChildren );
- spreadFilter->SetOutputImage( mImagePostFilter );
+ spreadFilter->SetInputTexture( mFrameBufferForChildren.GetColorTexture() );
+ spreadFilter->SetOutputFrameBuffer( mFrameBufferPostFilter );
spreadFilter->SetRootActor( mChildrenRoot );
spreadFilter->SetBackgroundColor( mBackgroundColor );
spreadFilter->SetPixelFormat( mPixelFormat );
spreadFilter->SetSpread( mEffectSize );
BlurTwoPassFilter* blurFilter = static_cast< BlurTwoPassFilter* >( mFilters[1] );
- blurFilter->SetInputImage( mImagePostFilter );
- blurFilter->SetOutputImage( mImagePostFilter );
+ blurFilter->SetInputTexture( mFrameBufferPostFilter.GetColorTexture() );
+ blurFilter->SetOutputFrameBuffer( mFrameBufferPostFilter );
blurFilter->SetRootActor( mChildrenRoot );
blurFilter->SetBackgroundColor( mBackgroundColor );
blurFilter->SetPixelFormat( mPixelFormat );
case Toolkit::EffectsView::EMBOSS:
{
SpreadFilter* spreadFilter = static_cast< SpreadFilter* >( mFilters[0] );
- spreadFilter->SetInputImage( mImageForChildren );
- spreadFilter->SetOutputImage( mImagePostFilter );
+ spreadFilter->SetInputTexture( mFrameBufferForChildren.GetColorTexture() );
+ spreadFilter->SetOutputFrameBuffer( mFrameBufferPostFilter );
spreadFilter->SetRootActor( mChildrenRoot );
spreadFilter->SetBackgroundColor( mBackgroundColor );
spreadFilter->SetPixelFormat( Pixel::RGBA8888 );
spreadFilter->SetSpread( mEffectSize );
EmbossFilter* embossFilter = static_cast< EmbossFilter* >( mFilters[1] );
- embossFilter->SetInputImage( mImagePostFilter );
- embossFilter->SetOutputImage( mImagePostFilter );
+ embossFilter->SetInputTexture( mFrameBufferPostFilter.GetColorTexture() );
+ embossFilter->SetOutputFrameBuffer( mFrameBufferPostFilter );
embossFilter->SetRootActor( mChildrenRoot );
embossFilter->SetBackgroundColor( mBackgroundColor );
embossFilter->SetPixelFormat( Pixel::RGBA8888 );
embossFilter->SetSize( mTargetSize );
BlurTwoPassFilter* blurFilter = static_cast< BlurTwoPassFilter* >( mFilters[2] );
- blurFilter->SetInputImage( mImagePostFilter );
- blurFilter->SetOutputImage( mImagePostFilter );
+ blurFilter->SetInputTexture( mFrameBufferPostFilter.GetColorTexture() );
+ blurFilter->SetOutputFrameBuffer( mFrameBufferPostFilter );
blurFilter->SetRootActor( mChildrenRoot );
blurFilter->SetBackgroundColor( Vector4( 0.5f, 0.5f, 0.5f, 0.0 ) );
blurFilter->SetPixelFormat( Pixel::RGBA8888 );
}
}
}
+
void EffectsView::AllocateResources()
{
if(mTargetSize != mLastSize)
Actor self( Self() );
- mImageForChildren = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat );
- Internal::InitializeVisual( self, mVisualForChildren, mImageForChildren );
- DevelControl::RegisterVisual( *this, CHILD_VISUAL, mVisualForChildren, DepthIndex::CONTENT + 1 );
+ mFrameBufferForChildren = FrameBuffer::New( mTargetSize.width, mTargetSize.height, FrameBuffer::Attachment::NONE );
+ Texture textureForChildren = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mTargetSize.width), unsigned(mTargetSize.height) );
+ mFrameBufferForChildren.AttachColorTexture( textureForChildren );
+
+ SetRendererTexture( mRendererForChildren, textureForChildren );
+
+ mFrameBufferPostFilter = FrameBuffer::New( mTargetSize.width, mTargetSize.height, FrameBuffer::Attachment::NONE );
+ Texture texturePostFilter = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mTargetSize.width), unsigned(mTargetSize.height) );
+ mFrameBufferPostFilter.AttachColorTexture( texturePostFilter );
- mImagePostFilter = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat );
- TextureSet textureSet = TextureSet::New();
- TextureSetImage( textureSet, 0u, mImagePostFilter );
- self.GetRendererAt( 0 ).SetTextures( textureSet );
- mVisualPostFilter.SetDepthIndex( DepthIndex::CONTENT );
+ SetRendererTexture( mRendererPostFilter, texturePostFilter );
SetupFilters();
}
mRenderTaskForChildren.SetInputEnabled( false );
mRenderTaskForChildren.SetClearColor( mBackgroundColor );
mRenderTaskForChildren.SetClearEnabled( true );
- mRenderTaskForChildren.SetTargetFrameBuffer( mImageForChildren );
+ mRenderTaskForChildren.SetFrameBuffer( mFrameBufferForChildren );
mRenderTaskForChildren.SetCameraActor(mCameraForChildren); // use camera that covers render target exactly
// Enable image filters
#include <dali/public-api/actors/camera-actor.h>
#include <dali/public-api/common/dali-vector.h>
#include <dali/public-api/render-tasks/render-task.h>
+#include <dali/public-api/rendering/frame-buffer.h>
+#include <dali/public-api/rendering/renderer.h>
// INTERNAL INCLUDES
#include <dali-toolkit/devel-api/controls/effects-view/effects-view.h>
#include <dali-toolkit/public-api/controls/control-impl.h>
-#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
namespace Dali
{
EffectsView();
/**
- * Constructor.
- * @copydoc Toolkit::EffectsView New(const unsigned int,const float,const Pixel::Format,const float,const float)
- */
- EffectsView(const unsigned int numSamples, const float blurBellCurveWidth, const int spread,
- const Pixel::Format pixelFormat,
- const float downsampleWidthScale, const float downsampleHeightScale,
- FrameBufferImage image);
-
- /**
* A reference counted object may only be deleted by calling Unreference()
*/
virtual ~EffectsView();
/////////////////////////////////////////////////////////////
// for rendering all user added children to offscreen target
- FrameBufferImage mImageForChildren;
- Toolkit::Visual::Base mVisualForChildren;
+ FrameBuffer mFrameBufferForChildren;
+ Renderer mRendererForChildren;
RenderTask mRenderTaskForChildren;
CameraActor mCameraForChildren;
Actor mChildrenRoot; // for creating a subtree for all user added child actors
Vector2 mLastSize;
/////////////////////////////////////////////////////////////
// post blur image
- FrameBufferImage mImagePostFilter;
- Toolkit::Visual::Base mVisualPostFilter;
+ FrameBuffer mFrameBufferPostFilter;
+ Renderer mRendererPostFilter;
Vector<ImageFilter*> mFilters;
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/internal/controls/control/control-renderers.h>
// TODO:
// pixel format / size - set from JSON
const float ARBITRARY_FIELD_OF_VIEW = Math::PI / 4.0f;
-#define DALI_COMPOSE_SHADER(STR) #STR
-
-const char * const BASIC_VERTEX_SOURCE = DALI_COMPOSE_SHADER(
- precision mediump float;\n
- attribute mediump vec2 aPosition;\n
- attribute mediump vec2 aTexture;\n
- varying mediump vec2 vTexCoord;\n
- uniform mediump mat4 uMvpMatrix;\n
- uniform mediump vec3 uSize;\n
- \n
- void main()\n
- {\n
- mediump vec4 vertexPosition = vec4(aPosition * uSize.xy, 0.0, 1.0);\n
- vTexCoord = aTexture;\n
- gl_Position = uMvpMatrix * vertexPosition;\n
- }\n
-);
-
-const char * const BASIC_FRAGMENT_SOURCE = DALI_COMPOSE_SHADER(
- precision mediump float;\n
- varying mediump vec2 vTexCoord;\n
- uniform sampler2D sTexture;\n
- uniform vec4 uColor;\n
- \n
- void main()\n
- {\n
- gl_FragColor = texture2D(sTexture, vTexCoord);\n
- gl_FragColor *= uColor;
- }\n
-);
-
const char* const GAUSSIAN_BLUR_FRAGMENT_SOURCE = DALI_COMPOSE_SHADER(
varying mediump vec2 vTexCoord;\n
uniform sampler2D sTexture;\n
}\n
);
-Renderer CreateRenderer( const char* vertexSrc, const char* fragmentSrc )
-{
- Shader shader = Shader::New( vertexSrc, fragmentSrc );
-
- Geometry texturedQuadGeometry = Geometry::New();
-
- struct VertexPosition { Vector2 position; };
- struct VertexTexture { Vector2 texture; };
-
- VertexPosition positionArray[] =
- {
- { Vector2( -0.5f, -0.5f ) },
- { Vector2( 0.5f, -0.5f ) },
- { Vector2( -0.5f, 0.5f ) },
- { Vector2( 0.5f, 0.5f ) }
- };
- uint32_t numberOfVertices = sizeof(positionArray)/sizeof(VertexPosition);
-
- VertexTexture uvArray[] =
- {
- { Vector2( 0.0f, 0.0f ) },
- { Vector2( 1.0f, 0.0f ) },
- { Vector2( 0.0f, 1.0f ) },
- { Vector2( 1.0f, 1.0f ) }
- };
-
- Property::Map positionVertexFormat;
- positionVertexFormat["aPosition"] = Property::VECTOR2;
- PropertyBuffer positionVertices = PropertyBuffer::New( positionVertexFormat );
- positionVertices.SetData( positionArray, numberOfVertices );
- texturedQuadGeometry.AddVertexBuffer( positionVertices );
-
- Property::Map textureVertexFormat;
- textureVertexFormat["aTexture"] = Property::VECTOR2;
- PropertyBuffer textureVertices = PropertyBuffer::New( textureVertexFormat );
- textureVertices.SetData( uvArray, numberOfVertices );
- texturedQuadGeometry.AddVertexBuffer( textureVertices );
-
- const uint16_t indices[] = { 0, 3, 1, 0, 2, 3 };
- texturedQuadGeometry.SetIndexBuffer ( &indices[0], sizeof( indices )/ sizeof( indices[0] ) );
-
- Renderer renderer = Renderer::New( texturedQuadGeometry, shader );
-
- TextureSet textureSet = TextureSet::New();
- renderer.SetTextures( textureSet );
-
- return renderer;
-}
-
-void SetTexture( Actor actor, Texture texture )
-{
- if( Renderer renderer = actor.GetRendererAt(0) )
- {
- TextureSet textureSet = renderer.GetTextures();
- textureSet.SetTexture( 0u, texture );
- }
-}
-
-void SetTexture( Actor actor, FrameBuffer frameBuffer )
-{
- if( frameBuffer )
- {
- SetTexture( actor, frameBuffer.GetColorTexture() );
- }
-}
-
} // namespace
mUserInputImage = inputImage;
- SetTexture( mHorizBlurActor, inputImage );
+ SetRendererTexture( mHorizBlurActor.GetRendererAt(0), inputImage );
mUserOutputRenderTarget = outputRenderTarget;
}
mRenderTargetForRenderingChildren.AttachColorTexture( texture );
// Set actor for performing a horizontal blur
- SetTexture( mHorizBlurActor, mRenderTargetForRenderingChildren );
+ SetRendererTexture( mHorizBlurActor.GetRendererAt(0), mRenderTargetForRenderingChildren );
// Create offscreen buffer for vert blur pass
mRenderTarget1 = FrameBuffer::New( mDownsampledWidth, mDownsampledHeight, FrameBuffer::Attachment::NONE );
mRenderTarget1.AttachColorTexture( texture );
// use the completed blur in the first buffer and composite with the original child actors render
- SetTexture( mCompositingActor, mRenderTarget1 );
+ SetRendererTexture( mCompositingActor.GetRendererAt(0), mRenderTarget1 );
// set up target actor for rendering result, i.e. the blurred image
- SetTexture( mTargetActor, mRenderTargetForRenderingChildren );
+ SetRendererTexture( mTargetActor.GetRendererAt(0), mRenderTargetForRenderingChildren );
}
// Create offscreen buffer for horiz blur pass
// size needs to match render target
mVertBlurActor.SetSize(mDownsampledWidth, mDownsampledHeight);
- SetTexture( mVertBlurActor, mRenderTarget2 );
+ SetRendererTexture( mVertBlurActor.GetRendererAt(0), mRenderTarget2 );
// set gaussian blur up for new sized render targets
SetShaderConstants();
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/internal/controls/control/control-renderers.h>
#include <dali-toolkit/internal/controls/shadow-view/shadow-view-impl.h>
#include <dali-toolkit/internal/filters/blur-two-pass-filter.h>
{
mShadowPlaneBg = shadowPlaneBackground;
- mShadowPlane = Toolkit::ImageView::New( mOutputImage );
+ mShadowPlane = Actor::New();
mShadowPlane.SetName( "SHADOW_PLANE" );
- mShadowPlane.SetParentOrigin(ParentOrigin::CENTER);
- mShadowPlane.SetAnchorPoint(AnchorPoint::CENTER);
+ mShadowPlane.SetParentOrigin( ParentOrigin::CENTER );
+ mShadowPlane.SetAnchorPoint( AnchorPoint::CENTER );
+ Renderer shadowRenderer = CreateRenderer( RENDER_SHADOW_VERTEX_SOURCE, RENDER_SHADOW_FRAGMENT_SOURCE, Shader::Hint::OUTPUT_IS_TRANSPARENT, Uint16Pair(20,20) );
+ TextureSet textureSet = shadowRenderer.GetTextures();
+ textureSet.SetTexture( 0u, mOutputFrameBuffer.GetColorTexture() );
+ mShadowPlane.AddRenderer( shadowRenderer );
- mShadowPlane.SetProperty( Toolkit::ImageView::Property::IMAGE, mShadowVisualMap );
SetShaderConstants();
// Rather than parent the shadow plane drawable and have constraints to move it to the same
// position, instead parent the shadow plane drawable on the shadow plane passed in.
- mShadowPlaneBg.Add(mShadowPlane);
- mShadowPlane.SetParentOrigin(ParentOrigin::CENTER);
- mShadowPlane.SetZ(1.0f);
+ mShadowPlaneBg.Add( mShadowPlane );
+ mShadowPlane.SetParentOrigin( ParentOrigin::CENTER );
+ mShadowPlane.SetZ( 1.0f );
ConstrainCamera();
mCameraActor.SetOrientation(Radian(Degree(180)), Vector3::YAXIS);
mCameraActor.SetPosition(DEFAULT_LIGHT_POSITION);
-
- Property::Map customShader;
- customShader[ Toolkit::Visual::Shader::Property::VERTEX_SHADER ] = RENDER_SHADOW_VERTEX_SOURCE;
- customShader[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = RENDER_SHADOW_FRAGMENT_SOURCE;
-
- customShader[ Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X ] = 20;
- customShader[ Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y ] = 20;
-
- customShader[ Toolkit::Visual::Shader::Property::HINTS ] = Shader::Hint::OUTPUT_IS_TRANSPARENT;
-
- mShadowVisualMap[ Toolkit::Visual::Property::SHADER ] = customShader;
-
// Create render targets needed for rendering from light's point of view
- mSceneFromLightRenderTarget = FrameBufferImage::New( stageSize.width, stageSize.height, Pixel::RGBA8888 );
+ mSceneFromLightRenderTarget = FrameBuffer::New( stageSize.width, stageSize.height, FrameBuffer::Attachment::NONE );
+ Texture textureFromLight = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, unsigned(stageSize.width), unsigned(stageSize.height) );
+ mSceneFromLightRenderTarget.AttachColorTexture( textureFromLight );
- mOutputImage = FrameBufferImage::New( stageSize.width * 0.5f, stageSize.height * 0.5f, Pixel::RGBA8888 );
+ mOutputFrameBuffer = FrameBuffer::New( stageSize.width * 0.5f, stageSize.height * 0.5f, FrameBuffer::Attachment::NONE );
+ Texture outputTexture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, unsigned(stageSize.width * 0.5f), unsigned(stageSize.height * 0.5f) );
+ mOutputFrameBuffer.AttachColorTexture( outputTexture );
//////////////////////////////////////////////////////
// Connect to actor tree
Self().Add( mChildrenRoot );
Stage::GetCurrent().Add( mCameraActor );
- mBlurFilter.SetRefreshOnDemand(false);
- mBlurFilter.SetInputImage(mSceneFromLightRenderTarget);
- mBlurFilter.SetOutputImage(mOutputImage);
- mBlurFilter.SetSize(stageSize * 0.5f);
- mBlurFilter.SetPixelFormat(Pixel::RGBA8888);
+ mBlurFilter.SetRefreshOnDemand( false );
+ mBlurFilter.SetInputTexture( mSceneFromLightRenderTarget.GetColorTexture() );
+ mBlurFilter.SetOutputFrameBuffer( mOutputFrameBuffer );
+ mBlurFilter.SetSize( stageSize * 0.5f );
+ mBlurFilter.SetPixelFormat( Pixel::RGBA8888 );
mBlurRootActor = Actor::New();
mBlurRootActor.SetName( "BLUR_ROOT_ACTOR" );
// Turn off inheritance to ensure filter renders properly
mBlurRootActor.SetParentOrigin( ParentOrigin::CENTER );
- mBlurRootActor.SetInheritPosition(false);
- mBlurRootActor.SetInheritOrientation(false);
- mBlurRootActor.SetInheritScale(false);
- mBlurRootActor.SetColorMode(USE_OWN_COLOR);
+ mBlurRootActor.SetInheritPosition( false );
+ mBlurRootActor.SetInheritOrientation( false );
+ mBlurRootActor.SetInheritScale( false );
+ mBlurRootActor.SetColorMode( USE_OWN_COLOR );
- Self().Add(mBlurRootActor);
+ Self().Add( mBlurRootActor );
mBlurFilter.SetRootActor(mBlurRootActor);
mBlurFilter.SetBackgroundColor(Vector4::ZERO);
mRenderSceneTask.SetCameraActor( mCameraActor );
mRenderSceneTask.SetSourceActor( mChildrenRoot );
- mRenderSceneTask.SetTargetFrameBuffer( mSceneFromLightRenderTarget );
+ mRenderSceneTask.SetFrameBuffer( mSceneFromLightRenderTarget );
mRenderSceneTask.SetInputEnabled( false );
mRenderSceneTask.SetClearEnabled( true );
void CreateBlurFilter();
private:
- Toolkit::ImageView mShadowPlane; // Shadow renders into this actor
+ Actor mShadowPlane; // Shadow renders into this actor
Actor mShadowPlaneBg; // mShadowPlane renders directly in front of this actor
Actor mPointLight; // Shadow is cast from this point light
/////////////////////////////////////////////////////////////
- FrameBufferImage mSceneFromLightRenderTarget; // for rendering normal scene seen from light to texture instead of the screen
+ FrameBuffer mSceneFromLightRenderTarget; // for rendering normal scene seen from light to texture instead of the screen
- FrameBufferImage mOutputImage;
+ FrameBuffer mOutputFrameBuffer;
Actor mChildrenRoot; // Subtree for all user added child actors that should be rendered normally
Actor mBlurRootActor; // Root actor for blur filter processing
// INTERNAL_INCLUDES
#include <dali-toolkit/public-api/image-loader/sync-image-loader.h>
#include <dali-toolkit/devel-api/controls/control-devel.h>
+#include <dali-toolkit/internal/controls/control/control-renderers.h>
#include <dali-toolkit/internal/visuals/visual-base-impl.h>
#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
Vector2 mRange;
};
-#define DALI_COMPOSE_SHADER(STR) #STR
-
-const char * const BASIC_VERTEX_SOURCE = DALI_COMPOSE_SHADER(
- precision mediump float;\n
- attribute mediump vec2 aPosition;\n
- attribute mediump vec2 aTexture;\n
- varying mediump vec2 vTexCoord;\n
- uniform mediump mat4 uMvpMatrix;\n
- uniform mediump vec3 uSize;\n
- \n
- void main()\n
- {\n
- mediump vec4 vertexPosition = vec4(aPosition * uSize.xy, 0.0, 1.0);\n
- vTexCoord = aTexture;\n
- gl_Position = uMvpMatrix * vertexPosition;\n
- }\n
-);
-
-const char * const BASIC_FRAGMENT_SOURCE = DALI_COMPOSE_SHADER(
- precision mediump float;\n
- varying mediump vec2 vTexCoord;\n
- uniform sampler2D sTexture;\n
- uniform vec4 uColor;\n
- \n
- void main()\n
- {\n
- gl_FragColor = texture2D(sTexture, vTexCoord);\n
- gl_FragColor *= uColor;
- }\n
-);
-
-Renderer CreateRenderer( const char* vertexSrc, const char* fragmentSrc )
-{
- Shader shader = Shader::New( vertexSrc, fragmentSrc );
-
- Geometry texturedQuadGeometry = Geometry::New();
-
- struct VertexPosition { Vector2 position; };
- struct VertexTexture { Vector2 texture; };
-
- VertexPosition positionArray[] =
- {
- { Vector2( -0.5f, -0.5f ) },
- { Vector2( 0.5f, -0.5f ) },
- { Vector2( -0.5f, 0.5f ) },
- { Vector2( 0.5f, 0.5f ) }
- };
- uint32_t numberOfVertices = sizeof(positionArray)/sizeof(VertexPosition);
-
- VertexTexture uvArray[] =
- {
- { Vector2( 0.0f, 0.0f ) },
- { Vector2( 1.0f, 0.0f ) },
- { Vector2( 0.0f, 1.0f ) },
- { Vector2( 1.0f, 1.0f ) }
- };
-
- Property::Map positionVertexFormat;
- positionVertexFormat["aPosition"] = Property::VECTOR2;
- PropertyBuffer positionVertices = PropertyBuffer::New( positionVertexFormat );
- positionVertices.SetData( positionArray, numberOfVertices );
- texturedQuadGeometry.AddVertexBuffer( positionVertices );
-
- Property::Map textureVertexFormat;
- textureVertexFormat["aTexture"] = Property::VECTOR2;
- PropertyBuffer textureVertices = PropertyBuffer::New( textureVertexFormat );
- textureVertices.SetData( uvArray, numberOfVertices );
- texturedQuadGeometry.AddVertexBuffer( textureVertices );
-
- const uint16_t indices[] = { 0, 3, 1, 0, 2, 3 };
- texturedQuadGeometry.SetIndexBuffer ( &indices[0], sizeof( indices )/ sizeof( indices[0] ) );
-
- Renderer renderer = Renderer::New( texturedQuadGeometry, shader );
-
- TextureSet textureSet = TextureSet::New();
- renderer.SetTextures( textureSet );
-
- return renderer;
-}
-
-void SetRendererTexture( Renderer& renderer, Texture& texture )
-{
- if( renderer )
- {
- TextureSet textureSet = renderer.GetTextures();
- textureSet.SetTexture( 0u, texture );
- }
-}
-
-void SetRendererTexture( Renderer& renderer, FrameBuffer& frameBuffer )
-{
- if( frameBuffer )
- {
- Texture texture = frameBuffer.GetColorTexture();
- SetRendererTexture( renderer, texture );
- }
-}
-
} // namespace
namespace Dali
$(toolkit_src_dir)/controls/buttons/toggle-button-impl.cpp \
$(toolkit_src_dir)/controls/control/control-data-impl.cpp \
$(toolkit_src_dir)/controls/control/control-debug.cpp \
+ $(toolkit_src_dir)/controls/control/control-renderers.cpp \
$(toolkit_src_dir)/controls/effects-view/effects-view-impl.cpp \
$(toolkit_src_dir)/controls/flex-container/flex-container-impl.cpp \
$(toolkit_src_dir)/controls/gaussian-blur-view/gaussian-blur-view-impl.cpp \
#include <dali/public-api/object/property-map.h>
#include <dali/public-api/render-tasks/render-task-list.h>
#include <dali/public-api/rendering/renderer.h>
-#include <dali/devel-api/images/texture-set-image.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/internal/controls/control/control-renderers.h>
namespace Dali
{
{
// create blending actor and register the property in constructor
// to make sure that GetBlurStrengthPropertyIndex() always returns a valid index
- mActorForBlending = Toolkit::ImageView::New();
+ mActorForBlending = Actor::New();
mBlurStrengthPropertyIndex = mActorForBlending.RegisterProperty( BLUR_STRENGTH_UNIFORM_NAME, 1.f );
}
void BlurTwoPassFilter::Enable()
{
+ // create custom shader effect
+ if( !GetKernelSize() )
+ {
+ CreateKernel( DEFAULT_KERNEL4, sizeof(DEFAULT_KERNEL4)/sizeof(DEFAULT_KERNEL4[0]) );
+ }
+ int kernelSize( static_cast< int >(GetKernelSize()) );
+
+ // Set up blur-two-pass custom shader
+ std::ostringstream sstream;
+ sstream << "#define NUM_SAMPLES " << kernelSize << "\n";
+ sstream << BLUR_TWO_PASS_FRAGMENT_SOURCE;
+ std::string fragmentSource( sstream.str() );
+
// create actor to render input with applied emboss effect
- mActorForInput = Toolkit::ImageView::New( mInputImage );
+ mActorForInput = Actor::New();
mActorForInput.SetParentOrigin( ParentOrigin::CENTER );
mActorForInput.SetSize( mTargetSize );
+ Renderer rendererForInput = CreateRenderer( BASIC_VERTEX_SOURCE, fragmentSource.c_str() );
+ SetRendererTexture( rendererForInput, mInputTexture );
+ mActorForInput.AddRenderer( rendererForInput );
// create internal offscreen for result of horizontal pass
- mImageForHorz = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat );
+ mFrameBufferForHorz = FrameBuffer::New( mTargetSize.width, mTargetSize.height, FrameBuffer::Attachment::NONE );
+ Texture textureForHorz = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mTargetSize.width), unsigned(mTargetSize.height) );
+ mFrameBufferForHorz.AttachColorTexture( textureForHorz );
+
// create an actor to render mImageForHorz for vertical blur pass
- mActorForHorz = Toolkit::ImageView::New( mImageForHorz );
+ mActorForHorz = Actor::New();
mActorForHorz.SetParentOrigin( ParentOrigin::CENTER );
mActorForHorz.SetSize( mTargetSize );
+ Renderer rendererForHorz = CreateRenderer( BASIC_VERTEX_SOURCE, fragmentSource.c_str() );
+ SetRendererTexture( rendererForHorz, textureForHorz );
+ mActorForHorz.AddRenderer( rendererForHorz );
// create internal offscreen for result of the two pass blurred image
- mBlurredImage = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat );
+ mBlurredFrameBuffer = FrameBuffer::New( mTargetSize.width, mTargetSize.height, FrameBuffer::Attachment::NONE );
+ Texture blurredTexture = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mTargetSize.width), unsigned(mTargetSize.height) );
+ mBlurredFrameBuffer.AttachColorTexture( blurredTexture );
+
// create an actor to blend the blurred image and the input image with the given blur strength
- mActorForBlending.SetImage( mBlurredImage );
+ Renderer rendererForBlending = CreateRenderer( BASIC_VERTEX_SOURCE, BLEND_TWO_IMAGES_FRAGMENT_SOURCE );
+ TextureSet textureSetForBlending = rendererForBlending.GetTextures();
+ textureSetForBlending.SetTexture( 0u, blurredTexture );
+ textureSetForBlending.SetTexture( 1u, mInputTexture );
+ mActorForBlending.AddRenderer( rendererForBlending );
mActorForBlending.SetParentOrigin( ParentOrigin::CENTER );
mActorForBlending.SetSize( mTargetSize );
- // create custom shader effect
- if( !GetKernelSize() )
- {
- CreateKernel( DEFAULT_KERNEL4, sizeof(DEFAULT_KERNEL4)/sizeof(DEFAULT_KERNEL4[0]) );
- }
- int kernelSize( static_cast< int >(GetKernelSize()) );
-
for( int i = 0; i < kernelSize; ++i )
{
const std::string offsetUniform( GetOffsetUniformName( i ) );
mActorForHorz.RegisterProperty( weightUniform, mKernel[i].z );
}
- // Set up blur-two-pass custom shader
- std::ostringstream fragmentSource;
- fragmentSource << "#define NUM_SAMPLES " << kernelSize << "\n";
- fragmentSource << BLUR_TWO_PASS_FRAGMENT_SOURCE;
-
- Property::Map customShader;
- customShader[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = fragmentSource.str();
- Property::Map visualMap;
- visualMap.Insert( Toolkit::Visual::Property::SHADER, customShader );
- mActorForInput.SetProperty( Toolkit::ImageView::Property::IMAGE, visualMap );
- mActorForHorz.SetProperty( Toolkit::ImageView::Property::IMAGE, visualMap );
-
- // Set up blend-two-image custom shader
- customShader[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = BLEND_TWO_IMAGES_FRAGMENT_SOURCE;
- visualMap[ Toolkit::Visual::Property::SHADER ] = customShader;
- mActorForBlending.SetProperty( Toolkit::ImageView::Property::IMAGE, visualMap );
-
mRootActor.Add( mActorForInput );
mRootActor.Add( mActorForHorz );
mRootActor.Add( mActorForBlending );
- // Add effect texture to blend-two-image custom shader
- TextureSet textureSet = mActorForBlending.GetRendererAt(0).GetTextures();
- if( textureSet )
- {
- TextureSetImage( textureSet, 1u, mInputImage );
- }
-
SetupCamera();
CreateRenderTasks();
}
mRenderTaskForHorz.SetInputEnabled( false );
mRenderTaskForHorz.SetClearEnabled( true );
mRenderTaskForHorz.SetClearColor( mBackgroundColor );
- mRenderTaskForHorz.SetTargetFrameBuffer( mImageForHorz );
+ mRenderTaskForHorz.SetFrameBuffer( mFrameBufferForHorz );
mRenderTaskForHorz.SetCameraActor( mCameraActor );
// use the internal buffer and perform a horizontal blur targeting the output buffer
mRenderTaskForVert.SetInputEnabled( false );
mRenderTaskForVert.SetClearEnabled( true );
mRenderTaskForVert.SetClearColor( mBackgroundColor );
- mRenderTaskForVert.SetTargetFrameBuffer( mBlurredImage );
+ mRenderTaskForVert.SetFrameBuffer( mBlurredFrameBuffer );
mRenderTaskForVert.SetCameraActor( mCameraActor );
//Perform a blending between the blurred image and the input image
mRenderTaskForBlending.SetInputEnabled( false );
mRenderTaskForBlending.SetClearEnabled( true );
mRenderTaskForBlending.SetClearColor( mBackgroundColor );
- mRenderTaskForBlending.SetTargetFrameBuffer( mOutputImage );
+ mRenderTaskForBlending.SetFrameBuffer( mOutputFrameBuffer );
mRenderTaskForBlending.SetCameraActor( mCameraActor );
}
// EXTERNAL INCLUDES
#include <dali/public-api/render-tasks/render-task.h>
-#include <dali-toolkit/public-api/controls/image-view/image-view.h>
// INTERNAL INCLUDES
#include "image-filter.h"
private: // Attributes
- // To perform horizontal blur from mInputImage to mImageForHorz
+ // To perform horizontal blur from mInputTexture to mFrameBufferForHorz
RenderTask mRenderTaskForHorz;
- Toolkit::ImageView mActorForInput;
- FrameBufferImage mImageForHorz;
+ Actor mActorForInput;
+ FrameBuffer mFrameBufferForHorz;
- // To perform vertical blur from mImageForHorz to mOutputImage
+ // To perform vertical blur from mFrameBufferForHorz to mOutputFrameBuffer
RenderTask mRenderTaskForVert;
- Toolkit::ImageView mActorForHorz;
- FrameBufferImage mBlurredImage;
+ Actor mActorForHorz;
+ FrameBuffer mBlurredFrameBuffer;
// To blend the blurred image and input image according to the blur strength
RenderTask mRenderTaskForBlending;
- Toolkit::ImageView mActorForBlending;
+ Actor mActorForBlending;
Actor mRootActorForBlending;
Property::Index mBlurStrengthPropertyIndex;
#include <dali/public-api/object/property-map.h>
#include <dali/public-api/render-tasks/render-task-list.h>
#include <dali/public-api/rendering/renderer.h>
-#include <dali/devel-api/images/texture-set-image.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
-#include <dali-toolkit/internal/visuals/visual-base-impl.h>
-#include <dali-toolkit/internal/visuals/visual-factory-impl.h>
+#include <dali-toolkit/internal/controls/control/control-renderers.h>
namespace Dali
{
void EmbossFilter::Enable()
{
- mImageForEmboss1 = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat );
- mImageForEmboss2 = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat );
+ mFrameBufferForEmboss1 = FrameBuffer::New( mTargetSize.width, mTargetSize.height, FrameBuffer::Attachment::NONE );
+ Texture texture1 = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mTargetSize.width), unsigned(mTargetSize.height) );
+ mFrameBufferForEmboss1.AttachColorTexture( texture1 );
- Property::Map customShader;
- customShader[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = EMBOSS_FRAGMENT_SOURCE;
- Property::Map visualMap;
- visualMap.Insert( Toolkit::Visual::Property::SHADER, customShader );
+ mFrameBufferForEmboss2 = FrameBuffer::New( mTargetSize.width, mTargetSize.height, FrameBuffer::Attachment::NONE );
+ Texture texture2 = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mTargetSize.width), unsigned(mTargetSize.height) );
+ mFrameBufferForEmboss2.AttachColorTexture( texture2 );
// create actor to render input with applied emboss effect
- mActorForInput1 = Toolkit::ImageView::New(mInputImage);
+ mActorForInput1 = Actor::New();
mActorForInput1.SetParentOrigin( ParentOrigin::CENTER );
mActorForInput1.SetSize(mTargetSize);
Vector2 textureScale( 1.5f/mTargetSize.width, 1.5f/mTargetSize.height);
mActorForInput1.RegisterProperty( TEX_SCALE_UNIFORM_NAME, textureScale );
mActorForInput1.RegisterProperty( COEFFICIENT_UNIFORM_NAME, Vector3( 2.f, -1.f, -1.f ) );
// set EMBOSS custom shader
- mActorForInput1.SetProperty( Toolkit::ImageView::Property::IMAGE, visualMap );
+ Renderer renderer1 = CreateRenderer( BASIC_VERTEX_SOURCE, EMBOSS_FRAGMENT_SOURCE );
+ SetRendererTexture( renderer1, mInputTexture );
+ mActorForInput1.AddRenderer( renderer1 );
mRootActor.Add( mActorForInput1 );
- mActorForInput2 = Toolkit::ImageView::New(mInputImage);
+ mActorForInput2 = Actor::New();
mActorForInput2.SetParentOrigin( ParentOrigin::CENTER );
mActorForInput2.SetSize(mTargetSize);
mActorForInput2.RegisterProperty( TEX_SCALE_UNIFORM_NAME, textureScale );
mActorForInput2.RegisterProperty( COEFFICIENT_UNIFORM_NAME, Vector3( -1.f, -1.f, 2.f ) );
// set EMBOSS custom shader
- mActorForInput2.SetProperty( Toolkit::ImageView::Property::IMAGE, visualMap );
+ Renderer renderer2 = CreateRenderer( BASIC_VERTEX_SOURCE, EMBOSS_FRAGMENT_SOURCE );
+ SetRendererTexture( renderer2, mInputTexture );
+ mActorForInput2.AddRenderer( renderer2 );
mRootActor.Add( mActorForInput2 );
mActorForComposite = Actor::New();
mActorForComposite.SetSize(mTargetSize);
mActorForComposite.SetColor( Color::BLACK );
- customShader[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = COMPOSITE_FRAGMENT_SOURCE;
-
mRootActor.Add( mActorForComposite );
- Internal::InitializeVisual( mActorForComposite, mVisualForEmboss1, mImageForEmboss1 );
- Toolkit::GetImplementation( mVisualForEmboss1 ).SetCustomShader( customShader );
- mActorForComposite.GetRendererAt(0).RegisterProperty( COLOR_UNIFORM_NAME, Color::BLACK );
- Internal::InitializeVisual( mActorForComposite, mVisualForEmboss2, mImageForEmboss2 );
- Toolkit::GetImplementation( mVisualForEmboss2 ).SetCustomShader( customShader );
- mActorForComposite.GetRendererAt(1).RegisterProperty( COLOR_UNIFORM_NAME, Color::WHITE );
+ mRendererForEmboss1 = CreateRenderer( BASIC_VERTEX_SOURCE, COMPOSITE_FRAGMENT_SOURCE );
+ SetRendererTexture( mRendererForEmboss1, mFrameBufferForEmboss1 );
+ mRendererForEmboss1.RegisterProperty( COLOR_UNIFORM_NAME, Color::BLACK );
+ mActorForComposite.AddRenderer( mRendererForEmboss1 );
+
+ mRendererForEmboss2 = CreateRenderer( BASIC_VERTEX_SOURCE, COMPOSITE_FRAGMENT_SOURCE );
+ SetRendererTexture( mRendererForEmboss2, mFrameBufferForEmboss2 );
+ mRendererForEmboss2.RegisterProperty( COLOR_UNIFORM_NAME, Color::WHITE );
+ mActorForComposite.AddRenderer( mRendererForEmboss2 );
SetupCamera();
CreateRenderTasks();
if( mActorForComposite )
{
- Toolkit::GetImplementation(mVisualForEmboss1).SetOffStage( mActorForComposite );
- Toolkit::GetImplementation(mVisualForEmboss2).SetOffStage( mActorForComposite );
- mVisualForEmboss1.Reset();
- mVisualForEmboss2.Reset();
+ mActorForComposite.RemoveRenderer( mRendererForEmboss1 );
+ mRendererForEmboss1.Reset();
+
+ mActorForComposite.RemoveRenderer( mRendererForEmboss2 );
+ mRendererForEmboss2.Reset();
+
mRootActor.Remove( mActorForComposite );
mActorForComposite.Reset();
}
mRenderTaskForEmboss1.SetInputEnabled( false );
mRenderTaskForEmboss1.SetClearColor( Vector4( 0.0f, 0.0f, 0.0f, 0.0f ) );
mRenderTaskForEmboss1.SetClearEnabled( true );
- mRenderTaskForEmboss1.SetTargetFrameBuffer( mImageForEmboss1 );
+ mRenderTaskForEmboss1.SetFrameBuffer( mFrameBufferForEmboss1 );
mRenderTaskForEmboss1.SetCameraActor( mCameraActor );
mRenderTaskForEmboss2 = taskList.CreateTask();
mRenderTaskForEmboss2.SetInputEnabled( false );
mRenderTaskForEmboss2.SetClearColor( Vector4( 1.0f, 1.0f, 1.0f, 0.0f ) );
mRenderTaskForEmboss2.SetClearEnabled( true );
- mRenderTaskForEmboss2.SetTargetFrameBuffer( mImageForEmboss2 );
+ mRenderTaskForEmboss2.SetFrameBuffer( mFrameBufferForEmboss2 );
mRenderTaskForEmboss2.SetCameraActor( mCameraActor );
mRenderTaskForOutput = taskList.CreateTask();
mRenderTaskForOutput.SetInputEnabled( false );
mRenderTaskForOutput.SetClearColor( Vector4( 0.5f, 0.5f, 0.5f, 0.0f ) );
mRenderTaskForOutput.SetClearEnabled( true );
- mRenderTaskForOutput.SetTargetFrameBuffer( mOutputImage );
+ mRenderTaskForOutput.SetFrameBuffer( mOutputFrameBuffer );
mRenderTaskForOutput.SetCameraActor( mCameraActor );
}
// EXTERNAL INCLUDES
#include <dali/public-api/render-tasks/render-task.h>
-#include <dali-toolkit/public-api/controls/image-view/image-view.h>
-#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
+#include <dali/public-api/rendering/frame-buffer.h>
+#include <dali/public-api/rendering/renderer.h>
+
+// INTERNAL INCLUDES
#include "image-filter.h"
namespace Dali
RenderTask mRenderTaskForEmboss1;
RenderTask mRenderTaskForEmboss2;
RenderTask mRenderTaskForOutput;
- FrameBufferImage mImageForEmboss1;
- FrameBufferImage mImageForEmboss2;
- Toolkit::ImageView mActorForInput1;
- Toolkit::ImageView mActorForInput2;
- Toolkit::Visual::Base mVisualForEmboss1;
- Toolkit::Visual::Base mVisualForEmboss2;
+ FrameBuffer mFrameBufferForEmboss1;
+ FrameBuffer mFrameBufferForEmboss2;
+ Actor mActorForInput1;
+ Actor mActorForInput2;
+ Renderer mRendererForEmboss1;
+ Renderer mRendererForEmboss2;
Actor mActorForComposite;
}; // class EmbossFilter
mRefreshOnDemand = onDemand;
}
-void ImageFilter::SetInputImage( Image image )
+void ImageFilter::SetInputTexture( Texture texture )
{
- mInputImage = image;
+ mInputTexture = texture;
}
-void ImageFilter::SetOutputImage( FrameBufferImage image )
+void ImageFilter::SetOutputFrameBuffer( FrameBuffer frameBuffer )
{
- mOutputImage = image;
+ mOutputFrameBuffer = frameBuffer;
}
void ImageFilter::SetSize( const Vector2& size )
// EXTERNAL INCLUDES
#include <dali/public-api/actors/camera-actor.h>
+#include <dali/public-api/rendering/frame-buffer.h>
+#include <dali/public-api/rendering/texture.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control-impl.h>
/**
* An interface class that provides a interface for image filters that perform
- * a simple shader effect on an input image, rendering the output to a FrameBufferImage.
+ * a simple shader effect on an input texture, rendering the output to a FrameBuffer.
*/
class ImageFilter
{
void SetRefreshOnDemand( bool onDemand );
/**
- * Set the input image
- * @param[in] The input/original image.
+ * Set the input texture
+ * @param[in] The input/original texture.
*/
- void SetInputImage( Image image );
+ void SetInputTexture( Texture texture );
/**
- * Set the output image
- * @return The output image.
+ * Set the output frame buffer
+ * @return The output frame buffer.
*/
- void SetOutputImage( FrameBufferImage image );
+ void SetOutputFrameBuffer( FrameBuffer frameBuffer );
/**
* Set size of ImageFilter. Used to create internal offscreen buffers
void SetupCamera();
protected:
- Image mInputImage;
- FrameBufferImage mOutputImage;
+ Texture mInputTexture;
+ FrameBuffer mOutputFrameBuffer;
FilterKernel mKernel;
Actor mRootActor;
CameraActor mCameraActor;
#include <dali/public-api/render-tasks/render-task-list.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/public-api/visuals/visual-properties.h>
+#include <dali-toolkit/internal/controls/control/control-renderers.h>
namespace Dali
{
void SpreadFilter::Enable()
{
// create actor to render input with applied emboss effect
- mActorForInput = Toolkit::ImageView::New( mInputImage );
+ mActorForInput = Actor::New();
mActorForInput.SetParentOrigin( ParentOrigin::CENTER );
mActorForInput.SetSize(mTargetSize);
// register properties as shader uniforms
mActorForInput.RegisterProperty( SPREAD_UNIFORM_NAME, mSpread );
mActorForInput.RegisterProperty( TEX_SCALE_UNIFORM_NAME, Vector2( 1.0f / mTargetSize.width, 0.0f ) );
+ Renderer rendererForInput = CreateRenderer( BASIC_VERTEX_SOURCE, SPREAD_FRAGMENT_SOURCE );
+ SetRendererTexture( rendererForInput, mInputTexture );
+ mActorForInput.AddRenderer( rendererForInput );
+
// create internal offscreen for result of horizontal pass
- mImageForHorz = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat );
+ mFrameBufferForHorz = FrameBuffer::New( mTargetSize.width, mTargetSize.height, FrameBuffer::Attachment::NONE );
+ Texture textureForHorz = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mTargetSize.width), unsigned(mTargetSize.height) );
+ mFrameBufferForHorz.AttachColorTexture( textureForHorz );
+
// create an actor to render mImageForHorz for vertical blur pass
- mActorForHorz = Toolkit::ImageView::New( mImageForHorz );
+ mActorForHorz = Actor::New();
mActorForHorz.SetParentOrigin( ParentOrigin::CENTER );
mActorForHorz.SetSize(mTargetSize);
// register properties as shader uniforms
mActorForHorz.RegisterProperty( SPREAD_UNIFORM_NAME, mSpread );
mActorForHorz.RegisterProperty( TEX_SCALE_UNIFORM_NAME, Vector2( 0.0f, 1.0f / mTargetSize.height ) );
-
- Property::Map customShader;
- customShader[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = SPREAD_FRAGMENT_SOURCE;
- Property::Map visualMap;
- visualMap.Insert( Toolkit::Visual::Property::SHADER, customShader );
-
- // set SPREAD custom shader
- mActorForInput.SetProperty( Toolkit::ImageView::Property::IMAGE, visualMap );
- mActorForHorz.SetProperty( Toolkit::ImageView::Property::IMAGE, visualMap );
+ Renderer rendererForHorz = CreateRenderer( BASIC_VERTEX_SOURCE, SPREAD_FRAGMENT_SOURCE );
+ SetRendererTexture( rendererForHorz, textureForHorz );
+ mActorForHorz.AddRenderer( rendererForHorz );
mRootActor.Add( mActorForInput );
mRootActor.Add( mActorForHorz );
mRenderTaskForHorz.SetInputEnabled( false );
mRenderTaskForHorz.SetClearEnabled( true );
mRenderTaskForHorz.SetClearColor( mBackgroundColor );
- mRenderTaskForHorz.SetTargetFrameBuffer( mImageForHorz );
+ mRenderTaskForHorz.SetFrameBuffer( mFrameBufferForHorz );
mRenderTaskForHorz.SetCameraActor( mCameraActor );
// use the internal buffer and perform a horizontal blur targeting the output buffer
mRenderTaskForVert.SetInputEnabled( false );
mRenderTaskForVert.SetClearEnabled( true );
mRenderTaskForVert.SetClearColor( mBackgroundColor );
- mRenderTaskForVert.SetTargetFrameBuffer( mOutputImage );
+ mRenderTaskForVert.SetFrameBuffer( mOutputFrameBuffer );
mRenderTaskForVert.SetCameraActor( mCameraActor );
}
// EXTERNAL INCLUDES
#include <dali/public-api/render-tasks/render-task.h>
-#include <dali-toolkit/public-api/controls/image-view/image-view.h>
// INTERNAL INCLUDES
#include "image-filter.h"
private: // Attributes
- // To perform horizontal spread from mInputImage to mImageForHorz
+ // To perform horizontal spread from mInputTexture to mFrameBufferForHorz
RenderTask mRenderTaskForHorz;
- Toolkit::ImageView mActorForInput;
- FrameBufferImage mImageForHorz;
+ Actor mActorForInput;
+ FrameBuffer mFrameBufferForHorz;
- // To perform vertical spread from mImageForHorz to mOutputImage
+ // To perform vertical spread from mFrameBufferForHorz to mOutputFrameBuffer
RenderTask mRenderTaskForVert;
- Toolkit::ImageView mActorForHorz;
+ Actor mActorForHorz;
int mSpread;
}; // class SpreadFilter
projects / platform / core / uifw / dali-toolkit.git / commitdiff