int UtcDaliScriptingNewImage01P(void)
{
TestApplication application; // Image needs application
Property::Map map;
map[ "filename" ] = "TEST_FILE";
// Filename only
ResourceImage image = ResourceImage::DownCast( NewImage( map ) );
DALI_TEST_EQUALS( "TEST_FILE", image.GetUrl(), TEST_LOCATION );
END_TEST;
}
void CubeTransitionApp::GoToNextImage()
{
mNextImage = LoadStageFillingImage( IMAGES[ mIndex ] );
mCurrentEffect.SetTargetImage( mNextImage );
if( mNextImage.GetLoadingState() == ResourceLoadingSucceeded )
{
mIsImageLoading = false;
OnImageLoaded( mNextImage );
}
else
{
mIsImageLoading = true;
mNextImage.LoadingFinishedSignal().Connect( this, &CubeTransitionApp::OnImageLoaded );
}
}
int UtcDaliScriptingNewImageNegative05(void)
{
TestApplication application; // Image needs application
// Invalid release-policy value
Property::Map map;
map[ "filename" ] = "TEST_FILE";
map[ "release-policy" ] = "INVALID";
// will give us a valid image with default release policy
Image image = NewImage( map );
DALI_TEST_CHECK( image );
ResourceImage resImage = ResourceImage::DownCast( image );
DALI_TEST_CHECK( resImage );
DALI_TEST_EQUALS( resImage.GetReleasePolicy(), Image::NEVER, TEST_LOCATION );
END_TEST;
}
int UtcDaliScriptingNewImageNegative03(void)
{
TestApplication application; // Image needs application
// Invalid load-policy value
Property::Map map;
map[ "filename" ] = "TEST_FILE";
map[ "load-policy" ] = "INVALID";
// will give us a valid image with default load policy
Image image = NewImage( map );
DALI_TEST_CHECK( image );
ResourceImage resImage = ResourceImage::DownCast( image );
DALI_TEST_CHECK( resImage );
DALI_TEST_EQUALS( resImage.GetLoadPolicy(), ResourceImage::IMMEDIATE, TEST_LOCATION );
END_TEST;
}
int UtcDaliScriptingNewImageNegative07(void)
{
TestApplication application; // Image needs application
// Invalid height
Property::Map map;
map[ "filename" ] = "TEST_FILE";
map[ "width" ] = 10;
map[ "height" ] = "Invalid";
// will give us a valid image
Image image = NewImage( map );
DALI_TEST_CHECK( image );
ResourceImage resImage = ResourceImage::DownCast( image );
DALI_TEST_CHECK( resImage );
DALI_TEST_EQUALS( resImage.GetWidth(), 10, TEST_LOCATION );
DALI_TEST_EQUALS( resImage.GetHeight(), 0, TEST_LOCATION );
END_TEST;
}
ResourceImage::ResourceImage(const ResourceImage& rhs) : pImpl(0)
{
if(rhs.isOpen()==false) return;
pImpl=new ResourceImageImpl;
pImpl->file=rhs.pImpl->file;
this->height=rhs.height;
this->width=rhs.width;
}
void CreatePropertyMap( Image image, Property::Map& map )
{
map.Clear();
if ( image )
{
std::string imageType( "ResourceImage" );
// Get Type - cannot use TypeRegistry as Image is not an Object and thus, not registered
BufferImage bufferImage = BufferImage::DownCast( image );
if ( bufferImage )
{
imageType = "BufferImage";
map[ "pixelFormat" ] = GetEnumerationName< Pixel::Format >( bufferImage.GetPixelFormat(), PIXEL_FORMAT_TABLE, PIXEL_FORMAT_TABLE_COUNT );
}
else if ( FrameBufferImage::DownCast( image ) )
{
imageType = "FrameBufferImage";
}
map[ "type" ] = imageType;
map[ "releasePolicy" ] = GetEnumerationName< Image::ReleasePolicy >( image.GetReleasePolicy(), IMAGE_RELEASE_POLICY_TABLE, IMAGE_RELEASE_POLICY_TABLE_COUNT );
ResourceImage resourceImage = ResourceImage::DownCast( image );
if( resourceImage )
{
map[ "filename" ] = resourceImage.GetUrl();
map[ "loadPolicy" ] = GetEnumerationName< ResourceImage::LoadPolicy >( resourceImage.GetLoadPolicy(), IMAGE_LOAD_POLICY_TABLE, IMAGE_LOAD_POLICY_TABLE_COUNT );
}
int width( image.GetWidth() );
int height( image.GetHeight() );
if ( width && height )
{
map[ "width" ] = width;
map[ "height" ] = height;
}
}
}
void ResourceModel::LoadMaterialLibrary(const std::string& filename) {
std::string materialFilename = filename;
std::string path = filename.substr(0, filename.find_last_of("\\/") + 1); // We keep the final dash
// Replace the last character of the extension - tmf becomes tml
materialFilename[filename.size()-1] = 'l';
std::ifstream fp;
fp.open(materialFilename.c_str(), std::ios::in);
if (!fp.is_open()) {
FrameWork::GetLogger()->LogError("Couldn't load material library for %s", filename);
return;
}
Material* currentMaterial = 0;
char buffer[256];
char shaderName[64];
char parameterType[16];
char parameterName[64];
char parameterValue[64];
memset(shaderName, 0, sizeof(shaderName));
memset(parameterType, 0, sizeof(parameterType));
memset(parameterName, 0, sizeof(parameterName));
memset(parameterValue, 0, sizeof(parameterValue));
int numTextureMap = 0;
while (fp.getline(buffer, sizeof(buffer))) {
if (buffer[0] != ' ' && buffer[0] != '\n') {
if (currentMaterial) {
numTextureMap = 0;
currentMaterial->shader = new Shader(shaderName, currentMaterial->shaderParameters);
mMaterialList.push_back(currentMaterial);
}
currentMaterial = new Material();
currentMaterial->name = std::string(buffer);
currentMaterial->shaderParameters = new ShaderParameters();
currentMaterial->shader = 0;
continue;
}
sscanf_s(buffer, " %s", parameterType, sizeof(parameterType));
std::string sparameterType(parameterType);
if (sparameterType == "INT") {
int v = 0;
sscanf_s(buffer, "%*s %s %d", parameterName, sizeof(parameterName), &v);
currentMaterial->shaderParameters->SetParameter(parameterName, PARAMETER_TYPE_INT, v);
}
else if (sparameterType == "FLOAT") {
float v = 0.0f;
sscanf_s(buffer, "%*s %s %f", parameterName, sizeof(parameterName), &v);
currentMaterial->shaderParameters->SetParameter(parameterName, PARAMETER_TYPE_FLOAT, v);
}
else if (sparameterType == "FLOAT2") {
float v1, v2;
sscanf_s(buffer, "%*s %s %f %f", parameterName, sizeof(parameterName), &v1, &v2);
currentMaterial->shaderParameters->SetParameter(parameterName, PARAMETER_TYPE_FLOAT2, float2(v1, v2));
}
else if (sparameterType == "FLOAT3") {
float v1, v2, v3;
sscanf_s(buffer, "%*s %s %f %f %f", parameterName, sizeof(parameterName), &v1, &v2, &v3);
currentMaterial->shaderParameters->SetParameter(parameterName, PARAMETER_TYPE_FLOAT3, float3(v1, v2, v3));
}
else if (sparameterType == "FLOAT4") {
float v1, v2, v3, v4;
sscanf_s(buffer, "%*s %s %f %f %f %f", parameterName, sizeof(parameterName), &v1, &v2, &v3, &v4);
currentMaterial->shaderParameters->SetParameter(parameterName, PARAMETER_TYPE_FLOAT4, float4(v1, v2, v3, v4));
}
else if (sparameterType == "TEXTUREMAP") {
sscanf_s(buffer, "%*s %s", parameterName, sizeof(parameterName));
std::string textureFileName(path);
textureFileName += parameterName;
ResourceImage* image = (ResourceImage*)FrameWork::GetResourceManager()->GetResource(textureFileName);
currentMaterial->shaderParameters->SetTextureMap((TextureMap)numTextureMap, image->GetTexture());
numTextureMap++;
}
else if (sparameterType == "SHADER") {
sscanf_s(buffer, "%*s %s", shaderName, sizeof(parameterName));
}
}
if (currentMaterial) {
currentMaterial->shader = new Shader(shaderName, currentMaterial->shaderParameters);
mMaterialList.push_back(currentMaterial);
}
fp.close();
}
