Ejemplo n.º 1
0
static void DoApply( ImageActor actor, const std::string& maskImage, const Vector2& maskSize, Vector4 maskBorder )
{
  const char* ALPHA_MASK_VERTEX_SHADER_SOURCE =
  "uniform vec2 uImageSize;                                                       \n"
  "uniform vec2 uMaskSize;                                                        \n"
  "varying vec2 vMaskTexCoord;                                                    \n"
  "                                                                               \n"
  "void main()                                                                    \n"
  "{                                                                              \n"
  "  gl_Position = uMvpMatrix * vec4(aPosition, 1.0);                             \n"
  "                                                                               \n"
  "  // Ignore mask UVs for image                                                 \n"
  "                                                                               \n"
  "  highp vec2 halfImageSize = uImageSize * 0.5;                                 \n"
  "  vTexCoord = (aPosition.xy + halfImageSize) / uImageSize;                     \n"
  "                                                                               \n"
  "  // UVs were calculated for image size, so convert for mask size              \n"
  "                                                                               \n"
  "  highp vec2 halfMaskSize  = uMaskSize * 0.5;                                  \n"
  "  highp vec2 halfSizeDelta = halfImageSize - halfMaskSize;                     \n"
  "                                                                               \n"
  "  highp vec2 maskPosition = aPosition.xy;                                      \n"
  "  maskPosition.x -= halfSizeDelta.x * sign(aPosition.x);                       \n"
  "  maskPosition.y -= halfSizeDelta.y * sign(aPosition.y);                       \n"
  "                                                                               \n"
  "  vMaskTexCoord = (maskPosition + halfMaskSize) / uMaskSize;                   \n"
  "}                                                                              \n";

  const char* ALPHA_MASK_FRAGMENT_SHADER_SOURCE =
  "varying vec2 vMaskTexCoord;                                                    \n"
  "                                                                               \n"
  "void main()                                                                    \n"
  "{                                                                              \n"
  "  highp vec4 mask = texture2D(sEffect, vMaskTexCoord);                         \n"
  "  gl_FragColor = texture2D(sTexture, vTexCoord) * uColor * vec4(1,1,1,mask.a); \n"
  "}                                                                              \n";

  ShaderEffect maskEffect = ShaderEffect::New( ALPHA_MASK_VERTEX_SHADER_SOURCE,
                                               ALPHA_MASK_FRAGMENT_SHADER_SOURCE,
                                               GeometryType( GEOMETRY_TYPE_IMAGE ),
                                               ShaderEffect::GeometryHints( ShaderEffect::HINT_BLENDING ) );

  maskEffect.SetEffectImage( Image::New( maskImage ) );

  maskEffect.SetUniform( "uImageSize", Vector2(0,0) /*Constrained to actor size*/ );
  maskEffect.ApplyConstraint( Constraint::New<Vector2>( maskEffect.GetPropertyIndex("uImageSize"),
                                                        Source(actor, Actor::SIZE),
                                                        NinePatchMaskEffectSizeConstraint() ) );

  maskEffect.SetUniform( "uMaskSize", maskSize );

  // Actor must provide nine-patch style geometry for this effect to work
  actor.SetStyle( ImageActor::STYLE_NINE_PATCH );
  actor.SetNinePatchBorder( maskBorder );

  actor.SetShaderEffect( maskEffect );
}
Ejemplo n.º 2
0
void KeyboardFocusManager::CreateDefaultFocusIndicatorActor()
{
  // Create a focus indicator actor shared by all the keyboard focusable actors
  Image borderImage = ResourceImage::New(FOCUS_BORDER_IMAGE_PATH);

  ImageActor focusIndicator = ImageActor::New(borderImage);
  focusIndicator.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
  focusIndicator.SetStyle( ImageActor::STYLE_NINE_PATCH );
  focusIndicator.SetNinePatchBorder(FOCUS_BORDER_IMAGE_BORDER);
  focusIndicator.SetPosition(Vector3(0.0f, 0.0f, 1.0f));

  // Apply size constraint to the focus indicator
  focusIndicator.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );

  SetFocusIndicatorActor(focusIndicator);
}
Ejemplo n.º 3
0
int UtcDaliImageSetNinePatchBorder(void)
{
  TestApplication application;

  Image image = Image::New(TestImageFilename);
  ImageActor actor = ImageActor::New(image);

  actor.SetStyle(ImageActor::STYLE_NINE_PATCH);
  actor.SetNinePatchBorder(Vector4( 1.0f, 2.0f, 3.0f, 4.0f));

  DALI_TEST_EQUALS( 1.0f, actor.GetNinePatchBorder().x, TEST_LOCATION );
  DALI_TEST_EQUALS( 2.0f, actor.GetNinePatchBorder().y, TEST_LOCATION );
  DALI_TEST_EQUALS( 3.0f, actor.GetNinePatchBorder().z, TEST_LOCATION );
  DALI_TEST_EQUALS( 4.0f, actor.GetNinePatchBorder().w, TEST_LOCATION );
  END_TEST;
}
Ejemplo n.º 4
0
int UtcDaliImageActor9Patch(void)
{
  TestApplication application;
  tet_infoline("Positive test for Dali::ImageActor:: 9 patch api");

  Image image = Image::New(TestImageFilename);
  ImageActor actor = ImageActor::New(image);

  actor.SetStyle(ImageActor::STYLE_NINE_PATCH);
  Vector4 border(0.1,0.2,0.3,0.4);
  actor.SetNinePatchBorder(border);

  DALI_TEST_EQUALS( 0.1f, actor.GetNinePatchBorder().x, TEST_LOCATION );
  DALI_TEST_EQUALS( 0.2f, actor.GetNinePatchBorder().y, TEST_LOCATION );
  DALI_TEST_EQUALS( 0.3f, actor.GetNinePatchBorder().z, TEST_LOCATION );
  DALI_TEST_EQUALS( 0.4f, actor.GetNinePatchBorder().w, TEST_LOCATION );
  END_TEST;
}
Ejemplo n.º 5
0
void Magnifier::SetFrameVisibility(bool visible)
{
  if(visible && !mFrameLayer)
  {
    Actor self(Self());

    Layer mFrameLayer = Layer::New();
    mFrameLayer.SetParentOrigin( ParentOrigin::CENTER );
    Stage::GetCurrent().Add(mFrameLayer);

    Image image = Image::New( DEFAULT_FRAME_IMAGE_PATH );
    ImageActor frame = ImageActor::New( image );
    frame.SetDrawMode(DrawMode::OVERLAY);
    frame.SetStyle( ImageActor::STYLE_NINE_PATCH );

    frame.SetNinePatchBorder( Vector4::ONE * IMAGE_BORDER_INDENT );
    mFrameLayer.Add(frame);

    // Apply position constraint to the frame
    Constraint constraint = Constraint::New<Vector3>( Actor::POSITION,
                                                      Source( self, Actor::WORLD_POSITION ),
                                                      EqualToConstraint() );
    frame.ApplyConstraint(constraint);

    // Apply scale constraint to the frame
    constraint = Constraint::New<Vector3>( Actor::SCALE,
                                           Source( self, Actor::SCALE ),
                                           EqualToConstraint() );
    frame.ApplyConstraint(constraint);

    Source(self, Actor::SCALE),

    // Apply size constraint to the the frame
    constraint = Constraint::New<Vector3>(Actor::SIZE,
                                          Source(self, Actor::SIZE),
                                          ImageBorderSizeConstraint());
    frame.ApplyConstraint(constraint);
  }
  else if(!visible && mFrameLayer)
  {
    Stage::GetCurrent().Remove(mFrameLayer);
    mFrameLayer.Reset();
  }
}
Ejemplo n.º 6
0
ImageActor CreateSolidColorActor( const Vector4& color, bool border, const Vector4& borderColor, const unsigned int borderSize )
{
  ImageActor image;
  if( borderSize > MAX_BORDER_SIZE )
  {
    return image;
  }

  const unsigned int bitmapWidth = borderSize * 2 + 2;
  bool needAlphaChannel = (color.a < 1.0f) || ( border && borderColor.a < 1.0f );
  BufferImage imageData;
  if( needAlphaChannel )
  {
    imageData = BufferImage::New( bitmapWidth, bitmapWidth, Pixel::RGBA8888 );
  }
  else
  {
    imageData = BufferImage::New( bitmapWidth, bitmapWidth, Pixel::RGB888 );
  }

  // Create the image
  PixelBuffer* pixbuf = imageData.GetBuffer();
  if( !pixbuf )
  {
    return image;
  }

  Vector4 outerColor = color;
  if ( border )
  {
    outerColor = borderColor;
  }

  // Using a (2 + border) x (2 + border) image gives a better blend with the GL implementation
  // than a (1 + border) x (1 + border) image
  const unsigned int bitmapSize = bitmapWidth * bitmapWidth;
  const unsigned int topLeft = bitmapWidth * borderSize + borderSize;
  const unsigned int topRight = topLeft + 1;
  const unsigned int bottomLeft = bitmapWidth * (borderSize + 1) + borderSize;
  const unsigned int bottomRight = bottomLeft + 1;

  if( needAlphaChannel )
  {
    for( size_t i = 0; i < bitmapSize; ++i )
    {
      if( i == topLeft ||
          i == topRight ||
          i == bottomLeft ||
          i == bottomRight )
      {
        pixbuf[i*4+0] = 0xFF * color.r;
        pixbuf[i*4+1] = 0xFF * color.g;
        pixbuf[i*4+2] = 0xFF * color.b;
        pixbuf[i*4+3] = 0xFF * color.a;
      }
      else
      {
        pixbuf[i*4+0] = 0xFF * outerColor.r;
        pixbuf[i*4+1] = 0xFF * outerColor.g;
        pixbuf[i*4+2] = 0xFF * outerColor.b;
        pixbuf[i*4+3] = 0xFF * outerColor.a;
      }
    }
  }
  else
  {
    for( size_t i = 0; i < bitmapSize; ++i )
    {
      if( i == topLeft ||
          i == topRight ||
          i == bottomLeft ||
          i == bottomRight )
      {
        pixbuf[i*3+0] = 0xFF * color.r;
        pixbuf[i*3+1] = 0xFF * color.g;
        pixbuf[i*3+2] = 0xFF * color.b;
      }
      else
      {
        pixbuf[i*3+0] = 0xFF * outerColor.r;
        pixbuf[i*3+1] = 0xFF * outerColor.g;
        pixbuf[i*3+2] = 0xFF * outerColor.b;
      }
    }
  }

  imageData.Update();
  image = ImageActor::New( imageData );
  image.SetParentOrigin( ParentOrigin::CENTER );

  if( border )
  {
    image.SetStyle( ImageActor::STYLE_NINE_PATCH );
    image.SetNinePatchBorder( Vector4::ONE * (float)borderSize * 2.0f );
  }

  return image;
}