const char* const IMAGE_PATH_2 ( DEMO_IMAGE_DIR "people-medium-7.jpg" );
const char* const IMAGE_PATH_3 ( DEMO_IMAGE_DIR "people-medium-7-rgb565.png" ); // is compressed
const char* const IMAGE_PATH_4 ( DEMO_IMAGE_DIR "people-medium-7-masked.png" ); // has alpha channel
-const char* const MASK_IMAGE_PATH_1 ( DEMO_IMAGE_DIR "mask.png" );
-const char* const MASK_IMAGE_PATH_2 ( DEMO_IMAGE_DIR "mask-large.png" ); // 300x300
+const char* const MASK_IMAGE_PATH_1 ( DEMO_IMAGE_DIR "store_mask_profile_n.png" ); // 300x300
+const char* const MASK_IMAGE_PATH_2 ( DEMO_IMAGE_DIR "store_mask_profile_f.png" );
}
class ImageViewAlphaBlendApp : public ConnectionTracker
mImageLabel.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
mImageLabel.SetAnchorPoint( ParentOrigin::BOTTOM_CENTER );
mImageLabel.SetPosition( Vector3( 0.0f, -50.0f, 0.0f ) );
- mImageLabel.SetProperty( Toolkit::TextLabel::Property::TEXT_COLOR, Color::GREEN );
+ mImageLabel.SetProperty( Toolkit::TextLabel::Property::TEXT_COLOR, Color::BLACK );
stage.Add(mImageLabel);
mMaskLabel = Toolkit::TextLabel::New();
mMaskLabel.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
mMaskLabel.SetAnchorPoint( ParentOrigin::BOTTOM_CENTER );
mMaskLabel.SetPosition( Vector3( 0.0f, 0.0f, 0.0f ) );
- mMaskLabel.SetProperty( Toolkit::TextLabel::Property::TEXT_COLOR, Color::GREEN );
+ mMaskLabel.SetProperty( Toolkit::TextLabel::Property::TEXT_COLOR, Color::BLACK );
stage.Add(mMaskLabel);
LoadImages();
const char* mask = masks[mImageCombinationIndex%2 ]; // Cycle through masks
const char* image = images[(mImageCombinationIndex/2)%4]; // then images
+
Property::Map map;
map.Add( Toolkit::Visual::Property::TYPE, Toolkit::Visual::Type::IMAGE );
map.Add( Toolkit::ImageVisual::Property::URL, image );
map.Add( Toolkit::DevelImageVisual::Property::ALPHA_MASK_URL, mask );
+
+ if( mImageCombinationIndex%2 == 0 )
+ {
+ map.Add( Toolkit::DevelImageVisual::Property::MASK_CONTENT_SCALE, 1.f );
+ map.Add( Toolkit::DevelImageVisual::Property::CROP_TO_MASK, false );
+ }
+ else
+ {
+ map.Add( Toolkit::DevelImageVisual::Property::MASK_CONTENT_SCALE, 1.6f );
+ map.Add( Toolkit::DevelImageVisual::Property::CROP_TO_MASK, true );
+ }
+
mImageView.SetProperty( Toolkit::ImageView::Property::IMAGE, map );
mImageLabel.SetProperty( Toolkit::TextLabel::Property::TEXT, strrchr(image, '/') );
#include <dali-toolkit/dali-toolkit.h>
#include <dali-toolkit/devel-api/controls/buttons/button-devel.h>
-
+#include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
#include "shared/utility.h"
using namespace Dali;
const char* const ANIMATE_PIXEL_AREA( "Animate PixelArea" );
const char* const ANIMATE_PIXEL_AREA_AND_SCALE( "Animate PixelArea & Scale" );
+const char* const STATIC_IMAGE_ARRAY_DOG( DEMO_IMAGE_DIR "dog-anim-001.png" );
+const char* const ANIMATE_IMAGE_ARRAY_DOG( DEMO_IMAGE_DIR "dog-anim-%03d.png" );
+
+const char* const STATIC_IMAGE_ARRAY_LOGO( DEMO_IMAGE_DIR "dali-logo-anim-001.png" );
+const char* const ANIMATE_IMAGE_ARRAY_LOGO( DEMO_IMAGE_DIR "dali-logo-anim-%03d.png" );
+
+
const Vector4 DIM_COLOR( 0.85f, 0.85f, 0.85f, 0.85f );
}
class AnimatedImageController : public ConnectionTracker
{
public:
+ enum ImageType
+ {
+ GIF,
+ IMAGE_ARRAY
+ };
+ enum StateType
+ {
+ STATIC,
+ ANIMATED
+ };
AnimatedImageController( Application& application )
- : mApplication( application )
+ : mApplication( application ),
+ mImageType(GIF)
{
// Connect to the Application's Init signal
mApplication.InitSignal().Connect( this, &AnimatedImageController::Create );
// Tie-in input event handlers:
stage.KeyEventSignal().Connect( this, &AnimatedImageController::OnKeyEvent );
- mActorDog = CreateGifViewWithOverlayPlayButton( STATIC_GIF_DOG );
- mActorDog.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
- mActorDog.SetY( -100.f );
- stage.Add( mActorDog );
-
- mActorLogo = CreateGifViewWithOverlayPlayButton( STATIC_GIF_LOGO );
- mActorLogo.SetAnchorPoint( AnchorPoint::TOP_CENTER );
- mActorLogo.SetY( 100.f );
- stage.Add( mActorLogo );
+ CreateStaticImageView( 0 );
+ CreateStaticImageView( 1 );
+
+ mGifButton = Toolkit::RadioButton::New("Gif");
+ mGifButton.SetProperty( Button::Property::SELECTED, true );
+ mArrayButton = Toolkit::RadioButton::New("Array");
+ mGifButton.ClickedSignal().Connect( this, &AnimatedImageController::OnTypeButtonClicked );
+ mArrayButton.ClickedSignal().Connect( this, &AnimatedImageController::OnTypeButtonClicked );
+
+ Toolkit::TableView radioButtonLayout = Toolkit::TableView::New(1, 2);
+ radioButtonLayout.SetName("RadioButtonsLayout");
+ radioButtonLayout.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::HEIGHT );
+ radioButtonLayout.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
+ radioButtonLayout.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
+ radioButtonLayout.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
+ radioButtonLayout.SetFitHeight(0);
+ radioButtonLayout.AddChild( mGifButton, TableView::CellPosition(0,0) );
+ radioButtonLayout.AddChild( mArrayButton, TableView::CellPosition(0,1) );
+ radioButtonLayout.SetCellAlignment( TableView::CellPosition( 0, 0 ), HorizontalAlignment::CENTER, VerticalAlignment::CENTER );
+ radioButtonLayout.SetCellAlignment( TableView::CellPosition( 0, 1 ), HorizontalAlignment::CENTER, VerticalAlignment::CENTER );
+ radioButtonLayout.SetY( -10.0f );
+
+ stage.Add( radioButtonLayout );
mTapDetector = TapGestureDetector::New();
mTapDetector.DetectedSignal().Connect( this, &AnimatedImageController::OnTap );
}
+ void CreateStaticImageView( int index )
+ {
+ Actor& actor = (index==0) ? mActorDog : mActorLogo;
+
+ Stage stage = Stage::GetCurrent();
+ if( actor )
+ {
+ stage.Remove( actor );
+ }
+
+ Property::Value viewSetup = SetupViewProperties( mImageType, STATIC, index, false );
+ actor = CreateImageViewWithPlayButton( viewSetup );
+ SetLayout(actor, index);
+ stage.Add( actor );
+ }
+
+
+ void CreateAnimImageView( int index )
+ {
+ Actor& actor = (index==0) ? mActorDog : mActorLogo;
+
+ Stage stage = Stage::GetCurrent();
+ if( actor )
+ {
+ stage.Remove( actor );
+ }
+
+ const char* label = (index==0) ? ANIMATE_PIXEL_AREA_AND_SCALE : ANIMATE_PIXEL_AREA;
+
+ Property::Value viewSetup = SetupViewProperties( mImageType, ANIMATED, index, true );
+ actor = CreateImageViewWithAnimatePixelAreaButton( viewSetup, label);
+ SetLayout(actor, index);
+
+ stage.Add( actor );
+ }
+
+ void SetLayout( Actor actor, int index )
+ {
+ if( index == 0 )
+ {
+ actor.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
+ actor.SetY( -80.f );
+ }
+ else
+ {
+ actor.SetAnchorPoint( AnchorPoint::TOP_CENTER );
+ actor.SetY( 80.f );
+ }
+ }
+
/**
* Create the gif image view with an overlay play button.
*/
- Toolkit::ImageView CreateGifViewWithOverlayPlayButton( const std::string& gifUrl )
+ Toolkit::ImageView CreateImageViewWithPlayButton( Property::Value& viewSetup )
{
- Toolkit::ImageView imageView = Toolkit::ImageView::New( gifUrl );
+ Toolkit::ImageView imageView = Toolkit::ImageView::New();
+ imageView.SetProperty( ImageView::Property::IMAGE, viewSetup );
imageView.SetParentOrigin( ParentOrigin::CENTER );
// Create a push button, and add it as child of the image view
return imageView;
}
- Toolkit::ImageView CreateGifViewWithAnimatePixelAreaButton( const std::string& gifUrl, WrapMode::Type wrapModeU, WrapMode::Type wrapModeV, const std::string& buttonLabel )
+ Toolkit::ImageView CreateImageViewWithAnimatePixelAreaButton( Property::Value& viewSetup, const std::string& buttonLabel )
{
Toolkit::ImageView imageView = Toolkit::ImageView::New();
- imageView.SetProperty( Toolkit::ImageView::Property::IMAGE,
- Property::Map().Add( Toolkit::ImageVisual::Property::URL, gifUrl )
- .Add( Toolkit::ImageVisual::Property::WRAP_MODE_U, wrapModeU )
- .Add( Toolkit::ImageVisual::Property::WRAP_MODE_V, wrapModeV ));
+ imageView.SetProperty( Toolkit::ImageView::Property::IMAGE, viewSetup );
imageView.SetParentOrigin( ParentOrigin::CENTER );
// Create a push button, and add it as child of the image view
if( button.GetParent() == mActorDog )
{
// remove the static gif view, the play button is also removed as its child.
- stage.Remove( mActorDog );
-
- mActorDog = CreateGifViewWithAnimatePixelAreaButton( ANIMATE_GIF_DOG, WrapMode::REPEAT, WrapMode::DEFAULT, ANIMATE_PIXEL_AREA_AND_SCALE );
- mActorDog.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
- mActorDog.SetY( -100.f );
- stage.Add( mActorDog );
+ CreateAnimImageView( 0 );
}
else // button.GetParent() == mActorLogo
{
// remove the static gif view, the play button is also removed as its child.
- stage.Remove( mActorLogo );
-
- mActorLogo = CreateGifViewWithAnimatePixelAreaButton( ANIMATE_GIF_LOGO, WrapMode::DEFAULT, WrapMode::MIRRORED_REPEAT, ANIMATE_PIXEL_AREA );
- mActorLogo.SetAnchorPoint( AnchorPoint::TOP_CENTER );
- mActorLogo.SetY( 100.f );
- stage.Add( mActorLogo );
+ CreateAnimImageView( 1 );
}
return true;
}
}
else if( actor == mActorDog ) // stop the animated gif, switch to static view
{
- Stage stage = Stage::GetCurrent();
- stage.Remove( mActorDog );
-
- mActorDog = CreateGifViewWithOverlayPlayButton( STATIC_GIF_DOG );
- mActorDog.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
- mActorDog.SetY( -100.f );
- stage.Add( mActorDog );
+ CreateStaticImageView( 0 );
}
else if( actor == mActorLogo ) // stop the animated gif, switch to static view
{
- Stage stage = Stage::GetCurrent();
- stage.Remove( mActorLogo );
+ CreateStaticImageView( 1 );
+ }
+ }
- mActorLogo = CreateGifViewWithOverlayPlayButton( STATIC_GIF_LOGO );
- mActorLogo.SetAnchorPoint( AnchorPoint::TOP_CENTER );
- mActorLogo.SetY( 100.f );
- stage.Add( mActorLogo );
+ bool OnTypeButtonClicked( Toolkit::Button button )
+ {
+ if( button == mGifButton )
+ {
+ mImageType = GIF;
+ }
+ else
+ {
+ mImageType = IMAGE_ARRAY;
}
+ Stage stage = Stage::GetCurrent();
+ CreateStaticImageView( 0 );
+ CreateStaticImageView( 1 );
+ return true;
}
void OnKeyEvent(const KeyEvent& event)
}
}
+ Property::Value SetupViewProperties( ImageType type, StateType state, int index, bool wrap )
+ {
+ Property::Map map;
+
+ AddUrl( map, type, state, index );
+ AddWrap( map, wrap && state != 0, index );
+ AddCache( map, type, index );
+ return Property::Value(map);
+ }
+
+ void AddUrl( Property::Map& map, ImageType type, StateType state, int index )
+ {
+ const char* urls[2][2] =
+ { { STATIC_GIF_DOG, STATIC_GIF_LOGO },
+ { ANIMATE_GIF_DOG, ANIMATE_GIF_LOGO }
+ };
+ const char* urlFormats[2][2] =
+ { { STATIC_IMAGE_ARRAY_DOG, STATIC_IMAGE_ARRAY_LOGO } ,
+ { ANIMATE_IMAGE_ARRAY_DOG, ANIMATE_IMAGE_ARRAY_LOGO } };
+
+ int numFrames[2] = { 8, 15 };
+
+ if( type == GIF )
+ {
+ map.Add( Toolkit::ImageVisual::Property::URL, Property::Value( urls[state][index] ) );
+ }
+ else
+ {
+ if( state == STATIC )
+ {
+ Property::Array frameUrls;
+ frameUrls.Add(Property::Value( urlFormats[0][index] ));
+ map.Add( Toolkit::ImageVisual::Property::URL, frameUrls );
+ }
+ else
+ {
+ Property::Array frameUrls;
+ for( int i=1; i<= numFrames[index]; ++i )
+ {
+ char* buffer;
+ int len = asprintf( &buffer, urlFormats[1][index], i);
+ if( len > 0 )
+ {
+ std::string frameUrl(buffer);
+ free(buffer);
+ frameUrls.Add( Property::Value( frameUrl ) );
+ }
+ }
+ map.Add( Toolkit::ImageVisual::Property::URL, Property::Value( frameUrls ) );
+ }
+ }
+ }
+
+ void AddWrap( Property::Map& map, bool wrap, int index )
+ {
+ WrapMode::Type wrapModes[2][2] = {
+ { WrapMode::REPEAT, WrapMode::DEFAULT },
+ { WrapMode::DEFAULT, WrapMode::MIRRORED_REPEAT } };
+
+ if( wrap )
+ {
+ map
+ .Add( Toolkit::ImageVisual::Property::WRAP_MODE_U, wrapModes[index][0] )
+ .Add( Toolkit::ImageVisual::Property::WRAP_MODE_V, wrapModes[index][1] );
+ }
+ else
+ {
+ map
+ .Add( Toolkit::ImageVisual::Property::WRAP_MODE_U, WrapMode::DEFAULT )
+ .Add( Toolkit::ImageVisual::Property::WRAP_MODE_V, WrapMode::DEFAULT );
+ }
+ }
+
+ void AddCache( Property::Map& map, ImageType type, int index )
+ {
+ if( type == IMAGE_ARRAY )
+ {
+ map
+ .Add( Toolkit::DevelImageVisual::Property::BATCH_SIZE, 4 )
+ .Add( Toolkit::DevelImageVisual::Property::CACHE_SIZE, 10 )
+ .Add( Toolkit::DevelImageVisual::Property::FRAME_DELAY, 150 );
+ }
+ }
+
private:
Application& mApplication;
Toolkit::ImageView mActorDog;
Toolkit::ImageView mActorLogo;
+ Toolkit::RadioButton mGifButton;
+ Toolkit::RadioButton mArrayButton;
TapGestureDetector mTapDetector;
+ ImageType mImageType;
};
// Entry point for Linux & Tizen applications
*
*/
+#include <string>
#include "shared/view.h"
#include <dali/dali.h>
#include <dali-toolkit/dali-toolkit.h>
+#include <dali-toolkit/devel-api/controls/text-controls/text-label-devel.h>
using namespace Dali;
const char* APPLICATION_TITLE( "Image view" );
const char* IMAGE_PATH[] = {
- DEMO_IMAGE_DIR "blocks-ball.png",
DEMO_IMAGE_DIR "gallery-small-23.jpg",
- DEMO_IMAGE_DIR "selection-popup-bg.2.9.png",
+ DEMO_IMAGE_DIR "woodEffect.jpg",
DEMO_IMAGE_DIR "heartsframe.9.png",
+ DEMO_IMAGE_DIR "World.svg"
};
-const unsigned int NUM_IMAGES = sizeof(IMAGE_PATH) / sizeof(char*);
+const unsigned int NUMBER_OF_IMAGES = 3;
-const unsigned int COLUMNS = 3;
-const unsigned int ROWS = 4;
+enum CellPlacement
+{
+ TOP_BUTTON,
+ LOWER_BUTTON,
+ IMAGE,
+ NUMBER_OF_ROWS
+};
+
+
+unsigned int GetButtonIndex( Toolkit::Button button )
+{
+ std::string buttonName = button.GetName();
+ unsigned int index = 0;
+
+ if ( buttonName != "")
+ {
+ index = std::stoul( buttonName );
+ }
+
+ return index;
+}
+
+
+const unsigned int NUMBER_OF_RESOURCES = sizeof(IMAGE_PATH) / sizeof(char*);
+
+std::string EXAMPLE_INSTRUCTIONS = "Instructions: Change button cycles through different image visuals, "
+ "on/off takes the ImageView and it's current visual on or off stage.";
} // namespace
ImageViewController( Application& application )
: mApplication( application ),
mCurrentPositionToggle( 0, 0 ),
- mCurrentPositionImage( 0, 0 ),
- mToggleOff( true ),
- mImageIdx( 1 )
+ mCurrentPositionImage( 0, 0 )
{
// Connect to the Application's Init signal
mApplication.InitSignal().Connect( this, &ImageViewController::Create );
APPLICATION_TITLE );
- mTable = Toolkit::TableView::New( ROWS, COLUMNS );
+ // Create a table view to show a pair of buttons above each image.
+ mTable = Toolkit::TableView::New( CellPlacement::NUMBER_OF_ROWS, NUMBER_OF_IMAGES );
mTable.SetAnchorPoint( AnchorPoint::CENTER );
mTable.SetParentOrigin( ParentOrigin::CENTER );
- mTable.SetResizePolicy( ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT, Dimension::ALL_DIMENSIONS );
- Vector3 offset( -50.0f, -350.0f, 0.0f );
+ mTable.SetResizePolicy( ResizePolicy::SIZE_RELATIVE_TO_PARENT, Dimension::ALL_DIMENSIONS );
+ Vector3 offset( 0.9f, 0.70f, 0.0f );
mTable.SetSizeModeFactor( offset );
-
+ mTable.SetFitHeight(CellPlacement::TOP_BUTTON);
+ mTable.SetFitHeight(CellPlacement::LOWER_BUTTON);
mContentLayer.Add( mTable );
- for( unsigned int y = 0; y < ROWS; ++y )
- {
- for( unsigned int x = 0; x < COLUMNS; ++x )
- {
- mImageViews[x][y] = Toolkit::ImageView::New( IMAGE_PATH[ 0 ] );
- mImageViews[x][y].SetParentOrigin( ParentOrigin::CENTER );
- mImageViews[x][y].SetAnchorPoint( AnchorPoint::CENTER );
- mImageViews[x][y].SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
+ Toolkit::TextLabel instructions = Toolkit::TextLabel::New( EXAMPLE_INSTRUCTIONS );
+ instructions.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
+ instructions.SetParentOrigin(ParentOrigin::BOTTOM_CENTER);
+ instructions.SetY(-50.0f);
+ instructions.SetProperty( Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL, true );
+ instructions.SetProperty( Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT, 10 );
+ mContentLayer.Add(instructions);
- mTable.AddChild( mImageViews[x][y], Toolkit::TableView::CellPosition( y, x ) );
- }
+ for( unsigned int x = 0; x < NUMBER_OF_IMAGES; x++ )
+ {
+ Toolkit::PushButton button = Toolkit::PushButton::New();
+ button.SetProperty( Toolkit::Button::Property::LABEL, "on/off" );
+ button.SetParentOrigin( ParentOrigin::TOP_CENTER );
+ button.SetAnchorPoint( AnchorPoint::TOP_CENTER );
+ button.ClickedSignal().Connect( this, &ImageViewController::ToggleImageOnStage );
+ button.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
+ button.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
+ std::string s = std::to_string(x);
+ button.SetName( s );
+ mTable.AddChild( button, Toolkit::TableView::CellPosition( CellPlacement::TOP_BUTTON, x ) );
+
+ Toolkit::PushButton button2 = Toolkit::PushButton::New();
+ button2.SetProperty( Toolkit::Button::Property::LABEL, "Change" );
+ button2.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
+ button2.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
+ button2.ClickedSignal().Connect( this, &ImageViewController::ChangeImageClicked );
+ button2.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
+ button2.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::HEIGHT );
+ button2.SetName( s );
+ mTable.AddChild( button2, Toolkit::TableView::CellPosition( CellPlacement::LOWER_BUTTON, x ) );
+
+ mImageViews[x] = Toolkit::ImageView::New( IMAGE_PATH[ 0 ] );
+ mImageViews[x].SetParentOrigin( ParentOrigin::CENTER );
+ mImageViews[x].SetAnchorPoint( AnchorPoint::CENTER );
+ mImageViews[x].SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
+ mTable.AddChild( mImageViews[x], Toolkit::TableView::CellPosition( CellPlacement::IMAGE, x ) );
+
+ // Set changeable counter and toggle for each ImageView
+ mImageViewImageIndexStatus[x] = true;
+ mImageViewToggleStatus[x] = true;
}
- Toolkit::TableView buttonsTable = Toolkit::TableView::New( 3, 1 );
- buttonsTable.SetAnchorPoint( AnchorPoint::BOTTOM_CENTER );
- buttonsTable.SetParentOrigin( ParentOrigin::BOTTOM_CENTER );
- buttonsTable.SetFitHeight( 0 );
- buttonsTable.SetFitHeight( 1 );
- buttonsTable.SetFitHeight( 2 );
- buttonsTable.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
-
- Toolkit::PushButton button = Toolkit::PushButton::New();
- button.SetProperty( Toolkit::Button::Property::LABEL, "Toggle on/off stage" );
- button.SetParentOrigin( ParentOrigin::CENTER );
- button.SetAnchorPoint( AnchorPoint::CENTER );
- button.ClickedSignal().Connect( this, &ImageViewController::ToggleImageOnStage );
- button.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
- buttonsTable.AddChild( button, Toolkit::TableView::CellPosition( 0, 0 ) );
-
- Toolkit::PushButton button2 = Toolkit::PushButton::New();
- button2.SetProperty( Toolkit::Button::Property::LABEL, "Change Image" );
- button2.SetParentOrigin( ParentOrigin::CENTER );
- button2.SetAnchorPoint( AnchorPoint::CENTER );
- button2.ClickedSignal().Connect( this, &ImageViewController::ChangeImageClicked );
- button2.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::WIDTH );
- buttonsTable.AddChild( button2, Toolkit::TableView::CellPosition( 1, 0 ) );
-
- mContentLayer.Add(buttonsTable);
-
Stage::GetCurrent().KeyEventSignal().Connect(this, &ImageViewController::OnKeyEvent);
}
private:
+
bool ToggleImageOnStage( Toolkit::Button button )
{
- Toolkit::ImageView imageView = mImageViews[ mCurrentPositionToggle.columnIndex ][ mCurrentPositionToggle.rowIndex ];
+ unsigned int buttonIndex = GetButtonIndex( button );
- if( mToggleOff )
+ Toolkit::ImageView imageView = mImageViews[ buttonIndex ];
+
+ if( mImageViewToggleStatus[ buttonIndex ] )
{
imageView.Unparent();
}
else
{
- mTable.AddChild( imageView, mCurrentPositionToggle );
+ mTable.AddChild( imageView, Toolkit::TableView::CellPosition( 2, GetButtonIndex( button ) ) );
}
- ++mCurrentPositionToggle.columnIndex;
- if( mCurrentPositionToggle.columnIndex == COLUMNS )
- {
- mCurrentPositionToggle.columnIndex = 0;
- ++mCurrentPositionToggle.rowIndex;
- }
- if( mCurrentPositionToggle.rowIndex == ROWS )
- {
- mCurrentPositionToggle.rowIndex = 0;
- mToggleOff = !mToggleOff;
- }
+ mImageViewToggleStatus[ buttonIndex ] = !mImageViewToggleStatus[ buttonIndex ];
return true;
}
bool ChangeImageClicked( Toolkit::Button button )
{
- Toolkit::ImageView imageView = mImageViews[ mCurrentPositionImage.columnIndex ][ mCurrentPositionImage.rowIndex ];
-
- imageView.SetImage( IMAGE_PATH[ mImageIdx ] );
+ unsigned int buttonIndex = GetButtonIndex( button );
- ++mCurrentPositionImage.columnIndex;
- if( mCurrentPositionImage.columnIndex == COLUMNS )
- {
- mCurrentPositionImage.columnIndex = 0;
- ++mCurrentPositionImage.rowIndex;
- }
- if( mCurrentPositionImage.rowIndex == ROWS )
+ if ( mImageViews[buttonIndex].OnStage() )
{
- mCurrentPositionImage.rowIndex = 0;
- ++mImageIdx;
+ mImageViews[buttonIndex].SetImage( IMAGE_PATH[ mImageViewImageIndexStatus[buttonIndex] ] );
- if( mImageIdx == NUM_IMAGES )
+ ++mImageViewImageIndexStatus[buttonIndex];
+
+ if( mImageViewImageIndexStatus[buttonIndex] == NUMBER_OF_RESOURCES )
{
- mImageIdx = 0;
+ mImageViewImageIndexStatus[buttonIndex] = 0;
}
}
-
return true;
}
Toolkit::ToolBar mToolBar; ///< The View's Toolbar.
Layer mContentLayer; ///< Content layer
Toolkit::TableView mTable;
- Toolkit::ImageView mImageViews[ COLUMNS ][ ROWS ];
+ Toolkit::ImageView mImageViews[ NUMBER_OF_IMAGES ];
+ bool mImageViewToggleStatus[ NUMBER_OF_IMAGES ];
+ unsigned int mImageViewImageIndexStatus[ NUMBER_OF_IMAGES ];
Toolkit::TableView::CellPosition mCurrentPositionToggle;
Toolkit::TableView::CellPosition mCurrentPositionImage;
- bool mToggleOff;
- int mImageIdx;
-
};
void RunTest( Application& application )
// EXTERNAL INCLUDES
#include <dali/integration-api/debug.h>
-#include <string>
#include <sstream>
#include <string.h>
ObjLoader::ObjLoader()
: mSceneLoaded( false ),
mMaterialLoaded( false ),
- mHasTexturePoints( false ),
+ mHasTextureUv( false ),
mHasDiffuseMap( false ),
mHasNormalMap( false ),
mHasSpecularMap( false )
return mMaterialLoaded;
}
-void ObjLoader::CalculateHardFaceNormals( const Dali::Vector<Vector3>& vertices, Dali::Vector<TriIndex>& triangles,
+void ObjLoader::CalculateHardFaceNormals( const Dali::Vector<Vector3>& points, Dali::Vector<TriIndex>& triangles,
Dali::Vector<Vector3>& normals )
{
- int numFaceVertices = 3 * triangles.Size(); //Vertex per face, as each point has different normals for each face.
+ int numFaceVertices = 3 * triangles.Size(); //Vertices per face, as each vertex has different normals instance for each face.
int normalIndex = 0; //Tracks progress through the array of normals.
normals.Clear();
for( unsigned long i = 0; i < triangles.Size(); i++ )
{
//Triangle vertices.
- const Vector3& v0 = vertices[triangles[i].pointIndex[0]];
- const Vector3& v1 = vertices[triangles[i].pointIndex[1]];
- const Vector3& v2 = vertices[triangles[i].pointIndex[2]];
+ const Vector3& v0 = points[triangles[i].pointIndex[0]];
+ const Vector3& v1 = points[triangles[i].pointIndex[1]];
+ const Vector3& v2 = points[triangles[i].pointIndex[2]];
//Triangle edges.
Vector3 edge1 = v1 - v0;
Vector3 edge2 = v2 - v0;
- //Using edges as vectors on the plane, cross to get the normal.
+ //Using edges as vectors on the plane, cross product to get the normal.
Vector3 normalVector = edge1.Cross(edge2);
normalVector.Normalize();
- //Assign normals to points.
+ //Assign normal index to triangle vertex and set the normal vector to the list of normals.
for( unsigned long j = 0; j < 3; j++, normalIndex++ )
{
triangles[i].normalIndex[j] = normalIndex;
}
}
-void ObjLoader::CalculateSoftFaceNormals( const Dali::Vector<Vector3>& vertices, Dali::Vector<TriIndex>& triangles,
+void ObjLoader::CalculateSoftFaceNormals( const Dali::Vector<Vector3>& points, Dali::Vector<TriIndex>& triangles,
Dali::Vector<Vector3>& normals )
{
int normalIndex = 0; //Tracks progress through the array of normals.
normals.Clear();
- normals.Resize( vertices.Size() ); //One (averaged) normal per point.
+ normals.Resize( points.Size() ); //One (averaged) normal per point.
//For each triangle, calculate the normal by crossing two vectors on the triangle's plane
//We then add the triangle's normal to the cumulative normals at each point of it
for( unsigned long i = 0; i < triangles.Size(); i++ )
{
- //Triangle vertices.
- const Vector3& v0 = vertices[triangles[i].pointIndex[0]];
- const Vector3& v1 = vertices[triangles[i].pointIndex[1]];
- const Vector3& v2 = vertices[triangles[i].pointIndex[2]];
+ //Triangle points.
+ const Vector3& v0 = points[triangles[i].pointIndex[0]];
+ const Vector3& v1 = points[triangles[i].pointIndex[1]];
+ const Vector3& v2 = points[triangles[i].pointIndex[2]];
//Triangle edges.
Vector3 edge1 = v1 - v0;
//Using edges as vectors on the plane, cross to get the normal.
Vector3 normalVector = edge1.Cross(edge2);
- //Add this triangle's normal to the cumulative normal of each constituent point and set the index of the normal accordingly.
- for( unsigned long j = 0; j < 3; j++, normalIndex++ )
+ //Add this triangle's normal to the cumulative normal of each constituent triangle point and set the index of the normal accordingly.
+ for( unsigned long j = 0; j < 3; j++)
{
- triangles[i].normalIndex[j] = triangles[i].pointIndex[j]; //Normal index matches up to vertex index, as one normal per vertex.
- normals[triangles[i].normalIndex[j]] += normalVector;
+ normalIndex = triangles[i].pointIndex[j];
+ triangles[i].normalIndex[j] = normalIndex; //Normal index matches up to vertex index, as one normal per vertex.
+ normals[normalIndex] += normalVector;
}
}
{
//Reset tangent vector to hold new values.
mTangents.Clear();
- mTangents.Resize( mPoints.Size() );
+ mTangents.Resize( mNormals.Size() );
- //For each triangle, calculate the tangent vector and then add it to the total tangent vector of each point.
+ //For each triangle, calculate the tangent vector and then add it to the total tangent vector of each normal.
for ( unsigned long a = 0; a < mTriangles.Size(); a++ )
{
Vector3 tangentVector;
Vector3 edge1 = v1 - v0;
Vector3 edge2 = v2 - v0;
- const Vector2& w0 = mTextures[mTriangles[a].textureIndex[0]];
- const Vector2& w1 = mTextures[mTriangles[a].textureIndex[1]];
- const Vector2& w2 = mTextures[mTriangles[a].textureIndex[2]];
+ const Vector2& w0 = mTextureUv[mTriangles[a].textureIndex[0]];
+ const Vector2& w1 = mTextureUv[mTriangles[a].textureIndex[1]];
+ const Vector2& w2 = mTextureUv[mTriangles[a].textureIndex[2]];
float deltaU1 = w1.x - w0.x;
float deltaV1 = w1.y - w0.y;
float deltaU2 = w2.x - w0.x;
float deltaV2 = w2.y - w0.y;
- float f = 1.0f / (deltaU1 * deltaV2 - deltaU2 * deltaV1);
+ // 1.0/f could cause division by zero in some cases, this factor will act
+ // as a weight of the tangent vector and it is fixed when it is normalised.
+ float f = (deltaU1 * deltaV2 - deltaU2 * deltaV1);
tangentVector.x = f * ( deltaV2 * edge1.x - deltaV1 * edge2.x );
tangentVector.y = f * ( deltaV2 * edge1.y - deltaV1 * edge2.y );
tangentVector.z = f * ( deltaV2 * edge1.z - deltaV1 * edge2.z );
- mTangents[mTriangles[a].pointIndex[0]] += tangentVector;
- mTangents[mTriangles[a].pointIndex[1]] += tangentVector;
- mTangents[mTriangles[a].pointIndex[2]] += tangentVector;
+ mTangents[mTriangles[a].normalIndex[0]] += tangentVector;
+ mTangents[mTriangles[a].normalIndex[1]] += tangentVector;
+ mTangents[mTriangles[a].normalIndex[2]] += tangentVector;
}
- //Orthogonalize tangents and set binormals.
+ //Orthogonalize tangents.
for ( unsigned long a = 0; a < mTangents.Size(); a++ )
{
const Vector3& n = mNormals[a];
bool mustCalculateTangents = ( mTangents.Size() == 0 ) || ( mTangents.Size() != mNormals.Size() );
//However, we don't need to do this if the object doesn't use textures to begin with.
- mustCalculateTangents &= mHasTexturePoints;
+ mustCalculateTangents &= mHasTextureUv;
- //We also have to recalculate the normals if we need to calculate tangents,
- // as we need just one normal, tangent per vertex, rather than the supplied per-face vertices.
- //Alternatively, we need to calculate the normals if there weren't any to begin with.
- if( mNormals.Size() == 0 || mustCalculateTangents )
+ // We calculate the normals if hard normals(flat normals) is set.
+ // Use the normals provided by the file to make the tangent calculation per normal,
+ // the correct results depends of normal generated by file, otherwise we need to recalculate
+ // the normal programmatically.
+ if( ( ( mNormals.Size() == 0 ) && mustCalculateTangents ) || !useSoftNormals )
{
- if( useSoftNormals || mustCalculateTangents )
+ if( useSoftNormals )
{
CalculateSoftFaceNormals( mPoints, mTriangles, mNormals );
}
}
}
- if( mHasTexturePoints && mustCalculateTangents )
+ if( mHasTextureUv && mustCalculateTangents )
{
CalculateTangentFrame();
}
- bool mapsCorrespond; //True if the sizes of the arrays necessary for the object agree.
+ bool mapsCorrespond; //True if the sizes of the arrays necessary to draw the object match.
- if ( mHasTexturePoints )
+ if ( mHasTextureUv )
{
- mapsCorrespond = ( mPoints.Size() == mTextures.Size() ) && ( mTextures.Size() == mNormals.Size() );
+ mapsCorrespond = ( mPoints.Size() == mTextureUv.Size() ) && ( mTextureUv.Size() == mNormals.Size() );
}
else
{
normals[mTriangles[ui].pointIndex[j]] = mNormals[mTriangles[ui].normalIndex[j]];
- if ( mHasTexturePoints )
+ if ( mHasTextureUv )
{
- textures[mTriangles[ui].pointIndex[j]] = mTextures[mTriangles[ui].textureIndex[j]];
+ textures[mTriangles[ui].pointIndex[j]] = mTextureUv[mTriangles[ui].textureIndex[j]];
tangents[mTriangles[ui].pointIndex[j]] = mTangents[mTriangles[ui].normalIndex[j]];
}
}
positions[index] = mPoints[mTriangles[ui].pointIndex[j]];
normals[index] = mNormals[mTriangles[ui].normalIndex[j]];
- if( mHasTexturePoints )
+ if( mHasTextureUv )
{
- textures[index] = mTextures[mTriangles[ui].textureIndex[j]];
+ textures[index] = mTextureUv[mTriangles[ui].textureIndex[j]];
tangents[index] = mTangents[mTriangles[ui].normalIndex[j]];
}
std::string strMatActual;
- std::string input = objBuffer;
+ std::string input( objBuffer, fileSize );
std::istringstream ss(input);
ss.imbue( std::locale( "C" ) );
{
isline >> texture.x;
isline >> texture.y;
-
texture.y = 1.0-texture.y;
- mTextures.PushBack( texture );
+ mTextureUv.PushBack( texture );
}
else if ( tag == "#_#vt1" )
{
isline >> texture.y;
texture.y = 1.0-texture.y;
- mTextures2.PushBack( texture );
+ mTextureUv2.PushBack( texture );
}
else if ( tag == "s" )
{
}
int numIndices = 0;
- while( isline >> vet[numIndices] && numIndices < MAX_POINT_INDICES )
+ while( ( numIndices < MAX_POINT_INDICES ) && ( isline >> vet[numIndices] ) )
{
numIndices++;
}
{
CenterAndScale( true, mPoints );
mSceneLoaded = true;
- mHasTexturePoints = hasTexture;
+ mHasTextureUv = hasTexture;
return true;
}
surface.AddVertexBuffer( normalBuffer );
//Some need tangent
- if( ( objectProperties & TANGENTS ) && mHasTexturePoints )
+ if( ( objectProperties & TANGENTS ) && mHasTextureUv )
{
Property::Map tangentMap;
tangentMap["aTangent"] = Property::VECTOR3;
}
//Some need texture coordinates
- if( ( objectProperties & TEXTURE_COORDINATES ) && mHasTexturePoints )
+ if( ( objectProperties & TEXTURE_COORDINATES ) && mHasTextureUv )
{
Property::Map textCoordMap;
textCoordMap["aTexCoord"] = Property::VECTOR2;
void ObjLoader::ClearArrays()
{
mPoints.Clear();
- mTextures.Clear();
- mTextures2.Clear();
+ mTextureUv.Clear();
+ mTextureUv2.Clear();
mNormals.Clear();
mTangents.Clear();
mBiTangents.Clear();
bool ObjLoader::IsTexturePresent()
{
- return mHasTexturePoints;
+ return mHasTextureUv;
}
bool ObjLoader::IsDiffuseMapPresent()
private:
Dali::Vector<Vector3> mPoints;
- Dali::Vector<Vector2> mTextures;
- Dali::Vector<Vector2> mTextures2;
+ Dali::Vector<Vector2> mTextureUv;
+ Dali::Vector<Vector2> mTextureUv2;
Dali::Vector<Vector3> mNormals;
Dali::Vector<Vector3> mTangents;
Dali::Vector<Vector3> mBiTangents;
bool mSceneLoaded;
bool mMaterialLoaded;
- bool mHasTexturePoints;
+ bool mHasTextureUv;
//Material file properties.
bool mHasDiffuseMap;
Name: com.samsung.dali-demo
Summary: The OpenGLES Canvas Core Demo
-Version: 1.2.46
+Version: 1.2.49
Release: 1
Group: System/Libraries
License: Apache-2.0
projects / platform / core / uifw / dali-demo.git / commitdiff
