utc-Dali-Gltf2Loader.cpp
utc-Dali-KtxLoader.cpp
utc-Dali-MatrixStack.cpp
+ utc-Dali-MeshDefinition.cpp
utc-Dali-NodeDefinition.cpp
utc-Dali-RendererState.cpp
utc-Dali-ResourceBundle.cpp
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <vector>
+
+#include "dali-scene-loader/public-api/mesh-definition.h"
+#include <dali-test-suite-utils.h>
+
+using namespace Dali;
+using namespace Dali::SceneLoader;
+
+int UtcDaliMeshDefinitionBlobApplyMinMaxBothMinMaxApplied(void)
+{
+ using Container = std::vector<float>;
+
+ Container buffer = { 4.0f, 6.0f, 8.0f, 10.0f, 12.0f };
+ Container minValues = { 5.0f };
+ Container maxValues = { 10.0f };
+ Container result = {5.0f, 6.0f, 8.0f, 10.0f, 10.0f};
+
+ MeshDefinition::Blob::ApplyMinMax(minValues, maxValues, 5, buffer.data());
+
+ for( auto i = 0u; i < result.size(); ++i)
+ {
+ DALI_TEST_EQUALS(buffer[i], result[i], TEST_LOCATION);
+ }
+
+ END_TEST;
+}
+
+int UtcDaliMeshDefinitionBlobApplyMinMaxOnlyMin(void)
+{
+ using Container = std::vector<float>;
+
+ Container buffer = { 4.0f, 6.0f, 8.0f, 10.0f, 12.0f };
+ Container minValues = { 5.0f };
+ Container maxValues = {};
+ Container result = {5.0f, 6.0f, 8.0f, 10.0f, 12.0f};
+
+ MeshDefinition::Blob::ApplyMinMax(minValues, maxValues, 5, buffer.data());
+
+ for( auto i = 0u; i < result.size(); ++i)
+ {
+ DALI_TEST_EQUALS(buffer[i], result[i], TEST_LOCATION);
+ }
+
+ END_TEST;
+}
+
+int UtcDaliMeshDefinitionBlobApplyMinMaxOnlyMax(void)
+{
+ using Container = std::vector<float>;
+
+ Container buffer = { 4.0f, 6.0f, 8.0f, 10.0f, 12.0f };
+ Container minValues = { };
+ Container maxValues = { 10.0f };
+ Container result = {4.0f, 6.0f, 8.0f, 10.0f, 10.0f};
+
+ MeshDefinition::Blob::ApplyMinMax(minValues, maxValues, 5, buffer.data());
+
+ for( auto i = 0u; i < result.size(); ++i)
+ {
+ DALI_TEST_EQUALS(buffer[i], result[i], TEST_LOCATION);
+ }
+
+ END_TEST;
+}
+
+int UtcDaliMeshDefinitionBlobApplyMinMaxBothEmpty(void)
+{
+ using Container = std::vector<float>;
+
+ Container buffer = { 4.0f, 6.0f, 8.0f, 10.0f, 12.0f };
+ Container minValues;
+ Container maxValues;
+ Container result = {4.0f, 6.0f, 8.0f, 10.0f, 12.0f};
+
+ MeshDefinition::Blob::ApplyMinMax(minValues, maxValues, 5, buffer.data());
+
+ for( auto i = 0u; i < result.size(); ++i)
+ {
+ DALI_TEST_EQUALS(buffer[i], result[i], TEST_LOCATION);
+ }
+
+ END_TEST;
+}
+
SET(PKG_NAME "dali-shader-generator")
SET(EXEC_NAME "tct-${PKG_NAME}-core")
+SET(EXEC_NAME "tct-${PKG_NAME}-core")
+
+SET(CAPI_LIB "dali-shader-generator")
-PKG_CHECK_MODULES(${EXEC_NAME} REQUIRED
+PKG_CHECK_MODULES(${CAPI_LIB} REQUIRED
+ dali2-core
+ dali2-adaptor
dali2-toolkit
)
-ADD_EXECUTABLE(${EXEC_NAME} ${EXEC_NAME}.cpp)
+SET(TC_SOURCES
+ utc-Dali-ShaderGenerator.cpp
+)
+
+# List of test harness files (Won't get parsed for test cases)
+SET(TEST_HARNESS_DIR "../dali-toolkit/dali-toolkit-test-utils")
+
+SET(TEST_HARNESS_SOURCES
+ ${TEST_HARNESS_DIR}/toolkit-adaptor.cpp
+ ${TEST_HARNESS_DIR}/toolkit-application.cpp
+ ${TEST_HARNESS_DIR}/toolkit-event-thread-callback.cpp
+ ${TEST_HARNESS_DIR}/toolkit-environment-variable.cpp
+ ${TEST_HARNESS_DIR}/toolkit-input-method-context.cpp
+ ${TEST_HARNESS_DIR}/toolkit-input-method-options.cpp
+ ${TEST_HARNESS_DIR}/toolkit-lifecycle-controller.cpp
+ ${TEST_HARNESS_DIR}/toolkit-orientation.cpp
+ ${TEST_HARNESS_DIR}/toolkit-style-monitor.cpp
+ ${TEST_HARNESS_DIR}/toolkit-test-application.cpp
+ ${TEST_HARNESS_DIR}/toolkit-timer.cpp
+ ${TEST_HARNESS_DIR}/toolkit-trigger-event-factory.cpp
+ ${TEST_HARNESS_DIR}/toolkit-window.cpp
+ ${TEST_HARNESS_DIR}/toolkit-scene-holder.cpp
+ ${TEST_HARNESS_DIR}/dali-test-suite-utils.cpp
+ ${TEST_HARNESS_DIR}/dali-toolkit-test-suite-utils.cpp
+ ${TEST_HARNESS_DIR}/dummy-control.cpp
+ ${TEST_HARNESS_DIR}/mesh-builder.cpp
+ ${TEST_HARNESS_DIR}/test-actor-utils.cpp
+ ${TEST_HARNESS_DIR}/test-animation-data.cpp
+ ${TEST_HARNESS_DIR}/test-application.cpp
+ ${TEST_HARNESS_DIR}/test-button.cpp
+ ${TEST_HARNESS_DIR}/test-harness.cpp
+ ${TEST_HARNESS_DIR}/test-gesture-generator.cpp
+ ${TEST_HARNESS_DIR}/test-gl-abstraction.cpp
+ ${TEST_HARNESS_DIR}/test-gl-sync-abstraction.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-buffer.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-command-buffer.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-controller.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-texture.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-sampler.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-program.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-pipeline.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-shader.cpp
+ ${TEST_HARNESS_DIR}/test-graphics-reflection.cpp
+ ${TEST_HARNESS_DIR}/test-platform-abstraction.cpp
+ ${TEST_HARNESS_DIR}/test-render-controller.cpp
+ ${TEST_HARNESS_DIR}/test-trace-call-stack.cpp
+)
+
+ADD_DEFINITIONS(-DTEST_RESOURCE_DIR=\"${CMAKE_CURRENT_SOURCE_DIR}/../../resources\" )
+
+FOREACH(directory ${${CAPI_LIB}_LIBRARY_DIRS})
+ SET(CMAKE_CXX_LINK_FLAGS "${CMAKE_CXX_LINK_FLAGS} -L${directory}")
+ENDFOREACH(directory ${CAPI_LIB_LIBRARY_DIRS})
+
+INCLUDE_DIRECTORIES(
+ ../../../
+ ${${CAPI_LIB}_INCLUDE_DIRS}
+ ../dali-toolkit/dali-toolkit-test-utils
+)
+
+ADD_COMPILE_OPTIONS( -O0 -ggdb --coverage -Wall -Werror -DDEBUG_ENABLED)
+ADD_COMPILE_OPTIONS( ${${CAPI_LIB}_CFLAGS_OTHER} )
+
+ADD_EXECUTABLE(${EXEC_NAME} ${EXEC_NAME}.h ${EXEC_NAME}.cpp ${TC_SOURCES} ${TEST_HARNESS_SOURCES})
+
+TARGET_LINK_LIBRARIES(${EXEC_NAME}
+ ${${CAPI_LIB}_LIBRARIES}
+ -lpthread --coverage
+)
+
+ADD_CUSTOM_COMMAND(
+ COMMAND ${SCRIPT_DIR}/tcheadgen.sh ${EXEC_NAME}.h ${TC_SOURCES}
+ WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ OUTPUT ${EXEC_NAME}.h
+ COMMENT "Generating test tables"
+)
INSTALL(PROGRAMS ${EXEC_NAME}
- DESTINATION ${BIN_DIR}/${EXEC_NAME}
+ DESTINATION ${BIN_DIR}/${EXEC_NAME}
)
SET(SHADER_GENERATOR dali-shader-generator)
SET(GENERATED_FOLDER ${CMAKE_CURRENT_BINARY_DIR}/shader/generated)
SET(SHADER_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/shader)
+# All the shader generator execution tests are below
+
ADD_CUSTOM_TARGET(test_help ALL COMMAND ${SHADER_GENERATOR} -h | grep "DALi Shader Generator" > /dev/null 2>&1 && echo "test_help Succeeded" VERBATIM)
ADD_CUSTOM_TARGET(test_no_params ALL COMMAND ${SHADER_GENERATOR} > /dev/null 2>&1 || echo "test_no_params Succeeded" VERBATIM)
ADD_CUSTOM_TARGET(test_version ALL COMMAND ${SHADER_GENERATOR} -v | wc -l | grep 1 > /dev/null 2>&1 && echo "test_version Succeeded" VERBATIM)
ALL
COMMAND ${SHADER_GENERATOR} ${SHADER_FOLDER} ${GENERATED_FOLDER} | grep "SHADER_SHADER_DEFINE_DEF" | grep "shader-define-def.h" > /dev/null 2>&1 && echo "test_def_correct Succeeded"
VERBATIM)
+
-#include <iostream>
+#include <test-harness.h>
+#include "tct-dali-shader-generator-core.h"
+
int main(int argc, char * const argv[])
{
- std::cout << "All tests run as part of Cmake build." << std::endl;
- return 0;
+ return TestHarness::RunTests(argc, argv, tc_array);
}
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <dali-toolkit-test-suite-utils.h>
+
+void utc_dali_shader_generator_startup(void)
+{
+ test_return_value = TET_UNDEF;
+}
+
+void utc_dali_shader_generator_cleanup(void)
+{
+ test_return_value = TET_PASS;
+}
+
+int UtcDaliShaderGenerator(void)
+{
+ tet_infoline("All tests run as part of cmake build");
+ DALI_TEST_CHECK(true);
+ END_TEST;
+}
bool Load(const std::string& url)
{
mUrl = url;
- if(mUrl == "invalid.json")
+ if(mUrl == "invalid.json" || mUrl == "invalid.riv")
{
return false;
}
return mConsoleMessageSignal;
}
- Dali::WebEnginePlugin::WebEnginePolicyDecisionSignalType& PolicyDecisionSignal()
+ Dali::WebEnginePlugin::WebEngineResponsePolicyDecisionSignalType& ResponsePolicyDecisionSignal()
{
- return mPolicyDecisionSignal;
+ return mResponsePolicyDecisionSignal;
}
Dali::WebEnginePlugin::WebEngineCertificateSignalType& CertificateConfirmSignal()
Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType mFrameRenderedSignal;
Dali::WebEnginePlugin::WebEngineRequestInterceptorSignalType mRequestInterceptorSignal;
Dali::WebEnginePlugin::WebEngineConsoleMessageSignalType mConsoleMessageSignal;
- Dali::WebEnginePlugin::WebEnginePolicyDecisionSignalType mPolicyDecisionSignal;
+ Dali::WebEnginePlugin::WebEngineResponsePolicyDecisionSignalType mResponsePolicyDecisionSignal;
Dali::WebEnginePlugin::WebEngineCertificateSignalType mCertificateConfirmSignal;
Dali::WebEnginePlugin::WebEngineCertificateSignalType mSslCertificateChangedSignal;
Dali::WebEnginePlugin::WebEngineHttpAuthHandlerSignalType mHttpAuthHandlerSignal;
std::shared_ptr<Dali::WebEngineConsoleMessage> message(new MockWebEngineConsoleMessage());
gInstance->mConsoleMessageSignal.Emit(std::move(message));
std::shared_ptr<Dali::WebEnginePolicyDecision> policyDecision(new MockWebEnginePolicyDecision());
- gInstance->mPolicyDecisionSignal.Emit(std::move(policyDecision));
+ gInstance->mResponsePolicyDecisionSignal.Emit(std::move(policyDecision));
std::shared_ptr<Dali::WebEngineCertificate> certificate(new MockWebEngineCertificate());
gInstance->mCertificateConfirmSignal.Emit(std::move(certificate));
return Internal::Adaptor::GetImplementation(*this).ConsoleMessageSignal();
}
-Dali::WebEnginePlugin::WebEnginePolicyDecisionSignalType& WebEngine::PolicyDecisionSignal()
+Dali::WebEnginePlugin::WebEngineResponsePolicyDecisionSignalType& WebEngine::ResponsePolicyDecisionSignal()
{
- return Internal::Adaptor::GetImplementation(*this).PolicyDecisionSignal();
+ return Internal::Adaptor::GetImplementation(*this).ResponsePolicyDecisionSignal();
}
Dali::WebEnginePlugin::WebEngineCertificateSignalType& WebEngine::CertificateConfirmSignal()
const char* TEST_VECTOR_IMAGE_FILE_NAME_FRAME_DROP = "framedrop.json";
const char* TEST_VECTOR_IMAGE_INVALID_FILE_NAME = "invalid.json";
+const char* TEST_VECTOR_IMAGE_RIVE_FILE_NAME = TEST_RESOURCE_DIR "/shape.riv";
+const char* TEST_VECTOR_IMAGE_INVALID_RIVE_FILE_NAME = "invalid.riv";
+
bool gAnimationFinishedSignalFired = false;
void VisualEventSignal( Control control, Dali::Property::Index visualIndex, Dali::Property::Index signalId )
END_TEST;
}
+
+int UtcDaliAnimatedVectorImageVisualLoadRiveFileP(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline( "UtcDaliAnimatedVectorImageVisualLoadRiveFile: Request animated vector image visual with a rive url" );
+
+ VisualFactory factory = VisualFactory::Get();
+ Visual::Base visual = factory.CreateVisual( TEST_VECTOR_IMAGE_RIVE_FILE_NAME, ImageDimensions() );
+ DALI_TEST_CHECK( visual );
+
+ DummyControl actor = DummyControl::New( true );
+ DummyControlImpl& dummyImpl = static_cast< DummyControlImpl& >( actor.GetImplementation() );
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
+ actor.SetProperty( Actor::Property::SIZE, Vector2( 200.0f, 200.0f ) );
+ application.GetScene().Add( actor );
+
+ application.SendNotification();
+ application.Render();
+
+ // renderer is added to actor
+ DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
+ Renderer renderer = actor.GetRendererAt( 0u );
+ DALI_TEST_CHECK( renderer );
+
+ // Test SetOffScene().
+ actor.Unparent();
+ DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
+
+ END_TEST;
+}
+
+int UtcDaliAnimatedVectorImageVisualLoadRiveFileN(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline("Request loading with invalid rive file - should draw broken image");
+
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& textureTrace = gl.GetTextureTrace();
+ textureTrace.Enable(true);
+
+ Property::Map propertyMap;
+ propertyMap.Add(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE)
+ .Add(ImageVisual::Property::URL, TEST_VECTOR_IMAGE_INVALID_RIVE_FILE_NAME);
+
+ Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
+ DALI_TEST_CHECK(visual);
+
+ DummyControl actor = DummyControl::New(true);
+ DummyControlImpl& dummyImpl = static_cast< DummyControlImpl& >(actor.GetImplementation());
+ dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
+
+ actor.SetProperty(Actor::Property::SIZE, Vector2(20.0f, 20.0f));
+
+ application.GetScene().Add(actor);
+
+ application.SendNotification();
+ application.Render();
+
+ // Check resource status
+ Visual::ResourceStatus status = actor.GetVisualResourceStatus(DummyControl::Property::TEST_VISUAL);
+ DALI_TEST_EQUALS(status, Visual::ResourceStatus::FAILED, TEST_LOCATION);
+
+ // The broken image should be shown.
+ DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
+
+ END_TEST;
+}
+
+int UtcDaliAnimatedVectorImageVisualPlaybackRiveFile(void)
+{
+ ToolkitTestApplication application;
+
+ tet_infoline( "UtcDaliAnimatedVectorImageVisualPlaybackRiveFile" );
+
+ {
+ // request AnimatedVectorImageVisual for Rive with a property map
+ VisualFactory factory = VisualFactory::Get();
+ Visual::Base visual = factory.CreateVisual(
+ Property::Map()
+ .Add( Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_VECTOR_IMAGE )
+ .Add( ImageVisual::Property::URL, TEST_VECTOR_IMAGE_RIVE_FILE_NAME ) );
+
+ DummyControl dummyControl = DummyControl::New( true );
+ Impl::DummyControl& dummyImpl = static_cast< Impl::DummyControl& >( dummyControl.GetImplementation() );
+ dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
+ dummyControl.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
+
+ Property::Map attributes;
+ tet_infoline( "Test Play action" );
+ DevelControl::DoAction( dummyControl, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes );
+
+ application.GetScene().Add( dummyControl );
+ application.SendNotification();
+ application.Render( 16 );
+
+ Property::Map map = dummyControl.GetProperty< Property::Map >( DummyControl::Property::TEST_VISUAL );
+ Property::Value* value = map.Find( DevelImageVisual::Property::PLAY_STATE );
+ DALI_TEST_CHECK( value->Get< int >() == DevelImageVisual::PlayState::PLAYING );
+
+ tet_infoline( "Test Pause action" );
+ DevelControl::DoAction( dummyControl, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PAUSE, attributes );
+
+ application.SendNotification();
+ application.Render(16);
+
+ map = dummyControl.GetProperty< Property::Map >( DummyControl::Property::TEST_VISUAL );
+ value = map.Find( DevelImageVisual::Property::PLAY_STATE );
+ DALI_TEST_CHECK( value->Get< int >() == DevelImageVisual::PlayState::PAUSED );
+
+ tet_infoline( "Test Play action" );
+ DevelControl::DoAction( dummyControl, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes );
+
+ application.SendNotification();
+ application.Render(16);
+
+ map = dummyControl.GetProperty< Property::Map >( DummyControl::Property::TEST_VISUAL );
+ value = map.Find( DevelImageVisual::Property::PLAY_STATE );
+ DALI_TEST_CHECK( value->Get< int >() == DevelImageVisual::PlayState::PLAYING );
+
+ tet_infoline( "Test Stop action" );
+ DevelControl::DoAction( dummyControl, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::STOP, attributes );
+
+ application.SendNotification();
+ application.Render(16);
+
+ map = dummyControl.GetProperty< Property::Map >( DummyControl::Property::TEST_VISUAL );
+ value = map.Find( DevelImageVisual::Property::PLAY_STATE );
+ DALI_TEST_CHECK( value->Get< int >() == DevelImageVisual::PlayState::STOPPED );
+
+ tet_infoline( "Test Stop action again" );
+ DevelControl::DoAction( dummyControl, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::STOP, attributes );
+
+ application.SendNotification();
+ application.Render(16);
+
+ map = dummyControl.GetProperty< Property::Map >( DummyControl::Property::TEST_VISUAL );
+ value = map.Find( DevelImageVisual::Property::PLAY_STATE );
+ DALI_TEST_CHECK( value->Get< int >() == DevelImageVisual::PlayState::STOPPED );
+
+ tet_infoline( "Test Play action" );
+ DevelControl::DoAction( dummyControl, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes );
+
+ application.SendNotification();
+ application.Render(16);
+
+ map = dummyControl.GetProperty< Property::Map >( DummyControl::Property::TEST_VISUAL );
+ value = map.Find( DevelImageVisual::Property::PLAY_STATE );
+ DALI_TEST_CHECK( value->Get< int >() == DevelImageVisual::PlayState::PLAYING );
+
+ tet_infoline( "Off stage" );
+ dummyControl.Unparent();
+
+ application.SendNotification();
+ application.Render(16);
+
+ map = dummyControl.GetProperty< Property::Map >( DummyControl::Property::TEST_VISUAL );
+ value = map.Find( DevelImageVisual::Property::PLAY_STATE );
+ DALI_TEST_CHECK( value->Get< int >() == DevelImageVisual::PlayState::STOPPED );
+
+ tet_infoline( "On stage again" );
+ application.GetScene().Add( dummyControl );
+
+ application.SendNotification();
+ application.Render(16);
+
+ map = dummyControl.GetProperty< Property::Map >( DummyControl::Property::TEST_VISUAL );
+ value = map.Find( DevelImageVisual::Property::PLAY_STATE );
+ DALI_TEST_CHECK( value->Get< int >() == DevelImageVisual::PlayState::STOPPED );
+
+ tet_infoline( "Test Play action" );
+ DevelControl::DoAction( dummyControl, DummyControl::Property::TEST_VISUAL, Dali::Toolkit::DevelAnimatedVectorImageVisual::Action::PLAY, attributes );
+
+ application.SendNotification();
+ application.Render(16);
+
+ map = dummyControl.GetProperty< Property::Map >( DummyControl::Property::TEST_VISUAL );
+ value = map.Find( DevelImageVisual::Property::PLAY_STATE );
+ DALI_TEST_CHECK( value->Get< int >() == DevelImageVisual::PlayState::PLAYING );
+
+ // Change Size
+ Vector3 newSize( 100.0f, 100.0f, 0.0f );
+ dummyControl.SetProperty( Actor::Property::SIZE, newSize );
+
+ application.SendNotification();
+ application.Render(16);
+
+ // Size should be changed
+ Vector3 naturalSize = dummyControl.GetNaturalSize();
+ DALI_TEST_CHECK( naturalSize == newSize );
+
+ dummyControl.Unparent();
+ }
+
+ END_TEST;
+}
\ No newline at end of file
static std::shared_ptr<Dali::WebEngineRequestInterceptor> gRequestInterceptorInstance = nullptr;
static int gConsoleMessageCallbackCalled = 0;
static std::shared_ptr<Dali::WebEngineConsoleMessage> gConsoleMessageInstance = nullptr;
-static int gPolicyDecisionCallbackCalled = 0;
-static std::shared_ptr<Dali::WebEnginePolicyDecision> gPolicyDecisionInstance = nullptr;
+static int gResponsePolicyDecidedCallbackCalled = 0;
+static std::shared_ptr<Dali::WebEnginePolicyDecision> gResponsePolicyDecisionInstance = nullptr;
static int gCertificateConfirmCallbackCalled = 0;
static std::shared_ptr<Dali::WebEngineCertificate> gCertificateConfirmInstance = nullptr;
static int gSslCertificateChangedCallbackCalled = 0;
gScrollEdgeReachedCallbackCalled++;
}
-static void OnPolicyDecisionRequest(WebView view, std::shared_ptr<Dali::WebEnginePolicyDecision> decision)
+static void OnResponsePolicyDecided(WebView view, std::shared_ptr<Dali::WebEnginePolicyDecision> decision)
{
- gPolicyDecisionCallbackCalled++;
- gPolicyDecisionInstance = std::move(decision);
+ gResponsePolicyDecidedCallbackCalled++;
+ gResponsePolicyDecisionInstance = std::move(decision);
}
static void OnUrlChanged( WebView view, const std::string& url )
END_TEST;
}
-int UtcDaliWebViewPolicyDecisionRequest(void)
+int UtcDaliWebViewResponsePolicyDecisionRequest(void)
{
ToolkitTestApplication application;
// load url.
ConnectionTracker* testTracker = new ConnectionTracker();
- view.PolicyDecisionSignal().Connect( &OnPolicyDecisionRequest );
+ view.ResponsePolicyDecisionSignal().Connect( &OnResponsePolicyDecided );
bool signal1 = false;
- view.ConnectSignal( testTracker, "policyDecision", CallbackFunctor(&signal1) );
- DALI_TEST_EQUALS( gPolicyDecisionCallbackCalled, 0, TEST_LOCATION );
- DALI_TEST_CHECK(gPolicyDecisionInstance == 0);
+ view.ConnectSignal( testTracker, "responsePolicyDecided", CallbackFunctor(&signal1) );
+ DALI_TEST_EQUALS( gResponsePolicyDecidedCallbackCalled, 0, TEST_LOCATION );
+ DALI_TEST_CHECK(gResponsePolicyDecisionInstance == 0);
view.LoadUrl( TEST_URL1 );
Test::EmitGlobalTimerSignal();
- DALI_TEST_EQUALS( gPolicyDecisionCallbackCalled, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS( gResponsePolicyDecidedCallbackCalled, 1, TEST_LOCATION );
DALI_TEST_CHECK( signal1 );
- // check policy decision & its frame.
- DALI_TEST_CHECK(gPolicyDecisionInstance != 0);
+ // check response policy decision & its frame.
+ DALI_TEST_CHECK(gResponsePolicyDecisionInstance != 0);
std::string testUrl("http://test.html");
- DALI_TEST_EQUALS(gPolicyDecisionInstance->GetUrl(), testUrl, TEST_LOCATION);
+ DALI_TEST_EQUALS(gResponsePolicyDecisionInstance->GetUrl(), testUrl, TEST_LOCATION);
std::string testCookie("test:abc");
- DALI_TEST_EQUALS(gPolicyDecisionInstance->GetCookie(), testCookie, TEST_LOCATION);
+ DALI_TEST_EQUALS(gResponsePolicyDecisionInstance->GetCookie(), testCookie, TEST_LOCATION);
Dali::WebEnginePolicyDecision::DecisionType testDecisionType = Dali::WebEnginePolicyDecision::DecisionType::USE;
- DALI_TEST_EQUALS(gPolicyDecisionInstance->GetDecisionType(), testDecisionType, TEST_LOCATION);
+ DALI_TEST_EQUALS(gResponsePolicyDecisionInstance->GetDecisionType(), testDecisionType, TEST_LOCATION);
std::string testResponseMime("txt/xml");
- DALI_TEST_EQUALS(gPolicyDecisionInstance->GetResponseMime(), testResponseMime, TEST_LOCATION);
+ DALI_TEST_EQUALS(gResponsePolicyDecisionInstance->GetResponseMime(), testResponseMime, TEST_LOCATION);
int32_t ResponseStatusCode = 500;
- DALI_TEST_EQUALS(gPolicyDecisionInstance->GetResponseStatusCode(), ResponseStatusCode, TEST_LOCATION);
+ DALI_TEST_EQUALS(gResponsePolicyDecisionInstance->GetResponseStatusCode(), ResponseStatusCode, TEST_LOCATION);
Dali::WebEnginePolicyDecision::NavigationType testNavigationType = Dali::WebEnginePolicyDecision::NavigationType::LINK_CLICKED;
- DALI_TEST_EQUALS(gPolicyDecisionInstance->GetNavigationType(), testNavigationType, TEST_LOCATION);
+ DALI_TEST_EQUALS(gResponsePolicyDecisionInstance->GetNavigationType(), testNavigationType, TEST_LOCATION);
std::string testScheme("test");
- DALI_TEST_EQUALS(gPolicyDecisionInstance->GetScheme(), testScheme, TEST_LOCATION);
- DALI_TEST_CHECK(gPolicyDecisionInstance->Use());
- DALI_TEST_CHECK(gPolicyDecisionInstance->Ignore());
- DALI_TEST_CHECK(gPolicyDecisionInstance->Suspend());
+ DALI_TEST_EQUALS(gResponsePolicyDecisionInstance->GetScheme(), testScheme, TEST_LOCATION);
+ DALI_TEST_CHECK(gResponsePolicyDecisionInstance->Use());
+ DALI_TEST_CHECK(gResponsePolicyDecisionInstance->Ignore());
+ DALI_TEST_CHECK(gResponsePolicyDecisionInstance->Suspend());
- Dali::WebEngineFrame* webFrame = &(gPolicyDecisionInstance->GetFrame());
+ Dali::WebEngineFrame* webFrame = &(gResponsePolicyDecisionInstance->GetFrame());
DALI_TEST_CHECK(webFrame);
DALI_TEST_CHECK(webFrame->IsMainFrame());
- gPolicyDecisionInstance = nullptr;
+ gResponsePolicyDecisionInstance = nullptr;
END_TEST;
}
SET(SHADER_GENERATOR_NAME dali-shader-generator)
SET(SHADER_GENERATOR_SOURCES ${ROOT_SRC_DIR}/dali-toolkit/shader-generator/shader-generator.cpp)
+IF( WIN32)
+ # When Using VCPKG, the default is always set to Debug if CMAKE_BUILD_TYPE is not set
+ IF( NOT CMAKE_BUILD_TYPE )
+ SET(SHADER_GENERATOR_BINARY ${CMAKE_CURRENT_BINARY_DIR}/Debug/${SHADER_GENERATOR_NAME})
+ ELSE()
+ SET(SHADER_GENERATOR_BINARY ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/${SHADER_GENERATOR_NAME})
+ ENDIF()
+ELSE()
+ SET(SHADER_GENERATOR_BINARY ${CMAKE_CURRENT_BINARY_DIR}/${SHADER_GENERATOR_NAME})
+ENDIF()
+
IF(NOT ANDROID)
ADD_EXECUTABLE(${SHADER_GENERATOR_NAME} ${SHADER_GENERATOR_SOURCES})
INSTALL(TARGETS ${SHADER_GENERATOR_NAME} RUNTIME DESTINATION bin)
SET(BUILT_IN_SHADER_GEN_CPP "${GENERATED_SHADER_DIR}/generated/builtin-shader-gen.cpp")
ADD_CUSTOM_COMMAND(OUTPUT ${BUILT_IN_SHADER_GEN_CPP}
DEPENDS ${SHADER_GENERATOR_NAME}
- COMMAND ${CMAKE_CURRENT_BINARY_DIR}/${SHADER_GENERATOR_NAME} ${SHADER_SOURCE_DIR} ${SHADER_GENERATED_DIR})
+ COMMAND ${SHADER_GENERATOR_BINARY} ${SHADER_SOURCE_DIR} ${SHADER_GENERATED_DIR})
SET(SOURCES ${SOURCES} ${BUILT_IN_SHADER_GEN_CPP})
add_definitions("-DDEBUG_ENABLED")
endif()
+ADD_DEFINITIONS( "-DBUILDING_DALI_SCENE_LOADER" )
+
foreach(flag ${PKGS_CFLAGS})
set(extra_flags "${extra_flags} ${flag}")
endforeach(flag)
"${GENERATED_SHADER_DIR}/generated/"
"${GENERATED_SHADER_DIR}/builtin-shader-extern-gen.h")
+IF( WIN32)
+ # When Using VCPKG, the default is always set to Debug if CMAKE_BUILD_TYPE is not set
+ IF( NOT CMAKE_BUILD_TYPE )
+ SET(SHADER_GENERATOR_BINARY ${CMAKE_CURRENT_BINARY_DIR}/../Debug/${SHADER_GENERATOR_NAME})
+ ELSE()
+ SET(SHADER_GENERATOR_BINARY ${CMAKE_CURRENT_BINARY_DIR}/../${CMAKE_BUILD_TYPE}/${SHADER_GENERATOR_NAME})
+ ENDIF()
+ELSE()
+ SET(SHADER_GENERATOR_BINARY ${CMAKE_CURRENT_BINARY_DIR}/../${SHADER_GENERATOR_NAME})
+ENDIF()
+
SET( BUILT_IN_SHADER_GEN_CPP "${GENERATED_SHADER_DIR}/generated/builtin-shader-gen.cpp")
ADD_CUSTOM_COMMAND(OUTPUT ${BUILT_IN_SHADER_GEN_CPP}
- DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/../${SHADER_GENERATOR_NAME}
- COMMAND ${CMAKE_CURRENT_BINARY_DIR}/../${SHADER_GENERATOR_NAME} ${SHADER_SOURCE_DIR} ${SHADER_GENERATED_DIR})
+ DEPENDS ${SHADER_GENERATOR_BINARY}
+ COMMAND ${SHADER_GENERATOR_BINARY} ${SHADER_SOURCE_DIR} ${SHADER_GENERATED_DIR})
SET( scene_loader_src_files ${scene_loader_src_files} ${BUILT_IN_SHADER_GEN_CPP} )
: (max.empty() ? [](const float* min, const float* max, uint32_t i, float& value) {
value = std::max(min[i], value);
}
- : [](const float* min, const float* max, uint32_t i, float& value) {
+ : static_cast<ClampFn>([](const float* min, const float* max, uint32_t i, float& value) {
value = std::min(std::max(min[i], value), max[i]);
- });
+ }));
if(!clampFn)
{
return Dali::Toolkit::GetImpl(*this).ConsoleMessageSignal();
}
-WebView::WebViewPolicyDecisionSignalType& WebView::PolicyDecisionSignal()
+WebView::WebViewResponsePolicyDecisionSignalType& WebView::ResponsePolicyDecisionSignal()
{
- return Dali::Toolkit::GetImpl(*this).PolicyDecisionSignal();
+ return Dali::Toolkit::GetImpl(*this).ResponsePolicyDecisionSignal();
}
WebView::WebViewCertificateSignalType& WebView::CertificateConfirmSignal()
using WebViewConsoleMessageSignalType = Signal<void(WebView, std::shared_ptr<Dali::WebEngineConsoleMessage>)>;
/**
- * @brief WebView signal type related with policy decision.
+ * @brief WebView signal type related with response policy decision.
*/
- using WebViewPolicyDecisionSignalType = Signal<void(WebView, std::shared_ptr<Dali::WebEnginePolicyDecision>)>;
+ using WebViewResponsePolicyDecisionSignalType = Signal<void(WebView, std::shared_ptr<Dali::WebEnginePolicyDecision>)>;
/**
* @brief WebView signal type related with certificate changed.
WebViewConsoleMessageSignalType& ConsoleMessageSignal();
/**
- * @brief Connect to this signal to be notified when new policy would be decided.
+ * @brief Connect to this signal to be notified when response policy would be decided.
*
* @return A signal object to connect with.
*/
- WebViewPolicyDecisionSignalType& PolicyDecisionSignal();
+ WebViewResponsePolicyDecisionSignalType& ResponsePolicyDecisionSignal();
/**
* @brief Connect to this signal to be notified when certificate need be confirmed.
DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "frameRendered", FRAME_RENDERED_SIGNAL )
DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "requestInterceptor", REQUEST_INTERCEPTOR_SIGNAL )
DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "consoleMessage", CONSOLE_MESSAGE_SIGNAL )
-DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "policyDecision", POLICY_DECISION )
+DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "responsePolicyDecided", POLICY_DECISION )
DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "certificateConfirm", CERTIFICATE_CONFIRM_SIGNAL )
DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "sslCertificateChanged", SSL_CERTIFICATE_CHANGED_SIGNAL )
DALI_SIGNAL_REGISTRATION(Toolkit, WebView, "httpAuthRequest", HTTP_AUTH_REQUEST_SIGNAL )
mWebEngine.FrameRenderedSignal().Connect(this, &WebView::OnFrameRendered);
mWebEngine.RequestInterceptorSignal().Connect(this, &WebView::OnInterceptRequest);
mWebEngine.ConsoleMessageSignal().Connect(this, &WebView::OnConsoleMessage);
- mWebEngine.PolicyDecisionSignal().Connect(this, &WebView::OnPolicyDecisionRequest);
+ mWebEngine.ResponsePolicyDecisionSignal().Connect(this, &WebView::OnResponsePolicyDecided);
mWebEngine.CertificateConfirmSignal().Connect(this, &WebView::OnCertificateConfirm);
mWebEngine.SslCertificateChangedSignal().Connect(this, &WebView::OnSslCertificateChanged);
mWebEngine.HttpAuthHandlerSignal().Connect(this, &WebView::OnHttpAuthenticationRequest);
return mConsoleMessageSignal;
}
-Dali::Toolkit::WebView::WebViewPolicyDecisionSignalType& WebView::PolicyDecisionSignal()
+Dali::Toolkit::WebView::WebViewResponsePolicyDecisionSignalType& WebView::ResponsePolicyDecisionSignal()
{
- return mPolicyDecisionSignal;
+ return mResponsePolicyDecisionSignal;
}
Dali::Toolkit::WebView::WebViewCertificateSignalType& WebView::CertificateConfirmSignal()
}
}
-void WebView::OnPolicyDecisionRequest(std::shared_ptr<Dali::WebEnginePolicyDecision> decision)
+void WebView::OnResponsePolicyDecided(std::shared_ptr<Dali::WebEnginePolicyDecision> decision)
{
- if(!mPolicyDecisionSignal.Empty())
+ if(!mResponsePolicyDecisionSignal.Empty())
{
Dali::Toolkit::WebView handle(GetOwner());
- mPolicyDecisionSignal.Emit(handle, std::move(decision));
+ mResponsePolicyDecisionSignal.Emit(handle, std::move(decision));
}
}
}
else if(0 == strcmp(signalName.c_str(), POLICY_DECISION))
{
- webView.PolicyDecisionSignal().Connect(tracker, functor);
+ webView.ResponsePolicyDecisionSignal().Connect(tracker, functor);
connected = true;
}
else if(0 == strcmp(signalName.c_str(), CERTIFICATE_CONFIRM_SIGNAL))
Dali::Toolkit::WebView::WebViewConsoleMessageSignalType& ConsoleMessageSignal();
/**
- * @copydoc Dali::Toolkit::WebView::PolicyDecisionSignal()
+ * @copydoc Dali::Toolkit::WebView::ResponsePolicyDecisionSignal()
*/
- Dali::Toolkit::WebView::WebViewPolicyDecisionSignalType& PolicyDecisionSignal();
+ Dali::Toolkit::WebView::WebViewResponsePolicyDecisionSignalType& ResponsePolicyDecisionSignal();
/**
* @copydoc Dali::Toolkit::WebView::CertificateConfirmSignal()
void OnConsoleMessage(std::shared_ptr<Dali::WebEngineConsoleMessage> message);
/**
- * @brief Callback function to be called when policy need be decided.
+ * @brief Callback function to be called when response policy need be decided.
* @param[in] decision The policy decided.
*/
- void OnPolicyDecisionRequest(std::shared_ptr<Dali::WebEnginePolicyDecision> decision);
+ void OnResponsePolicyDecided(std::shared_ptr<Dali::WebEnginePolicyDecision> decision);
/**
* @brief Callback function to be called when certificate need be confirmed.
Dali::Toolkit::WebView::WebViewFrameRenderedSignalType mFrameRenderedSignal;
Dali::Toolkit::WebView::WebViewRequestInterceptorSignalType mRequestInterceptorSignal;
Dali::Toolkit::WebView::WebViewConsoleMessageSignalType mConsoleMessageSignal;
- Dali::Toolkit::WebView::WebViewPolicyDecisionSignalType mPolicyDecisionSignal;
+ Dali::Toolkit::WebView::WebViewResponsePolicyDecisionSignalType mResponsePolicyDecisionSignal;
Dali::Toolkit::WebView::WebViewCertificateSignalType mCertificateConfirmSignal;
Dali::Toolkit::WebView::WebViewCertificateSignalType mSslCertificateChangedSignal;
Dali::Toolkit::WebView::WebViewHttpAuthHandlerSignalType mHttpAuthHandlerSignal;
--- /dev/null
+/*
+ * Copyright 2012 Google, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the \"License\");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an \"AS IS\" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Google Author(s): Behdad Esfahbod, Maysum Panju
+ */
+
+
+#ifndef GLYPHY_INFINITY
+#define GLYPHY_INFINITY 1e9
+#endif
+#ifndef GLYPHY_EPSILON
+#define GLYPHY_EPSILON 1e-5
+#endif
+
+#ifndef GLYPHY_RGBA
+#ifdef GLYPHY_BGRA
+#define GLYPHY_RGBA(v) glyphy_bgra (v)
+#else
+#define GLYPHY_RGBA(v) glyphy_rgba (v)
+#endif
+#endif
+
+vec4 glyphy_rgba (const vec4 v)
+{
+ return v.rgba;
+}
+
+vec4 glyphy_bgra (const vec4 v)
+{
+ return v.bgra;
+}
+
+struct glyphy_arc_t
+{
+ vec2 p0;
+ vec2 p1;
+ float d;
+};
+
+struct glyphy_arc_endpoint_t
+{
+ /* Second arc endpoint */
+ vec2 p;
+ /* Infinity if this endpoint does not form an arc with the previous
+ * endpoint. Ie. a \"move_to\". Test with glyphy_isinf().
+ * Arc depth otherwise. */
+ float d;
+};
+
+struct glyphy_arc_list_t
+{
+ /* Number of endpoints in the list.
+ * Will be zero if we're far away inside or outside, in which case side is set.
+ * Will be -1 if this arc-list encodes a single line, in which case line_* are set. */
+ int num_endpoints;
+
+ /* If num_endpoints is zero, this specifies whether we are inside (-1)
+ * or outside (+1). Otherwise we're unsure (0). */
+ int side;
+ /* Offset to the arc-endpoints from the beginning of the glyph blob */
+ int offset;
+
+ /* A single line is all we care about. It's right here. */
+ float line_angle;
+ float line_distance; /* From nominal glyph center */
+};
+
+bool glyphy_isinf (const float v)
+{
+ return abs (v) >= GLYPHY_INFINITY * .5;
+}
+
+bool glyphy_iszero (const float v)
+{
+ return abs (v) <= GLYPHY_EPSILON * 2.;
+}
+
+vec2 glyphy_ortho (const vec2 v)
+{
+ return vec2 (-v.y, v.x);
+}
+
+int glyphy_float_to_byte (const float v)
+{
+ return int (v * (256. - GLYPHY_EPSILON));
+}
+
+ivec4 glyphy_vec4_to_bytes (const vec4 v)
+{
+ return ivec4 (v * (256. - GLYPHY_EPSILON));
+}
+
+ivec2 glyphy_float_to_two_nimbles (const float v)
+{
+ int f = glyphy_float_to_byte (v);
+ return ivec2 (f / 16, int(mod (float(f), 16.)));
+}
+
+/* returns tan (2 * atan (d)) */
+float glyphy_tan2atan (const float d)
+{
+ return 2. * d / (1. - d * d);
+}
+
+glyphy_arc_endpoint_t glyphy_arc_endpoint_decode(const vec4 v, const ivec2 nominal_size)
+{
+ vec2 p = (vec2 (glyphy_float_to_two_nimbles (v.a)) + v.gb) / 16.;
+ float d = v.r;
+ if (d == 0.)
+ d = GLYPHY_INFINITY;
+ else
+#define GLYPHY_MAX_D .5
+ d = float(glyphy_float_to_byte (d) - 128) * GLYPHY_MAX_D / 127.;
+#undef GLYPHY_MAX_D
+ return glyphy_arc_endpoint_t (p * vec2(nominal_size), d);
+}
+
+vec2 glyphy_arc_center (const glyphy_arc_t a)
+{
+ return mix (a.p0, a.p1, .5) +
+ glyphy_ortho (a.p1 - a.p0) / (2. * glyphy_tan2atan (a.d));
+}
+
+bool glyphy_arc_wedge_contains (const glyphy_arc_t a, const vec2 p)
+{
+ float d2 = glyphy_tan2atan (a.d);
+ return dot (p - a.p0, (a.p1 - a.p0) * mat2(1, d2, -d2, 1)) >= 0. &&
+ dot (p - a.p1, (a.p1 - a.p0) * mat2(1, -d2, d2, 1)) <= 0.;
+}
+
+float glyphy_arc_wedge_signed_dist_shallow (const glyphy_arc_t a, const vec2 p)
+{
+ vec2 v = normalize (a.p1 - a.p0);
+ float line_d = dot (p - a.p0, glyphy_ortho (v));
+ if (a.d == 0.)
+ return line_d;
+
+ float d0 = dot ((p - a.p0), v);
+ if (d0 < 0.)
+ return sign (line_d) * distance (p, a.p0);
+ float d1 = dot ((a.p1 - p), v);
+ if (d1 < 0.)
+ return sign (line_d) * distance (p, a.p1);
+ float r = 2. * a.d * (d0 * d1) / (d0 + d1);
+ if (r * line_d > 0.)
+ return sign (line_d) * min (abs (line_d + r), min (distance (p, a.p0), distance (p, a.p1)));
+ return line_d + r;
+}
+
+float glyphy_arc_wedge_signed_dist (const glyphy_arc_t a, const vec2 p)
+{
+ if (abs (a.d) <= .03)
+ return glyphy_arc_wedge_signed_dist_shallow (a, p);
+ vec2 c = glyphy_arc_center (a);
+ return sign (a.d) * (distance (a.p0, c) - distance (p, c));
+}
+
+float glyphy_arc_extended_dist (const glyphy_arc_t a, const vec2 p)
+{
+ /* Note: this doesn't handle points inside the wedge. */
+ vec2 m = mix (a.p0, a.p1, .5);
+ float d2 = glyphy_tan2atan (a.d);
+ if (dot (p - m, a.p1 - m) < 0.)
+ return dot (p - a.p0, normalize ((a.p1 - a.p0) * mat2(+d2, -1, +1, +d2)));
+ else
+ return dot (p - a.p1, normalize ((a.p1 - a.p0) * mat2(-d2, -1, +1, -d2)));
+}
+
+int glyphy_arc_list_offset (const vec2 p, const ivec2 nominal_size)
+{
+ ivec2 cell = ivec2 (clamp (floor (p), vec2 (0.,0.), vec2(nominal_size - 1)));
+ return cell.y * nominal_size.x + cell.x;
+}
+
+glyphy_arc_list_t glyphy_arc_list_decode (const vec4 v, const ivec2 nominal_size)
+{
+ glyphy_arc_list_t l;
+ ivec4 iv = glyphy_vec4_to_bytes (v);
+ l.side = 0; /* unsure */
+ if (iv.r == 0)
+ { /* arc-list encoded */
+ l.offset = (iv.g * 256) + iv.b;
+ l.num_endpoints = iv.a;
+ if (l.num_endpoints == 255)
+ {
+ l.num_endpoints = 0;
+ l.side = -1;
+ }
+ else if (l.num_endpoints == 0)
+ l.side = +1;
+ }
+ else
+ { /* single line encoded */
+ l.num_endpoints = -1;
+ l.line_distance = ( float(iv.r)/32. + 0.01*float(iv.g)/82.0 - 6.) * max (float (nominal_size.x), float (nominal_size.y));
+ l.line_angle = ( -float(iv.b)/40.74 - float( iv.a )*0.0001 )-3.142;
+ }
+ return l;
+}
--- /dev/null
+/*
+ * Copyright 2012 Google, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the \"License\");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an \"AS IS\" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Google Author(s): Behdad Esfahbod, Maysum Panju
+ */
+
+#ifndef GLYPHY_TEXTURE1D_FUNC
+#define GLYPHY_TEXTURE1D_FUNC glyphy_texture1D_func
+#endif
+#ifndef GLYPHY_TEXTURE1D_EXTRA_DECLS
+#define GLYPHY_TEXTURE1D_EXTRA_DECLS
+#endif
+#ifndef GLYPHY_TEXTURE1D_EXTRA_ARGS
+#define GLYPHY_TEXTURE1D_EXTRA_ARGS
+#endif
+
+#ifndef GLYPHY_SDF_TEXTURE1D_FUNC
+#define GLYPHY_SDF_TEXTURE1D_FUNC GLYPHY_TEXTURE1D_FUNC
+#endif
+#ifndef GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS
+#define GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS GLYPHY_TEXTURE1D_EXTRA_DECLS
+#endif
+#ifndef GLYPHY_SDF_TEXTURE1D_EXTRA_ARGS
+#define GLYPHY_SDF_TEXTURE1D_EXTRA_ARGS GLYPHY_TEXTURE1D_EXTRA_ARGS
+#endif
+#ifndef GLYPHY_SDF_TEXTURE1D
+#define GLYPHY_SDF_TEXTURE1D(offset) GLYPHY_RGBA(GLYPHY_SDF_TEXTURE1D_FUNC (offset GLYPHY_TEXTURE1D_EXTRA_ARGS))
+#endif
+
+#ifndef GLYPHY_MAX_NUM_ENDPOINTS
+#define GLYPHY_MAX_NUM_ENDPOINTS 32
+#endif
+
+glyphy_arc_list_t glyphy_arc_list (const vec2 p, const ivec2 nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS)
+{
+ int cell_offset = glyphy_arc_list_offset (p, nominal_size);
+ vec4 arc_list_data = GLYPHY_SDF_TEXTURE1D (cell_offset);
+ return glyphy_arc_list_decode (arc_list_data, nominal_size);
+}
+
+float glyphy_sdf (const vec2 p, const ivec2 nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS)
+{
+ glyphy_arc_list_t arc_list = glyphy_arc_list (p, nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_ARGS);
+
+ /* Short-circuits */
+ if (arc_list.num_endpoints == 0)
+ {
+ /* far-away cell */
+ return GLYPHY_INFINITY * float(arc_list.side);
+ }
+ if (arc_list.num_endpoints == -1)
+ {
+ /* single-line */
+ float angle = arc_list.line_angle;
+ vec2 n = vec2 (cos (angle), sin (angle));
+ return dot (p - (vec2(nominal_size) * .5), n) - arc_list.line_distance;
+ }
+
+ float side = float(arc_list.side);
+ float min_dist = GLYPHY_INFINITY;
+ glyphy_arc_t closest_arc;
+
+ glyphy_arc_endpoint_t endpoint_prev, endpoint;
+ endpoint_prev = glyphy_arc_endpoint_decode (GLYPHY_SDF_TEXTURE1D (arc_list.offset), nominal_size);
+ for (int i = 1; i < GLYPHY_MAX_NUM_ENDPOINTS; i++)
+ {
+ if (i >= arc_list.num_endpoints)
+ {
+ break;
+ }
+ endpoint = glyphy_arc_endpoint_decode (GLYPHY_SDF_TEXTURE1D (arc_list.offset + i), nominal_size);
+ glyphy_arc_t a = glyphy_arc_t (endpoint_prev.p, endpoint.p, endpoint.d);
+ endpoint_prev = endpoint;
+ if (glyphy_isinf (a.d)) continue;
+
+ if (glyphy_arc_wedge_contains (a, p))
+ {
+ float sdist = glyphy_arc_wedge_signed_dist (a, p);
+ float udist = abs (sdist) * (1. - GLYPHY_EPSILON);
+ if (udist <= min_dist)
+ {
+ min_dist = udist;
+ side = sign (sdist);
+ }
+ }
+ else
+ {
+ float udist = min (distance (p, a.p0), distance (p, a.p1));
+ if (udist < min_dist)
+ {
+ min_dist = udist;
+ side = 0.; /* unsure */
+ closest_arc = a;
+ }
+ else if (side == 0. && udist == min_dist)
+ {
+ /* If this new distance is the same as the current minimum,
+ * compare extended distances. Take the sign from the arc
+ * with larger extended distance. */
+ float old_ext_dist = glyphy_arc_extended_dist (closest_arc, p);
+ float new_ext_dist = glyphy_arc_extended_dist (a, p);
+
+ float ext_dist = abs (new_ext_dist) <= abs (old_ext_dist) ?
+ old_ext_dist : new_ext_dist;
+
+#ifdef GLYPHY_SDF_PSEUDO_DISTANCE
+ /* For emboldening and stuff: */
+ min_dist = abs (ext_dist);
+#endif
+ side = sign (ext_dist);
+ }
+ }
+ }
+
+ if (side == 0.)
+ {
+ // Technically speaking this should not happen, but it does. So try to fix it.
+ float ext_dist = glyphy_arc_extended_dist (closest_arc, p);
+ side = sign (ext_dist);
+ }
+
+ return min_dist * side;
+}
+
+float glyphy_point_dist (const vec2 p, const ivec2 nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS)
+{
+ glyphy_arc_list_t arc_list = glyphy_arc_list (p, nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_ARGS);
+
+ float side = float(arc_list.side);
+ float min_dist = GLYPHY_INFINITY;
+
+ if (arc_list.num_endpoints == 0)
+ return min_dist;
+
+ glyphy_arc_endpoint_t endpoint;
+ for (int i = 0; i < GLYPHY_MAX_NUM_ENDPOINTS; i++)
+ {
+ if (i >= arc_list.num_endpoints)
+ {
+ break;
+ }
+ endpoint = glyphy_arc_endpoint_decode (GLYPHY_SDF_TEXTURE1D (arc_list.offset + i), nominal_size);
+ if (glyphy_isinf (endpoint.d)) continue;
+ min_dist = min (min_dist, distance (p, endpoint.p));
+ }
+
+ return min_dist;
+}
--- /dev/null
+#extension GL_OES_standard_derivatives : enable
+precision highp float;
+precision highp int;
--- /dev/null
+struct Material
+{
+ mediump float mOpacity;
+ mediump float mShininess;
+ lowp vec4 mAmbient;
+ lowp vec4 mDiffuse;
+ lowp vec4 mSpecular;
+ lowp vec4 mEmissive;
+};
+
+uniform sampler2D sTexture;
+uniform sampler2D sOpacityTexture;
+uniform sampler2D sNormalMapTexture;
+uniform sampler2D sEffect;
+varying mediump vec2 vTexCoord;
+uniform Material uMaterial;
+uniform lowp vec4 uColor;
+varying highp vec4 vVertex;
+varying highp vec3 vNormal;
+varying mediump vec4 vColor;
+uniform vec4 u_atlas_info;
+
+#define GLYPHY_TEXTURE1D_EXTRA_DECLS , sampler2D _tex, ivec4 _atlas_info, ivec2 _atlas_pos
+#define GLYPHY_TEXTURE1D_EXTRA_ARGS , _tex, _atlas_info, _atlas_pos
+#define GLYPHY_DEMO_EXTRA_ARGS , sTexture, uu_atlas_info, gi.atlas_pos
+
+vec4 glyphy_texture1D_func (int offset GLYPHY_TEXTURE1D_EXTRA_DECLS)
+{
+ ivec2 item_geom = _atlas_info.zw;
+ vec2 pos = (vec2 (_atlas_pos.xy * item_geom +
+ ivec2 (mod (float (offset), float (item_geom.x)), offset / item_geom.x)) +
+ + vec2 (.5, .5)) / vec2(_atlas_info.xy);
+ return texture2D (_tex, pos);
+}
--- /dev/null
+uniform float u_contrast;
+uniform float u_gamma_adjust;
+uniform float u_outline_thickness;
+uniform float u_outline;
+uniform float u_boldness;
+
+varying vec4 v_glyph;
+
+#define SQRT2_2 0.70711 /* 1 / sqrt(2.) */
+#define SQRT2 1.41421
+
+struct glyph_info_t
+{
+ ivec2 nominal_size;
+ ivec2 atlas_pos;
+};
+
+glyph_info_t glyph_info_decode (vec4 v)
+{
+ glyph_info_t gi;
+ gi.nominal_size = (ivec2 (mod (v.zw, 256.)) + 2) / 4;
+ gi.atlas_pos = ivec2 (v_glyph.zw) / 256;
+ return gi;
+}
+
+
+float antialias (float d)
+{
+ return smoothstep (-.75, +.75, d);
+}
+
+vec4 source_over (const vec4 src, const vec4 dst)
+{
+ // http://dev.w3.org/fxtf/compositing-1/#porterduffcompositingoperators_srcover
+ float alpha = src.a + (dst.a * (1. - src.a));
+ return vec4 (((src.rgb * src.a) + (dst.rgb * dst.a * (1. - src.a))) / alpha, alpha);
+}
+
+void main()
+{
+ vec2 p = v_glyph.xy;
+ glyph_info_t gi = glyph_info_decode (v_glyph);
+
+ /* isotropic antialiasing */
+ vec2 dpdx = dFdx (p);
+ vec2 dpdy = dFdy (p);
+ float m = length (vec2 (length (dpdx), length (dpdy))) * SQRT2_2;
+
+ vec4 color = vec4( vColor.rgb * uColor.rgb, vColor.a * uColor.a );
+
+ ivec4 uu_atlas_info = ivec4( u_atlas_info );
+ float gsdist = glyphy_sdf (p, gi.nominal_size GLYPHY_DEMO_EXTRA_ARGS);
+ float sdist = gsdist / m * u_contrast;
+
+ sdist -= u_boldness * 10.;
+ if ( glyphy_iszero( u_outline ) )
+ sdist = abs (sdist) - u_outline_thickness * .5;
+ if (sdist > 1.)
+ discard;
+ float alpha = antialias (-sdist);
+ if (u_gamma_adjust != 1.)
+ alpha = pow (alpha, 1./u_gamma_adjust);
+ color = vec4 (color.rgb,color.a * alpha);
+
+ gl_FragColor = color;
+}
--- /dev/null
+uniform mediump mat4 uProjection;
+uniform mediump mat4 uModelView;
+uniform mediump mat4 uMvpMatrix;
+uniform bool uTextureMapped;
+uniform mediump vec4 uCustomTextureCoords;
+attribute highp vec2 aTexCoord;
+varying mediump vec2 vTexCoord;
+uniform mat3 uModelViewIT;
+attribute mediump vec3 aNormal;
+varying mediump vec3 vNormal;
+attribute mediump vec2 aPosition;
+varying mediump vec4 vVertex;
+attribute mediump vec4 aColor;
+varying mediump vec4 vColor;
+varying vec4 v_glyph;
+
+vec4 glyph_vertex_transcode (vec2 v)
+{
+ ivec2 g = ivec2 (v);
+ ivec2 corner = ivec2 (mod (v, 2.));
+ g /= 2;
+ ivec2 nominal_size = ivec2 (mod (vec2(g), 64.));
+ return vec4 (corner * nominal_size, g * 4);
+}
+
+void main()
+{
+ gl_Position = uMvpMatrix * vec4 (aPosition, 0.0, 1.0);
+ v_glyph = glyph_vertex_transcode (aTexCoord);
+ vColor = aColor;
+}
\ No newline at end of file
+++ /dev/null
-static const char* glyphy_common_glsl =
- "/*\n"
- " * Copyright 2012 Google, Inc. All Rights Reserved.\n"
- " *\n"
- " * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
- " * you may not use this file except in compliance with the License.\n"
- " * You may obtain a copy of the License at\n"
- " *\n"
- " * http://www.apache.org/licenses/LICENSE-2.0\n"
- " *\n"
- " * Unless required by applicable law or agreed to in writing, software\n"
- " * distributed under the License is distributed on an \"AS IS\" BASIS,\n"
- " * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
- " * See the License for the specific language governing permissions and\n"
- " * limitations under the License.\n"
- " *\n"
- " * Google Author(s): Behdad Esfahbod, Maysum Panju\n"
- " */\n"
- "\n"
- "\n"
- "#ifndef GLYPHY_INFINITY\n"
- "# define GLYPHY_INFINITY 1e9\n"
- "#endif\n"
- "#ifndef GLYPHY_EPSILON\n"
- "# define GLYPHY_EPSILON 1e-5\n"
- "#endif\n"
- "\n"
- "#ifndef GLYPHY_RGBA\n"
- "# ifdef GLYPHY_BGRA\n"
- "# define GLYPHY_RGBA(v) glyphy_bgra (v)\n"
- "# else\n"
- "# define GLYPHY_RGBA(v) glyphy_rgba (v)\n"
- "# endif\n"
- "#endif\n"
- "\n"
- "vec4\n"
- "glyphy_rgba (const vec4 v)\n"
- "{\n"
- " return v.rgba;\n"
- "}\n"
- "\n"
- "vec4\n"
- "glyphy_bgra (const vec4 v)\n"
- "{\n"
- " return v.bgra;\n"
- "}\n"
- "\n"
- "\n"
- "struct glyphy_arc_t {\n"
- " vec2 p0;\n"
- " vec2 p1;\n"
- " float d;\n"
- "};\n"
- "\n"
- "struct glyphy_arc_endpoint_t {\n"
- " /* Second arc endpoint */\n"
- " vec2 p;\n"
- " /* Infinity if this endpoint does not form an arc with the previous\n"
- " * endpoint. Ie. a \"move_to\". Test with glyphy_isinf().\n"
- " * Arc depth otherwise. */\n"
- " float d;\n"
- "};\n"
- "\n"
- "struct glyphy_arc_list_t {\n"
- " /* Number of endpoints in the list.\n"
- " * Will be zero if we're far away inside or outside, in which case side is set.\n"
- " * Will be -1 if this arc-list encodes a single line, in which case line_* are set. */\n"
- " int num_endpoints;\n"
- "\n"
- " /* If num_endpoints is zero, this specifies whether we are inside (-1)\n"
- " * or outside (+1). Otherwise we're unsure (0). */\n"
- " int side;\n"
- " /* Offset to the arc-endpoints from the beginning of the glyph blob */\n"
- " int offset;\n"
- "\n"
- " /* A single line is all we care about. It's right here. */\n"
- " float line_angle;\n"
- " float line_distance; /* From nominal glyph center */\n"
- "};\n"
- "\n"
- "bool\n"
- "glyphy_isinf (const float v)\n"
- "{\n"
- " return abs (v) >= GLYPHY_INFINITY * .5;\n"
- "}\n"
- "\n"
- "bool\n"
- "glyphy_iszero (const float v)\n"
- "{\n"
- " return abs (v) <= GLYPHY_EPSILON * 2.;\n"
- "}\n"
- "\n"
- "vec2\n"
- "glyphy_ortho (const vec2 v)\n"
- "{\n"
- " return vec2 (-v.y, v.x);\n"
- "}\n"
- "\n"
- "int\n"
- "glyphy_float_to_byte (const float v)\n"
- "{\n"
- " return int (v * (256. - GLYPHY_EPSILON));\n"
- "}\n"
- "\n"
- "ivec4\n"
- "glyphy_vec4_to_bytes (const vec4 v)\n"
- "{\n"
- " return ivec4 (v * (256. - GLYPHY_EPSILON));\n"
- "}\n"
- "\n"
- "ivec2\n"
- "glyphy_float_to_two_nimbles (const float v)\n"
- "{\n"
- " int f = glyphy_float_to_byte (v);\n"
- " return ivec2 (f / 16, int(mod (float(f), 16.)));\n"
- "}\n"
- "\n"
- "/* returns tan (2 * atan (d)) */\n"
- "float\n"
- "glyphy_tan2atan (const float d)\n"
- "{\n"
- " return 2. * d / (1. - d * d);\n"
- "}\n"
- "\n"
- "glyphy_arc_endpoint_t\n"
- "glyphy_arc_endpoint_decode (const vec4 v, const ivec2 nominal_size)\n"
- "{\n"
- " vec2 p = (vec2 (glyphy_float_to_two_nimbles (v.a)) + v.gb) / 16.;\n"
- " float d = v.r;\n"
- " if (d == 0.)\n"
- " d = GLYPHY_INFINITY;\n"
- " else\n"
- "#define GLYPHY_MAX_D .5\n"
- " d = float(glyphy_float_to_byte (d) - 128) * GLYPHY_MAX_D / 127.;\n"
- "#undef GLYPHY_MAX_D\n"
- " return glyphy_arc_endpoint_t (p * vec2(nominal_size), d);\n"
- "}\n"
- "\n"
- "vec2\n"
- "glyphy_arc_center (const glyphy_arc_t a)\n"
- "{\n"
- " return mix (a.p0, a.p1, .5) +\n"
- " glyphy_ortho (a.p1 - a.p0) / (2. * glyphy_tan2atan (a.d));\n"
- "}\n"
- "\n"
- "bool\n"
- "glyphy_arc_wedge_contains (const glyphy_arc_t a, const vec2 p)\n"
- "{\n"
- " float d2 = glyphy_tan2atan (a.d);\n"
- " return dot (p - a.p0, (a.p1 - a.p0) * mat2(1, d2, -d2, 1)) >= 0. &&\n"
- " dot (p - a.p1, (a.p1 - a.p0) * mat2(1, -d2, d2, 1)) <= 0.;\n"
- "}\n"
- "\n"
- "float\n"
- "glyphy_arc_wedge_signed_dist_shallow (const glyphy_arc_t a, const vec2 p)\n"
- "{\n"
- " vec2 v = normalize (a.p1 - a.p0);\n"
- " float line_d = dot (p - a.p0, glyphy_ortho (v));\n"
- " if (a.d == 0.)\n"
- " return line_d;\n"
- "\n"
- " float d0 = dot ((p - a.p0), v);\n"
- " if (d0 < 0.)\n"
- " return sign (line_d) * distance (p, a.p0);\n"
- " float d1 = dot ((a.p1 - p), v);\n"
- " if (d1 < 0.)\n"
- " return sign (line_d) * distance (p, a.p1);\n"
- " float r = 2. * a.d * (d0 * d1) / (d0 + d1);\n"
- " if (r * line_d > 0.)\n"
- " return sign (line_d) * min (abs (line_d + r), min (distance (p, a.p0), distance (p, a.p1)));\n"
- " return line_d + r;\n"
- "}\n"
- "\n"
- "float\n"
- "glyphy_arc_wedge_signed_dist (const glyphy_arc_t a, const vec2 p)\n"
- "{\n"
- " if (abs (a.d) <= .03)\n"
- " return glyphy_arc_wedge_signed_dist_shallow (a, p);\n"
- " vec2 c = glyphy_arc_center (a);\n"
- " return sign (a.d) * (distance (a.p0, c) - distance (p, c));\n"
- "}\n"
- "\n"
- "float\n"
- "glyphy_arc_extended_dist (const glyphy_arc_t a, const vec2 p)\n"
- "{\n"
- " /* Note: this doesn't handle points inside the wedge. */\n"
- " vec2 m = mix (a.p0, a.p1, .5);\n"
- " float d2 = glyphy_tan2atan (a.d);\n"
- " if (dot (p - m, a.p1 - m) < 0.)\n"
- " return dot (p - a.p0, normalize ((a.p1 - a.p0) * mat2(+d2, -1, +1, +d2)));\n"
- " else\n"
- " return dot (p - a.p1, normalize ((a.p1 - a.p0) * mat2(-d2, -1, +1, -d2)));\n"
- "}\n"
- "\n"
- "int\n"
- "glyphy_arc_list_offset (const vec2 p, const ivec2 nominal_size)\n"
- "{\n"
- " ivec2 cell = ivec2 (clamp (floor (p), vec2 (0.,0.), vec2(nominal_size - 1)));\n"
- " return cell.y * nominal_size.x + cell.x;\n"
- "}\n"
- "\n"
- "glyphy_arc_list_t\n"
- "glyphy_arc_list_decode (const vec4 v, const ivec2 nominal_size)\n"
- "{\n"
- " glyphy_arc_list_t l;\n"
- " ivec4 iv = glyphy_vec4_to_bytes (v);\n"
- " l.side = 0; /* unsure */\n"
- " if (iv.r == 0) { /* arc-list encoded */\n"
- " l.offset = (iv.g * 256) + iv.b;\n"
- " l.num_endpoints = iv.a;\n"
- " if (l.num_endpoints == 255) {\n"
- " l.num_endpoints = 0;\n"
- " l.side = -1;\n"
- " } else if (l.num_endpoints == 0)\n"
- " l.side = +1;\n"
- " } else { /* single line encoded */\n"
- " l.num_endpoints = -1;\n"
- /*" l.line_distance = float(((iv.r - 128) * 256 + iv.g) - 0x4000) / float (0x1FFF)\n"
- " * max (float (nominal_size.x), float (nominal_size.y));\n"
- " l.line_angle = float(-((iv.b * 256 + iv.a) - 0x8000)) / float (0x7FFF) * 3.14159265358979;\n"*/
- /*" l.line_distance = float(((iv.r - 128) * 256 + iv.g) - 16384) / 8191.0 \n"
- " * max (float (nominal_size.x), float (nominal_size.y));\n"
- " l.line_angle = float(-((iv.b * 256 + iv.a) - 32768)) / 32767. * 3.14159;\n"*/
- " l.line_distance = ( float(iv.r)/32. + 0.01*float(iv.g)/82.0 - 6.) \n"
- " * max (float (nominal_size.x), float (nominal_size.y));\n"
- " l.line_angle = ( -float(iv.b)/40.74 - float( iv.a )*0.0001 )-3.142;\n"
- " }\n"
- " return l;\n"
- "}\n";
+++ /dev/null
-static const char* glyphy_sdf_glsl =
- "/*\n"
- " * Copyright 2012 Google, Inc. All Rights Reserved.\n"
- " *\n"
- " * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
- " * you may not use this file except in compliance with the License.\n"
- " * You may obtain a copy of the License at\n"
- " *\n"
- " * http://www.apache.org/licenses/LICENSE-2.0\n"
- " *\n"
- " * Unless required by applicable law or agreed to in writing, software\n"
- " * distributed under the License is distributed on an \"AS IS\" BASIS,\n"
- " * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
- " * See the License for the specific language governing permissions and\n"
- " * limitations under the License.\n"
- " *\n"
- " * Google Author(s): Behdad Esfahbod, Maysum Panju\n"
- " */\n"
- "\n"
- "#ifndef GLYPHY_TEXTURE1D_FUNC\n"
- "#define GLYPHY_TEXTURE1D_FUNC glyphy_texture1D_func\n"
- "#endif\n"
- "#ifndef GLYPHY_TEXTURE1D_EXTRA_DECLS\n"
- "#define GLYPHY_TEXTURE1D_EXTRA_DECLS\n"
- "#endif\n"
- "#ifndef GLYPHY_TEXTURE1D_EXTRA_ARGS\n"
- "#define GLYPHY_TEXTURE1D_EXTRA_ARGS\n"
- "#endif\n"
- "\n"
- "#ifndef GLYPHY_SDF_TEXTURE1D_FUNC\n"
- "#define GLYPHY_SDF_TEXTURE1D_FUNC GLYPHY_TEXTURE1D_FUNC\n"
- "#endif\n"
- "#ifndef GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS\n"
- "#define GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS GLYPHY_TEXTURE1D_EXTRA_DECLS\n"
- "#endif\n"
- "#ifndef GLYPHY_SDF_TEXTURE1D_EXTRA_ARGS\n"
- "#define GLYPHY_SDF_TEXTURE1D_EXTRA_ARGS GLYPHY_TEXTURE1D_EXTRA_ARGS\n"
- "#endif\n"
- "#ifndef GLYPHY_SDF_TEXTURE1D\n"
- "#define GLYPHY_SDF_TEXTURE1D(offset) GLYPHY_RGBA(GLYPHY_SDF_TEXTURE1D_FUNC (offset GLYPHY_TEXTURE1D_EXTRA_ARGS))\n"
- "#endif\n"
- "\n"
- "#ifndef GLYPHY_MAX_NUM_ENDPOINTS\n"
- "#define GLYPHY_MAX_NUM_ENDPOINTS 32\n"
- "#endif\n"
- "\n"
- "glyphy_arc_list_t\n"
- "glyphy_arc_list (const vec2 p, const ivec2 nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS)\n"
- "{\n"
- " int cell_offset = glyphy_arc_list_offset (p, nominal_size);\n"
- " vec4 arc_list_data = GLYPHY_SDF_TEXTURE1D (cell_offset);\n"
- " return glyphy_arc_list_decode (arc_list_data, nominal_size);\n"
- "}\n"
- "\n"
- "float\n"
- "glyphy_sdf (const vec2 p, const ivec2 nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS)\n"
- "{\n"
- " glyphy_arc_list_t arc_list = glyphy_arc_list (p, nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_ARGS);\n"
- "\n"
- " /* Short-circuits */\n"
- " if (arc_list.num_endpoints == 0) {\n"
- " /* far-away cell */\n"
- " return GLYPHY_INFINITY * float(arc_list.side);\n"
- " } if (arc_list.num_endpoints == -1) {\n"
- " /* single-line */\n"
- " float angle = arc_list.line_angle;\n"
- " vec2 n = vec2 (cos (angle), sin (angle));\n"
- " return dot (p - (vec2(nominal_size) * .5), n) - arc_list.line_distance;\n"
- " }\n"
- "\n"
- " float side = float(arc_list.side);\n"
- " float min_dist = GLYPHY_INFINITY;\n"
- " glyphy_arc_t closest_arc;\n"
- "\n"
- " glyphy_arc_endpoint_t endpoint_prev, endpoint;\n"
- " endpoint_prev = glyphy_arc_endpoint_decode (GLYPHY_SDF_TEXTURE1D (arc_list.offset), nominal_size);\n"
- " for (int i = 1; i < GLYPHY_MAX_NUM_ENDPOINTS; i++)\n"
- " {\n"
- " if (i >= arc_list.num_endpoints) {\n"
- " break;\n"
- " }\n"
- " endpoint = glyphy_arc_endpoint_decode (GLYPHY_SDF_TEXTURE1D (arc_list.offset + i), nominal_size);\n"
- " glyphy_arc_t a = glyphy_arc_t (endpoint_prev.p, endpoint.p, endpoint.d);\n"
- " endpoint_prev = endpoint;\n"
- " if (glyphy_isinf (a.d)) continue;\n"
- "\n"
- " if (glyphy_arc_wedge_contains (a, p))\n"
- " {\n"
- " float sdist = glyphy_arc_wedge_signed_dist (a, p);\n"
- " float udist = abs (sdist) * (1. - GLYPHY_EPSILON);\n"
- " if (udist <= min_dist) {\n"
- " min_dist = udist;\n"
- " side = sign (sdist);"
- " }\n"
- " } else {\n"
- " float udist = min (distance (p, a.p0), distance (p, a.p1));\n"
- " if (udist < min_dist) {\n"
- " min_dist = udist;\n"
- " side = 0.; /* unsure */\n"
- " closest_arc = a;\n"
- " } else if (side == 0. && udist == min_dist) {\n"
- " /* If this new distance is the same as the current minimum,\n"
- " * compare extended distances. Take the sign from the arc\n"
- " * with larger extended distance. */\n"
- " float old_ext_dist = glyphy_arc_extended_dist (closest_arc, p);\n"
- " float new_ext_dist = glyphy_arc_extended_dist (a, p);\n"
- "\n"
- " float ext_dist = abs (new_ext_dist) <= abs (old_ext_dist) ?\n"
- " old_ext_dist : new_ext_dist;\n"
- "\n"
- "#ifdef GLYPHY_SDF_PSEUDO_DISTANCE\n"
- " /* For emboldening and stuff: */\n"
- " min_dist = abs (ext_dist);\n"
- "#endif\n"
- " side = sign (ext_dist);\n"
- " }\n"
- " }\n"
- " }\n"
- "\n"
- " if (side == 0.) {\n"
- " // Technically speaking this should not happen, but it does. So try to fix it.\n"
- " float ext_dist = glyphy_arc_extended_dist (closest_arc, p);\n"
- " side = sign (ext_dist);\n"
- " }\n"
- "\n"
- " return min_dist * side;\n"
- "}\n"
- "\n"
- "float\n"
- "glyphy_point_dist (const vec2 p, const ivec2 nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_DECLS)\n"
- "{\n"
- " glyphy_arc_list_t arc_list = glyphy_arc_list (p, nominal_size GLYPHY_SDF_TEXTURE1D_EXTRA_ARGS);\n"
- "\n"
- " float side = float(arc_list.side);\n"
- " float min_dist = GLYPHY_INFINITY;\n"
- "\n"
- " if (arc_list.num_endpoints == 0)\n"
- " return min_dist;\n"
- "\n"
- " glyphy_arc_endpoint_t endpoint;\n"
- " for (int i = 0; i < GLYPHY_MAX_NUM_ENDPOINTS; i++)\n"
- " {\n"
- " if (i >= arc_list.num_endpoints) {\n"
- " break;\n"
- " }\n"
- " endpoint = glyphy_arc_endpoint_decode (GLYPHY_SDF_TEXTURE1D (arc_list.offset + i), nominal_size);\n"
- " if (glyphy_isinf (endpoint.d)) continue;\n"
- " min_dist = min (min_dist, distance (p, endpoint.p));\n"
- " }\n"
- " return min_dist;\n"
- "}\n";
#include <sstream>
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/text/rendering/vector-based/glyphy-shader/glyphy-common-glsl.h>
-#include <dali-toolkit/internal/text/rendering/vector-based/glyphy-shader/glyphy-sdf-glsl.h>
+#include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
using namespace Dali;
-namespace
-{
-const char* const ENABLE_EXTENSION_PREFIX =
- "#extension GL_OES_standard_derivatives : enable\n"
- "precision highp float;\n"
- "precision highp int;\n";
-
-const char* const VERTEX_SHADER_MAIN =
- "uniform mediump mat4 uProjection;\n"
- "uniform mediump mat4 uModelView;\n"
- "uniform mediump mat4 uMvpMatrix;\n"
- "uniform bool uTextureMapped;\n"
- "uniform mediump vec4 uCustomTextureCoords;\n"
- "attribute highp vec2 aTexCoord;\n"
- "varying mediump vec2 vTexCoord;\n"
- "uniform mat3 uModelViewIT;\n"
- "attribute mediump vec3 aNormal;\n"
- "varying mediump vec3 vNormal;\n"
- "attribute mediump vec2 aPosition;\n"
- "varying mediump vec4 vVertex;\n"
- "attribute mediump vec4 aColor;\n"
- "varying mediump vec4 vColor;\n"
- "varying vec4 v_glyph;\n"
- "\n"
- "vec4\n"
- "glyph_vertex_transcode (vec2 v)\n"
- "{\n"
- " ivec2 g = ivec2 (v);\n"
- " ivec2 corner = ivec2 (mod (v, 2.));\n"
- " g /= 2;\n"
- " ivec2 nominal_size = ivec2 (mod (vec2(g), 64.));\n"
- " return vec4 (corner * nominal_size, g * 4);\n"
- "}\n"
- "\n"
- "void\n"
- "main()\n"
- "{\n"
- " gl_Position = uMvpMatrix * vec4 (aPosition, 0.0, 1.0);\n"
- " v_glyph = glyph_vertex_transcode (aTexCoord);\n"
- " vColor = aColor;\n"
- "}\n";
-
-const char* const FRAGMENT_SHADER_PREFIX =
- "struct Material\n"
- "{\n"
- " mediump float mOpacity;\n"
- " mediump float mShininess;\n"
- " lowp vec4 mAmbient;\n"
- " lowp vec4 mDiffuse;\n"
- " lowp vec4 mSpecular;\n"
- " lowp vec4 mEmissive;\n"
- "};\n"
- "uniform sampler2D sTexture;\n"
- "uniform sampler2D sOpacityTexture;\n"
- "uniform sampler2D sNormalMapTexture;\n"
- "uniform sampler2D sEffect;\n"
- "varying mediump vec2 vTexCoord;\n"
- "uniform Material uMaterial;\n"
- "uniform lowp vec4 uColor;\n"
- "varying highp vec4 vVertex;\n"
- "varying highp vec3 vNormal;\n"
- "varying mediump vec4 vColor;\n"
- "uniform vec4 u_atlas_info;\n"
- "\n"
- "#define GLYPHY_TEXTURE1D_EXTRA_DECLS , sampler2D _tex, ivec4 _atlas_info, ivec2 _atlas_pos\n"
- "#define GLYPHY_TEXTURE1D_EXTRA_ARGS , _tex, _atlas_info, _atlas_pos\n"
- "#define GLYPHY_DEMO_EXTRA_ARGS , sTexture, uu_atlas_info, gi.atlas_pos\n"
- "\n"
- "vec4\n"
- "glyphy_texture1D_func (int offset GLYPHY_TEXTURE1D_EXTRA_DECLS)\n"
- "{\n"
- " ivec2 item_geom = _atlas_info.zw;\n"
- " vec2 pos = (vec2 (_atlas_pos.xy * item_geom +\n"
- " ivec2 (mod (float (offset), float (item_geom.x)), offset / item_geom.x)) +\n"
- " + vec2 (.5, .5)) / vec2(_atlas_info.xy);\n"
- " return texture2D (_tex, pos);\n"
- "}\n";
-
-static const char* FRAGMENT_SHADER_MAIN =
- "uniform float u_contrast;\n"
- "uniform float u_gamma_adjust;\n"
- "uniform float u_outline_thickness;\n"
- "uniform float u_outline;\n"
- "uniform float u_boldness;\n"
- "\n"
- "varying vec4 v_glyph;\n"
- "\n"
- "\n"
- "#define SQRT2_2 0.70711 /* 1 / sqrt(2.) */\n"
- "#define SQRT2 1.41421\n"
- "\n"
- "struct glyph_info_t {\n"
- " ivec2 nominal_size;\n"
- " ivec2 atlas_pos;\n"
- "};\n"
- "\n"
- "glyph_info_t\n"
- "glyph_info_decode (vec4 v)\n"
- "{\n"
- " glyph_info_t gi;\n"
- " gi.nominal_size = (ivec2 (mod (v.zw, 256.)) + 2) / 4;\n"
- " gi.atlas_pos = ivec2 (v_glyph.zw) / 256;\n"
- " return gi;\n"
- "}\n"
- "\n"
- "\n"
- "float\n"
- "antialias (float d)\n"
- "{\n"
- " return smoothstep (-.75, +.75, d);\n"
- "}\n"
- "\n"
- "vec4\n"
- "source_over (const vec4 src, const vec4 dst)\n"
- "{\n"
- " // http://dev.w3.org/fxtf/compositing-1/#porterduffcompositingoperators_srcover\n"
- " float alpha = src.a + (dst.a * (1. - src.a));\n"
- " return vec4 (((src.rgb * src.a) + (dst.rgb * dst.a * (1. - src.a))) / alpha, alpha);\n"
- "}\n"
- "\n"
- "void\n"
- "main()\n"
- "{\n"
- " vec2 p = v_glyph.xy;\n"
- " glyph_info_t gi = glyph_info_decode (v_glyph);\n"
- "\n"
- " /* isotropic antialiasing */\n"
- " vec2 dpdx = dFdx (p);\n"
- " vec2 dpdy = dFdy (p);\n"
- " float m = length (vec2 (length (dpdx), length (dpdy))) * SQRT2_2;\n"
- "\n"
- " vec4 color = vec4( vColor.rgb * uColor.rgb, vColor.a * uColor.a );\n"
- "\n"
- " ivec4 uu_atlas_info = ivec4( u_atlas_info );"
- " float gsdist = glyphy_sdf (p, gi.nominal_size GLYPHY_DEMO_EXTRA_ARGS);\n"
- " float sdist = gsdist / m * u_contrast;\n"
- "\n"
- " sdist -= u_boldness * 10.;\n"
- " if ( glyphy_iszero( u_outline ) )\n"
- " sdist = abs (sdist) - u_outline_thickness * .5;\n"
- " if (sdist > 1.)\n"
- " discard;\n"
- " float alpha = antialias (-sdist);\n"
- " if (u_gamma_adjust != 1.)\n"
- " alpha = pow (alpha, 1./u_gamma_adjust);\n"
- " color = vec4 (color.rgb,color.a * alpha);\n"
- "\n"
- " gl_FragColor = color;\n"
- "}\n";
-
-} // namespace
-
namespace Dali
{
namespace Toolkit
std::ostringstream vertexShaderStringStream;
std::ostringstream fragmentShaderStringStream;
- vertexShaderStringStream << ENABLE_EXTENSION_PREFIX << VERTEX_SHADER_MAIN;
+ vertexShaderStringStream << SHADER_GLYPHY_SHADER_EXTENTION_PREFIX_DEF.data() << SHADER_GLYPHY_SHADER_MAIN_VERT.data();
- fragmentShaderStringStream << ENABLE_EXTENSION_PREFIX
- << FRAGMENT_SHADER_PREFIX
- << glyphy_common_glsl
+ fragmentShaderStringStream << SHADER_GLYPHY_SHADER_EXTENTION_PREFIX_DEF.data()
+ << SHADER_GLYPHY_SHADER_FRAGMENT_PREFIX_FRAG.data()
+ << SHADER_GLYPHY_COMMON_GLSL_SHADER_DEF.data()
<< "#define GLYPHY_SDF_PSEUDO_DISTANCE 1\n"
- << glyphy_sdf_glsl
- << FRAGMENT_SHADER_MAIN;
+ << SHADER_GLYPHY_SDF_GLSL_SHADER_DEF.data()
+ << SHADER_GLYPHY_SHADER_MAIN_FRAG.data();
Shader shaderEffectCustom = Shader::New(vertexShaderStringStream.str(),
fragmentShaderStringStream.str(),
break;
}
case VisualUrl::JSON:
+ case VisualUrl::RIVE:
{
visualPtr = AnimatedVectorImageVisual::New(GetFactoryCache(), GetImageVisualShaderFactory(), imageUrl, propertyMap);
break;
break;
}
case VisualUrl::JSON:
+ case VisualUrl::RIVE:
{
visualPtr = AnimatedVectorImageVisual::New(GetFactoryCache(), GetImageVisualShaderFactory(), visualUrl);
break;
char GIF[4] = {'f', 'i', 'g', '.'};
char WEBP[5] = {'p', 'b', 'e', 'w', '.'};
char JSON[5] = {'n', 'o', 's', 'j', '.'};
+ char RIVE[4] = {'v', 'i', 'r', '.'};
unsigned int svgScore = 0;
unsigned int gifScore = 0;
unsigned int webpScore = 0;
unsigned int jsonScore = 0;
+ unsigned int riveScore = 0;
int index = count;
while(--index >= 0)
{
return VisualUrl::JSON;
}
}
+ if((offsetFromEnd < sizeof(RIVE)) && (currentChar == RIVE[offsetFromEnd]))
+ {
+ // early out if RIVE as can't be used in N patch for now
+ if(++riveScore == sizeof(RIVE))
+ {
+ return VisualUrl::RIVE;
+ }
+ }
switch(state)
{
case SUFFIX:
SVG,
GIF,
WEBP,
- JSON
+ JSON,
+ RIVE
};
enum ProtocolType
{
const unsigned int TOOLKIT_MAJOR_VERSION = 2;
const unsigned int TOOLKIT_MINOR_VERSION = 0;
-const unsigned int TOOLKIT_MICRO_VERSION = 23;
+const unsigned int TOOLKIT_MICRO_VERSION = 25;
const char* const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
Name: dali2-toolkit
Summary: Dali 3D engine Toolkit
-Version: 2.0.23
+Version: 2.0.25
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-toolkit.git / commitdiff