Пример #1
0
bool BitmapTexture::CreateGlTexture()
{
  DALI_LOG_TRACE_METHOD(Debug::Filter::gImage);
  DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Bitmap: %s\n", DALI_LOG_GET_OBJECT_C_STR(this));

  if( mBitmap )
  {
    const unsigned char* pixels = mBitmap->GetBuffer();

    DALI_ASSERT_DEBUG(pixels != NULL);

    if( NULL != pixels )
    {
      AssignBitmap( true, pixels );
      mBitmap->DiscardBuffer();
    }
  }
  else
  {
    const unsigned char* pixels = NULL;
    std::vector<unsigned char> pixelData;
    if( ( NULL == pixels ) && ( true == mClearPixels ) )
    {
      unsigned int size = mWidth * mHeight * Pixel::GetBytesPerPixel(mPixelFormat);
      pixelData.resize(size, 0);
      pixels = &pixelData[0];
    }
    AssignBitmap( true, pixels );
  }

  return mId != 0;
}
bool ImageAttachment::DoPrepareResources( BufferIndex updateBufferIndex, ResourceManager& resourceManager )
{
  DALI_LOG_TRACE_METHOD_FMT(gImageAttachmentLogFilter, "this:%p", this);
  bool ready = false;

  if( 0 != mTextureId )
  {
    // The metadata is used by IsFullyOpaque(), below.
    mBitmapMetadata = resourceManager.GetBitmapMetadata( mTextureId );

    CompleteStatusManager& completeStatusManager = mSceneController->GetCompleteStatusManager();
    CompleteStatusManager::CompleteState status = completeStatusManager.GetStatus( mTextureId );

    switch( status )
    {
      case CompleteStatusManager::NOT_READY:
      {
        ready = false;

        if( mBitmapMetadata.GetIsFramebuffer() )
        {
          ready = true;
        }
        mFinishedResourceAcquisition = false;
        FollowTracker( mTextureId );
      }
      break;

      case CompleteStatusManager::COMPLETE:
      {
        ready = true;
        mFinishedResourceAcquisition = true;
      }
      break;

      case CompleteStatusManager::NEVER:
      {
        ready = false;
        mFinishedResourceAcquisition = true;
      }
      break;
    }
  }
  else
  {
    // Loading is essentially finished if we don't have a resource ID
    mFinishedResourceAcquisition = true;
  }

  ATTACHMENT_LOG_FMT(Debug::General, " ObjName:%s finished:%s ready:%s \n",
                     DALI_LOG_GET_OBJECT_C_STR(mParent),
                     mFinishedResourceAcquisition?"T":"F", ready?"T":"F");

  return ready;
}
void ImageAttachment::DoPrepareRender( BufferIndex updateBufferIndex )
{
  DALI_ASSERT_DEBUG( mSceneController && mImageRenderer );

  ATTACHMENT_LOG_FMT(Debug::General, "ObjName:%s textureId:%d\n",
                     DALI_LOG_GET_OBJECT_C_STR(mParent),
                     mTextureId);

  // Check whether we need to refresh the vertex buffer.
  if ( mRefreshMeshData )
  {
    const Vector3& actorSize = GetParent().GetSize( updateBufferIndex );
    mGeometrySize.x = actorSize.x;
    mGeometrySize.y = actorSize.y;

    Render::ImageRenderer::MeshType meshType = Render::ImageRenderer::GRID_QUAD;

    if ( !PreviousHintEnabled( Dali::ShaderEffect::HINT_GRID ) )
    {
      if ( mStyle == Dali::ImageActor::STYLE_NINE_PATCH )
      {
        meshType = Render::ImageRenderer::NINE_PATCH;
      }
      else if ( mStyle == Dali::ImageActor::STYLE_NINE_PATCH_NO_CENTER )
      {
        meshType = Render::ImageRenderer::NINE_PATCH_NO_CENTER;
      }
      else
      {
        meshType = Render::ImageRenderer::QUAD;
      }
    }
    else
    {
      if ( mStyle == Dali::ImageActor::STYLE_NINE_PATCH )
      {
        meshType = Render::ImageRenderer::GRID_NINE_PATCH;
      }
      else if ( mStyle == Dali::ImageActor::STYLE_NINE_PATCH_NO_CENTER )
      {
        meshType = Render::ImageRenderer::GRID_NINE_PATCH_NO_CENTER;
      }
      else
      {
        meshType = Render::ImageRenderer::GRID_QUAD;
      }
    }

    // Recalculate the mesh data in the next render
    {
      typedef MessageValue3< Render::ImageRenderer, Render::ImageRenderer::MeshType, Vector2, bool > DerivedType;

      // Reserve some memory inside the render queue
      unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );

      // Construct message in the render queue memory; note that delete should not be called on the return value
      new (slot) DerivedType( mImageRenderer, &Render::ImageRenderer::CalculateMeshData, meshType, mGeometrySize, mIsPixelAreaSet );
    }

    mRefreshMeshData = false;
  }
}