constexpr uint32_t TEXTURE_COUNT_FOR_GPU_ALPHA_MASK = 2u;
+struct NameIndexMatch
+{
+ const char* const name;
+ Property::Index index;
+};
+
+const NameIndexMatch NAME_INDEX_MATCH_TABLE[] =
+ {
+ {IMAGE_FITTING_MODE, Toolkit::ImageVisual::Property::FITTING_MODE},
+ {IMAGE_SAMPLING_MODE, Toolkit::ImageVisual::Property::SAMPLING_MODE},
+ {IMAGE_DESIRED_WIDTH, Toolkit::ImageVisual::Property::DESIRED_WIDTH},
+ {IMAGE_DESIRED_HEIGHT, Toolkit::ImageVisual::Property::DESIRED_HEIGHT},
+ {PIXEL_AREA_UNIFORM_NAME, Toolkit::ImageVisual::Property::PIXEL_AREA},
+ {IMAGE_WRAP_MODE_U, Toolkit::ImageVisual::Property::WRAP_MODE_U},
+ {IMAGE_WRAP_MODE_V, Toolkit::ImageVisual::Property::WRAP_MODE_V},
+ {SYNCHRONOUS_LOADING, Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING},
+ {IMAGE_ATLASING, Toolkit::ImageVisual::Property::ATLASING},
+ {ALPHA_MASK_URL, Toolkit::ImageVisual::Property::ALPHA_MASK_URL},
+ {MASK_CONTENT_SCALE_NAME, Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE},
+ {CROP_TO_MASK_NAME, Toolkit::ImageVisual::Property::CROP_TO_MASK},
+ {MASKING_TYPE_NAME, Toolkit::DevelImageVisual::Property::MASKING_TYPE},
+ {ENABLE_BROKEN_IMAGE, Toolkit::DevelImageVisual::Property::ENABLE_BROKEN_IMAGE},
+ {LOAD_POLICY_NAME, Toolkit::ImageVisual::Property::LOAD_POLICY},
+ {RELEASE_POLICY_NAME, Toolkit::ImageVisual::Property::RELEASE_POLICY},
+ {ORIENTATION_CORRECTION_NAME, Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION},
+ {FAST_TRACK_UPLOADING_NAME, Toolkit::DevelImageVisual::Property::FAST_TRACK_UPLOADING},
+};
+const int NAME_INDEX_MATCH_TABLE_SIZE = sizeof(NAME_INDEX_MATCH_TABLE) / sizeof(NAME_INDEX_MATCH_TABLE[0]);
+
Geometry CreateGeometry(VisualFactoryCache& factoryCache, ImageDimensions gridSize)
{
Geometry geometry;
Dali::SamplingMode::Type samplingMode)
: Visual::Base(factoryCache, Visual::FittingMode::FILL, Toolkit::Visual::IMAGE),
mPixelArea(FULL_TEXTURE_RECT),
+ mPixelAreaIndex(Property::INVALID_INDEX),
mPlacementActor(),
mImageUrl(imageUrl),
mMaskingData(),
}
else
{
- if(keyValue.first == IMAGE_FITTING_MODE)
- {
- DoSetProperty(Toolkit::ImageVisual::Property::FITTING_MODE, keyValue.second);
- }
- else if(keyValue.first == IMAGE_SAMPLING_MODE)
+ for(int i = 0; i < NAME_INDEX_MATCH_TABLE_SIZE; ++i)
{
- DoSetProperty(Toolkit::ImageVisual::Property::SAMPLING_MODE, keyValue.second);
- }
- else if(keyValue.first == IMAGE_DESIRED_WIDTH)
- {
- DoSetProperty(Toolkit::ImageVisual::Property::DESIRED_WIDTH, keyValue.second);
- }
- else if(keyValue.first == IMAGE_DESIRED_HEIGHT)
- {
- DoSetProperty(Toolkit::ImageVisual::Property::DESIRED_HEIGHT, keyValue.second);
- }
- else if(keyValue.first == PIXEL_AREA_UNIFORM_NAME)
- {
- DoSetProperty(Toolkit::ImageVisual::Property::PIXEL_AREA, keyValue.second);
- }
- else if(keyValue.first == IMAGE_WRAP_MODE_U)
- {
- DoSetProperty(Toolkit::ImageVisual::Property::WRAP_MODE_U, keyValue.second);
- }
- else if(keyValue.first == IMAGE_WRAP_MODE_V)
- {
- DoSetProperty(Toolkit::ImageVisual::Property::WRAP_MODE_V, keyValue.second);
- }
- else if(keyValue.first == SYNCHRONOUS_LOADING)
- {
- DoSetProperty(Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING, keyValue.second);
- }
- else if(keyValue.first == IMAGE_ATLASING)
- {
- DoSetProperty(Toolkit::ImageVisual::Property::ATLASING, keyValue.second);
- }
- else if(keyValue.first == ALPHA_MASK_URL)
- {
- DoSetProperty(Toolkit::ImageVisual::Property::ALPHA_MASK_URL, keyValue.second);
- }
- else if(keyValue.first == MASK_CONTENT_SCALE_NAME)
- {
- DoSetProperty(Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE, keyValue.second);
- }
- else if(keyValue.first == CROP_TO_MASK_NAME)
- {
- DoSetProperty(Toolkit::ImageVisual::Property::CROP_TO_MASK, keyValue.second);
- }
- else if(keyValue.first == MASKING_TYPE_NAME)
- {
- DoSetProperty(Toolkit::DevelImageVisual::Property::MASKING_TYPE, keyValue.second);
- }
- else if(keyValue.first == ENABLE_BROKEN_IMAGE)
- {
- DoSetProperty(Toolkit::DevelImageVisual::Property::ENABLE_BROKEN_IMAGE, keyValue.second);
- }
- else if(keyValue.first == LOAD_POLICY_NAME)
- {
- DoSetProperty(Toolkit::ImageVisual::Property::LOAD_POLICY, keyValue.second);
- }
- else if(keyValue.first == RELEASE_POLICY_NAME)
- {
- DoSetProperty(Toolkit::ImageVisual::Property::RELEASE_POLICY, keyValue.second);
- }
- else if(keyValue.first == ORIENTATION_CORRECTION_NAME)
- {
- DoSetProperty(Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION, keyValue.second);
- }
- else if(keyValue.first == FAST_TRACK_UPLOADING_NAME)
- {
- DoSetProperty(Toolkit::DevelImageVisual::Property::FAST_TRACK_UPLOADING, keyValue.second);
+ if(keyValue.first == NAME_INDEX_MATCH_TABLE[i].name)
+ {
+ DoSetProperty(NAME_INDEX_MATCH_TABLE[i].index, keyValue.second);
+ break;
+ }
}
}
}
case Toolkit::ImageVisual::Property::PIXEL_AREA:
{
value.Get(mPixelArea);
+
+ if(DALI_UNLIKELY(mImpl->mRenderer))
+ {
+ // Unusual case. SetProperty called after OnInitialize().
+ // Assume that DoAction call UPDATE_PROPERTY.
+ mPixelAreaIndex = mImpl->mRenderer.RegisterProperty(mPixelAreaIndex, PIXEL_AREA_UNIFORM_NAME, mPixelArea);
+ }
break;
}
}
else
{
- mMaskingData->mPreappliedMasking = Toolkit::DevelImageVisual::MaskingType::Type(maskingType) == Toolkit::DevelImageVisual::MaskingType::MASKING_ON_LOADING ? true : false;
+ mMaskingData->mPreappliedMasking = (Toolkit::DevelImageVisual::MaskingType::Type(maskingType) == Toolkit::DevelImageVisual::MaskingType::MASKING_ON_LOADING);
}
}
break;
case Toolkit::DevelImageVisual::Property::ENABLE_BROKEN_IMAGE:
{
- bool enableBrokenImage(mEnableBrokenImage);
- if(value.Get(enableBrokenImage))
- {
- mEnableBrokenImage = enableBrokenImage;
- }
+ value.Get(mEnableBrokenImage);
break;
}
}
case Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION:
{
- bool orientationCorrection(mOrientationCorrection);
- if(value.Get(orientationCorrection))
- {
- mOrientationCorrection = orientationCorrection;
- }
+ value.Get(mOrientationCorrection);
break;
}
case Toolkit::DevelImageVisual::Property::FAST_TRACK_UPLOADING:
{
- bool fastTrackUploading = false;
- if(value.Get(fastTrackUploading))
- {
- mUseFastTrackUploading = fastTrackUploading;
- }
+ value.Get(mUseFastTrackUploading);
break;
}
}
else
{
DALI_ASSERT_ALWAYS(mFastTrackLoadingTask->mTextures.size() >= 3u);
- textureSet.SetTexture(0u, mFastTrackLoadingTask->mTextures[0]);
- textureSet.SetTexture(1u, mFastTrackLoadingTask->mTextures[1]);
textureSet.SetTexture(2u, mFastTrackLoadingTask->mTextures[2]);
+ textureSet.SetTexture(1u, mFastTrackLoadingTask->mTextures[1]);
+ textureSet.SetTexture(0u, mFastTrackLoadingTask->mTextures[0]);
// We cannot determine what kind of shader will be used.
// Just use unified shader, and then change shader after load completed.
if(mPixelArea != FULL_TEXTURE_RECT)
{
- mImpl->mRenderer.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, mPixelArea);
+ mPixelAreaIndex = mImpl->mRenderer.RegisterProperty(mPixelAreaIndex, PIXEL_AREA_UNIFORM_NAME, mPixelArea);
}
if(mLoadState == TextureManager::LoadState::LOAD_FINISHED)
map.Insert(Toolkit::ImageVisual::Property::FITTING_MODE, mFittingMode);
map.Insert(Toolkit::ImageVisual::Property::SAMPLING_MODE, mSamplingMode);
- map.Insert(Toolkit::ImageVisual::Property::PIXEL_AREA, mPixelArea);
+ if(mImpl->mRenderer && mPixelAreaIndex != Property::INVALID_INDEX)
+ {
+ // Update values from Renderer
+ Vector4 pixelArea = mImpl->mRenderer.GetProperty<Vector4>(mPixelAreaIndex);
+ map.Insert(Toolkit::ImageVisual::Property::PIXEL_AREA, pixelArea);
+ }
+ else
+ {
+ map.Insert(Toolkit::ImageVisual::Property::PIXEL_AREA, mPixelArea);
+ }
+
map.Insert(Toolkit::ImageVisual::Property::WRAP_MODE_U, mWrapModeU);
map.Insert(Toolkit::ImageVisual::Property::WRAP_MODE_V, mWrapModeV);
Toolkit::Visual::ResourceStatus resourceStatus;
if(mImpl->mRenderer)
{
- if(textureInformation.useAtlasing)
- {
- mImpl->mRenderer.RegisterProperty(ATLAS_RECT_UNIFORM_NAME, mAtlasRect);
- }
-
EnablePreMultipliedAlpha(textureInformation.preMultiplied);
Actor actor = mPlacementActor.GetHandle();
}
else
{
- if(!textureInformation.useAtlasing)
- {
- Sampler sampler = Sampler::New();
- sampler.SetWrapMode(mWrapModeU, mWrapModeV);
- textureInformation.textureSet.SetSampler(0u, sampler);
- }
+ Sampler sampler = Sampler::New();
+ sampler.SetWrapMode(mWrapModeU, mWrapModeV);
+ textureInformation.textureSet.SetSampler(0u, sampler);
mImpl->mRenderer.SetTextures(textureInformation.textureSet);
ComputeTextureSize();
return shader;
}
+Dali::Property ImageVisual::OnGetPropertyObject(Dali::Property::Key key)
+{
+ if((key.type == Property::Key::INDEX && key.indexKey == Toolkit::ImageVisual::Property::PIXEL_AREA) || (key.type == Property::Key::STRING && key.stringKey == PIXEL_AREA_UNIFORM_NAME))
+ {
+ if(DALI_LIKELY(mImpl->mRenderer))
+ {
+ if(mPixelAreaIndex == Property::INVALID_INDEX)
+ {
+ mPixelAreaIndex = mImpl->mRenderer.RegisterProperty(mPixelAreaIndex, PIXEL_AREA_UNIFORM_NAME, mPixelArea);
+ }
+ return Dali::Property(mImpl->mRenderer, mPixelAreaIndex);
+ }
+ }
+
+ Handle handle;
+ return Dali::Property(handle, Property::INVALID_INDEX);
+}
+
void ImageVisual::CheckMaskTexture()
{
if(mMaskingData && !mMaskingData->mPreappliedMasking)
{
mImpl->mRenderer.RegisterProperty(MASK_TEXTURE_RATIO_NAME, ComputeMaskTextureRatio());
}
+ else
+ {
+ mImpl->mRenderer.RegisterProperty(MASK_TEXTURE_RATIO_NAME, Vector2::ONE);
+ }
maskLoadFailed = false;
}