compile_commands.json
dali-toolkit/internal/graphics/generated/*
dali-toolkit/internal/graphics/builtin-shader-extern-gen.h
-dali-scene-loader/internal/graphics/generated/*
-dali-scene-loader/internal/graphics/builtin-shader-extern-gen.h
+dali-scene3d/internal/graphics/generated/*
+dali-scene3d/internal/graphics/builtin-shader-extern-gen.h
* Build with the Visual Studio project.
* Build with CMake.
* [4. Building for MacOS](#4-building-for-macos)
- * [DALi Scene Loader](#dali-scene-loader)
+ * [DALi Scene3D](#dali-scene3d)
# Build Instructions
% make install -j8
```
-# DALi Scene Loader
+# DALi Scene3D
-For information about the DALi Scene Loader library, refer to dali-scene-loader/README.md.
+For information about the DALi Scene3D library, refer to dali-scene3d/README.md.
$files{$file}->{"patch"} = [@checklines];
$files{$file}->{"b_lines"} = {%b_lines};
- my %filter = map { $_ => $files{$_} } grep {m!^dali(-toolkit|-scene-loader)?/!} (keys(%files));
+ my %filter = map { $_ => $files{$_} } grep {m!^dali(-toolkit|-scene3d)?/!} (keys(%files));
if($pd_debug)
{
-SET(PKG_NAME "dali-scene-loader-internal")
+SET(PKG_NAME "dali-scene3d-internal")
SET(EXEC_NAME "tct-${PKG_NAME}-core")
SET(RPM_NAME "core-${PKG_NAME}-tests")
-SET(CAPI_LIB "dali-scene-loader")
+SET(CAPI_LIB "dali-scene3d")
# List of test case sources (Only these get parsed for test cases)
SET(TC_SOURCES
dali2-core
dali2-adaptor
dali2-toolkit
- dali2-scene-loader
+ dali2-scene3d
)
ADD_COMPILE_OPTIONS( -O0 -ggdb --coverage -Wall -Werror -DDEBUG_ENABLED)
#include <test-harness.h>
-#include "tct-dali-scene-loader-internal-core.h"
+#include "tct-dali-scene3d-internal-core.h"
int main(int argc, char * const argv[])
{
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/internal/gltf2-asset.h"
+#include "dali-scene3d/internal/loader/gltf2-asset.h"
#include <dali-test-suite-utils.h>
#include <string>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
int UtcDaliGltf2AssetComponentIsUnsigned(void)
{
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/internal/hash.h"
+#include "dali-scene3d/internal/loader/hash.h"
#include <dali-test-suite-utils.h>
#include <string>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
int UtcDaliHash(void)
{
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/internal/json-reader.h"
+#include "dali-scene3d/internal/loader/json-reader.h"
#include <dali-test-suite-utils.h>
#include <string>
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/internal/json-util.h"
+#include "dali-scene3d/internal/loader/json-util.h"
#include "dali-toolkit/devel-api/builder/json-parser.h"
#include <dali-test-suite-utils.h>
#include <string>
using namespace Dali;
using namespace Dali::Toolkit;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
namespace
{
-SET(PKG_NAME "dali-scene-loader")
+SET(PKG_NAME "dali-scene3d")
SET(EXEC_NAME "tct-${PKG_NAME}-core")
SET(RPM_NAME "core-${PKG_NAME}-tests")
-SET(CAPI_LIB "dali-scene-loader")
+SET(CAPI_LIB "dali-scene3d")
# List of test case sources (Only these get parsed for test cases)
SET(TC_SOURCES
dali2-core
dali2-adaptor
dali2-toolkit
- dali2-scene-loader
+ dali2-scene3d
)
ADD_COMPILE_OPTIONS( -O0 -ggdb --coverage -Wall -Werror -DDEBUG_ENABLED)
#include <test-harness.h>
-#include "tct-dali-scene-loader-core.h"
+#include "tct-dali-scene3d-core.h"
int main(int argc, char * const argv[])
{
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/public-api/alpha-function-helper.h"
+#include "dali-scene3d/public-api/loader/alpha-function-helper.h"
#include <dali-test-suite-utils.h>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
#define ALPHA_FN_PAIR(x) { #x, AlphaFunction::x }
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/public-api/animated-property.h"
+#include "dali-scene3d/public-api/loader/animated-property.h"
#include <dali-test-suite-utils.h>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
int UtcDaliAnimatedPropertyGetPropertyType(void)
{
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/public-api/animation-definition.h"
+#include "dali-scene3d/public-api/loader/animation-definition.h"
#include <dali-test-suite-utils.h>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
int UtcDaliAnimationDefinitionStopForModification(void)
{
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/public-api/camera-parameters.h"
+#include "dali-scene3d/public-api/loader/camera-parameters.h"
#include <dali-test-suite-utils.h>
#include <string_view>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
int UtcDaliCameraParameters(void)
{
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/public-api/cube-loader.h"
+#include "dali-scene3d/public-api/loader/cube-loader.h"
#include <dali-test-suite-utils.h>
#include <string_view>
#include <fstream>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
int UtcDaliCubeLoaderFailNonexistent(void)
{
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/public-api/cube-map-loader.h"
+#include "dali-scene3d/public-api/loader/cube-map-loader.h"
#include <dali-test-suite-utils.h>
#include <string_view>
#include <fstream>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
int UtcDaliCubeMapLoaderFailNonexistent(void)
{
#include <dali-test-suite-utils.h>
#include <string_view>
-#include "dali-scene-loader/internal/json-util.h"
-#include "dali-scene-loader/public-api/dli-loader.h"
-#include "dali-scene-loader/public-api/load-result.h"
-#include "dali-scene-loader/public-api/resource-bundle.h"
-#include "dali-scene-loader/public-api/scene-definition.h"
+#include "dali-scene3d/internal/loader/json-util.h"
+#include "dali-scene3d/public-api/loader/dli-loader.h"
+#include "dali-scene3d/public-api/loader/load-result.h"
+#include "dali-scene3d/public-api/loader/resource-bundle.h"
+#include "dali-scene3d/public-api/loader/scene-definition.h"
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
namespace
{
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/public-api/environment-definition.h"
+#include "dali-scene3d/public-api/loader/environment-definition.h"
#include <dali-test-suite-utils.h>
#include <string_view>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
int UtcDaliEnvironmentDefinitionLoadRawDefault(void)
{
*/
#include <dali-test-suite-utils.h>
-#include <dali-scene-loader/public-api/animation-definition.h>
-#include <dali-scene-loader/public-api/facial-animation-loader.h>
+#include <dali-scene3d/public-api/loader/animation-definition.h>
+#include <dali-scene3d/public-api/loader/facial-animation-loader.h>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
int UtcDaliLoadFacialAnimation(void)
{
#include <dali-test-suite-utils.h>
#include <string_view>
-#include "dali-scene-loader/public-api/gltf2-loader.h"
-#include "dali-scene-loader/public-api/load-result.h"
-#include "dali-scene-loader/public-api/resource-bundle.h"
-#include "dali-scene-loader/public-api/scene-definition.h"
-#include "dali-scene-loader/public-api/shader-definition-factory.h"
+#include "dali-scene3d/public-api/loader/gltf2-loader.h"
+#include "dali-scene3d/public-api/loader/load-result.h"
+#include "dali-scene3d/public-api/loader/resource-bundle.h"
+#include "dali-scene3d/public-api/loader/scene-definition.h"
+#include "dali-scene3d/public-api/loader/shader-definition-factory.h"
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
#define DALI_TEST_THROW(expression, exception, predicate) \
{ \
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/public-api/ktx-loader.h"
+#include "dali-scene3d/public-api/loader/ktx-loader.h"
#include <dali-test-suite-utils.h>
#include <string_view>
#include <fstream>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
int UtcDaliKtxLoaderFailNonexistent(void)
{
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/public-api/matrix-stack.h"
+#include "dali-scene3d/public-api/loader/matrix-stack.h"
#include <dali-test-suite-utils.h>
#include <string_view>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
int UtcDaliMatrixStack(void)
{
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
#include <vector>
-#include "dali-scene-loader/public-api/mesh-definition.h"
+#include "dali-scene3d/public-api/loader/mesh-definition.h"
#include <dali-test-suite-utils.h>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
int UtcDaliMeshDefinitionBlobApplyMinMaxBothMinMaxApplied(void)
{
#include <stdlib.h>
#include <iostream>
-#include <dali-scene-loader/public-api/controls/model-view/model-view.h>
+#include <dali-scene3d/public-api/controls/model-view/model-view.h>
using namespace Dali;
using namespace Dali::Toolkit;
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/public-api/node-definition.h"
-#include "dali-scene-loader/public-api/view-projection.h"
+#include "dali-scene3d/public-api/loader/node-definition.h"
+#include "dali-scene3d/public-api/loader/view-projection.h"
#include <toolkit-test-application.h>
#include <dali-test-suite-utils.h>
#include <string_view>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
namespace
{
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/public-api/renderer-state.h"
-#include "dali-scene-loader/public-api/parse-renderer-state.h"
-#include "dali-scene-loader/public-api/utils.h"
+#include "dali-scene3d/public-api/loader/renderer-state.h"
+#include "dali-scene3d/public-api/loader/parse-renderer-state.h"
+#include "dali-scene3d/public-api/loader/utils.h"
#include <dali-test-suite-utils.h>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
-namespace sl = SceneLoader;
+namespace sl = Dali::Scene3D::Loader;
namespace rs = RendererState;
int UtcDaliRendererStateFromBlendFactors(void)
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/public-api/resource-bundle.h"
-#include "dali-scene-loader/public-api/utils.h"
+#include "dali-scene3d/public-api/loader/resource-bundle.h"
+#include "dali-scene3d/public-api/loader/utils.h"
#include <dali-test-suite-utils.h>
#include <string_view>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
int UtcDaliResourceRefCounts(void)
{
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/public-api/scene-definition.h"
-#include "dali-scene-loader/public-api/utils.h"
+#include "dali-scene3d/public-api/loader/scene-definition.h"
+#include "dali-scene3d/public-api/loader/utils.h"
#include <dali-test-suite-utils.h>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
int UtcDaliSceneDefinitionAddNode(void)
{
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/public-api/shader-definition.h"
+#include "dali-scene3d/public-api/loader/shader-definition.h"
#include <dali-test-suite-utils.h>
#include <string_view>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
int UtcDaliShaderDefinitionFailedToLoad(void)
{
#include <dali-test-suite-utils.h>
#include <set>
#include <string_view>
-#include "dali-scene-loader/public-api/gltf2-loader.h"
-#include "dali-scene-loader/public-api/node-definition.h"
-#include "dali-scene-loader/public-api/resource-bundle.h"
-#include "dali-scene-loader/public-api/shader-definition-factory.h"
+#include "dali-scene3d/public-api/loader/gltf2-loader.h"
+#include "dali-scene3d/public-api/loader/node-definition.h"
+#include "dali-scene3d/public-api/loader/resource-bundle.h"
+#include "dali-scene3d/public-api/loader/shader-definition-factory.h"
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
namespace
{
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/public-api/string-callback.h"
+#include "dali-scene3d/public-api/loader/string-callback.h"
#include <dali-test-suite-utils.h>
#include <string_view>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
namespace
{
{
InstallLogFunction(TestLogFunction);
DefaultErrorCallback("Hello world!");
- DALI_TEST_EQUAL(std::string(sBuffer), "2: string-callback.cpp: DefaultErrorCallback(26) > Hello world!");
+ DALI_TEST_EQUAL(std::string(sBuffer), "2: string-callback.cpp: DefaultErrorCallback(28) > Hello world!");
END_TEST;
}
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/public-api/utils.h"
+#include "dali-scene3d/public-api/loader/utils.h"
#include <dali-test-suite-utils.h>
#include <string_view>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
namespace
{
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "dali-scene-loader/public-api/view-projection.h"
+#include "dali-scene3d/public-api/loader/view-projection.h"
#include <dali-test-suite-utils.h>
using namespace Dali;
-using namespace Dali::SceneLoader;
+using namespace Dali::Scene3D::Loader;
namespace
{
dali.info
*.dylib
dali2-*-config.cmake
-libdali2-scene-loader.so*
+libdali2-scene3d.so*
dali-shader-generator
OPTION(INSTALL_DOXYGEN_DOC "Install doxygen doc" ON)
OPTION(CONFIGURE_AUTOMATED_TESTS "Configure automated tests" ON)
OPTION(USE_DEFAULT_RESOURCE_DIR "Whether to use the default resource folders. Otherwise set environment variables for DALI_IMAGE_DIR, DALI_SOUND_DIR, DALI_STYLE_DIR, DALI_STYLE_IMAGE_DIR and DALI_DATA_READ_ONLY_DIR" ON)
-OPTION(BUILD_SCENE_LOADER "Whether to build dali-scene-loader." ON)
+OPTION(BUILD_SCENE3D "Whether to build dali-scene3d." ON)
IF( ENABLE_PKG_CONFIGURE )
FIND_PACKAGE( PkgConfig REQUIRED )
ADD_CUSTOM_TARGET( ${DALI_TOOLKIT_PREFIX}rename_cov_data ./rename-cov-data )
ADD_CUSTOM_TARGET( ${DALI_TOOLKIT_PREFIX}cov_data ${LCOV_BIN} ${LCOV_OPTS} --base-directory . --directory . -c -o dali.info
- COMMAND ${LCOV_BIN} ${LCOV_OPTS} --remove dali.info \"*/dali-env/*\" \"/usr/include/*\" \"*/dali-env/*\" \"*solid-color-actor*\" \"*/dali-toolkit/third-party/*\" \"*/dali-scene-loader/third-party/*\" -o dali.info )
+ COMMAND ${LCOV_BIN} ${LCOV_OPTS} --remove dali.info \"*/dali-env/*\" \"/usr/include/*\" \"*/dali-env/*\" \"*solid-color-actor*\" \"*/dali-toolkit/third-party/*\" \"*/dali-scene3d/third-party/*\" -o dali.info )
ADD_CUSTOM_TARGET( ${DALI_TOOLKIT_PREFIX}coverage genhtml -p ${ROOT_SRC_DIR} ${LCOV_OPTS} -o ${COVERAGE_OUTPUT_DIR} dali.info
DEPENDS cov_data )
ENDIF( LCOV_BIN )
ENDIF()
-IF ( BUILD_SCENE_LOADER )
- ADD_SUBDIRECTORY( ${CMAKE_CURRENT_SOURCE_DIR}/dali-scene-loader )
+IF ( BUILD_SCENE3D )
+ ADD_SUBDIRECTORY( ${CMAKE_CURRENT_SOURCE_DIR}/dali-scene3d )
ENDIF()
CONFIGURE_FILE( ${DOXYGEN_SRC_DIR}/dali.doxy.in ${DOXYGEN_SRC_DIR}/dali.doxy @ONLY )
CONFIGURE_FILE( ${DOXYGEN_INTERNAL_SRC_DIR}/dali-internal.doxy.in ${DOXYGEN_INTERNAL_SRC_DIR}/dali-internal.doxy @ONLY )
- IF ( BUILD_SCENE_LOADER )
+ IF ( BUILD_SCENE3D )
ADD_CUSTOM_TARGET( doc_doxygen ALL
- DEPENDS ${name} dali2-scene-loader
+ DEPENDS ${name} dali2-scene3d
COMMAND ${DOXYGEN_EXECUTABLE} -u ${DOXYGEN_SRC_DIR}/dali.doxy
COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_SRC_DIR}/dali.doxy
COMMAND ${CMAKE_COMMAND} -P ${DOXYGEN_SRC_DIR}/check_for_errors.cmake
MESSAGE( STATUS "Vector Based Text Rendering: " ${ENABLE_VECTOR_BASED_TEXT_RENDERING} )
MESSAGE( STATUS "Enable link test: " ${ENABLE_LINK_TEST} )
MESSAGE( STATUS "Configure automated tests: " ${CONFIGURE_AUTOMATED_TESTS} )
-MESSAGE( STATUS "Build Dali Scene Loader: " ${BUILD_SCENE_LOADER} )
+MESSAGE( STATUS "Build Dali Scene3D: " ${BUILD_SCENE3D} )
MESSAGE( STATUS "CXXFLAGS: " ${CMAKE_CXX_FLAGS} )
MESSAGE( STATUS "LDFLAGS: " ${CMAKE_SHARED_LINKER_FLAGS_INIT}${CMAKE_SHARED_LINKER_FLAGS} )
CMAKE_MINIMUM_REQUIRED(VERSION 3.8.2)
-set(name "dali2-scene-loader")
+set(name "dali2-scene3d")
project(${name} CXX)
set(${name}_VERSION_PATCH 0)
set(${name}_VERSION ${${name}_VERSION_MAJOR}.${${name}_VERSION_MINOR}.${${name}_VERSION_PATCH} )
-SET(DALI_SCENE_LOADER_VERSION ${${name}_VERSION} )
+SET(DALI_SCENE3D_VERSION ${${name}_VERSION} )
if(CMAKE_BUILD_TYPE MATCHES Debug)
add_definitions("-DDEBUG_ENABLED")
endif()
-ADD_DEFINITIONS( "-DBUILDING_DALI_SCENE_LOADER" )
+ADD_DEFINITIONS( "-DBUILDING_DALI_SCENE3D" )
foreach(flag ${PKGS_CFLAGS})
set(extra_flags "${extra_flags} ${flag}")
set(prefix ${CMAKE_INSTALL_PREFIX})
set(repo_root_dir "${CMAKE_CURRENT_LIST_DIR}/../../../")
-set(scene_loader_dir "${repo_root_dir}/dali-scene-loader")
+set(scene3d_dir "${repo_root_dir}/dali-scene3d")
option(ENABLE_PKG_CONFIGURE "Use pkgconfig" ON)
option(ENABLE_COVERAGE "Coverage" OFF)
set(EXEC_PREFIX ${CMAKE_INSTALL_PREFIX})
set(DEV_INCLUDE_PATH ${INCLUDE_DIR})
- set(core_pkg_cfg_file dali2-scene-loader.pc)
+ set(core_pkg_cfg_file dali2-scene3d.pc)
configure_file(${CMAKE_CURRENT_LIST_DIR}/${core_pkg_cfg_file}.in ${core_pkg_cfg_file} @ONLY)
endif()
-set(scene_loader_src_files "")
-include("${scene_loader_dir}/internal/file.list")
-include("${scene_loader_dir}/public-api/file.list")
+set(scene3d_src_files "")
+include("${scene3d_dir}/internal/file.list")
+include("${scene3d_dir}/public-api/file.list")
set(prefix_include_dir "${prefix}/include")
include_directories(${repo_root_dir}
)
# Generate source files for shaders
-SET(SHADER_SOURCE_DIR "${scene_loader_dir}/internal/graphics/shaders/")
-SET(SHADER_GENERATED_DIR "${scene_loader_dir}/internal/graphics/generated")
+SET(SHADER_SOURCE_DIR "${scene3d_dir}/internal/graphics/shaders/")
+SET(SHADER_GENERATED_DIR "${scene3d_dir}/internal/graphics/generated")
-SET(GENERATED_SHADER_DIR ${scene_loader_dir}/internal/graphics/)
+SET(GENERATED_SHADER_DIR ${scene3d_dir}/internal/graphics/)
SET_PROPERTY(DIRECTORY PROPERTY ADDITIONAL_MAKE_CLEAN_FILES
"${GENERATED_SHADER_DIR}/generated/"
"${GENERATED_SHADER_DIR}/builtin-shader-extern-gen.h")
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} )
+SET( scene3d_src_files ${scene3d_src_files} ${BUILT_IN_SHADER_GEN_CPP} )
-add_library(${name} SHARED ${scene_loader_src_files})
+add_library(${name} SHARED ${scene3d_src_files})
target_link_libraries(${name} ${DALICORE_LDFLAGS} ${DALIADAPTOR_LDFLAGS}
dali2-toolkit
IF( INSTALL_CMAKE_MODULES )
SET_TARGET_PROPERTIES( ${name}
PROPERTIES
- VERSION ${DALI_SCENE_LOADER_VERSION}
+ VERSION ${DALI_SCENE3D_VERSION}
SOVERSION ${${name}_VERSION_MAJOR}
CLEAN_DIRECT_OUPUT 1
)
INSTALL( TARGETS ${name} DESTINATION ${LIB_DIR} )
ENDIF()
-file(GLOB scene_loader_include_files ${scene_loader_public_api_dir})
-install(DIRECTORY ${scene_loader_include_files}
- DESTINATION "${prefix_include_dir}/dali-scene-loader"
+file(GLOB scene3d_include_files ${scene3d_public_api_dir})
+install(DIRECTORY ${scene3d_include_files}
+ DESTINATION "${prefix_include_dir}/dali-scene3d"
FILES_MATCHING PATTERN "*.h"
)
prefix=@PREFIX@
exec_prefix=@EXEC_PREFIX@
-apiversion=@DALI_SCENE_LOADER_VERSION@
+apiversion=@DALI_SCENE3D_VERSION@
libdir=@LIB_DIR@
includedir=@DEV_INCLUDE_PATH@
-Name: Dali 3D Engine Scene Loader
-Description: Dali Scene Loader library
+Name: Dali 3D Engine Scene3D
+Description: Dali Scene3D library
Version: ${apiversion}
Requires: dali2-toolkit
-Libs: -L${libdir} -ldali2-scene-loader
+Libs: -L${libdir} -ldali2-scene3d
Cflags: -I${includedir}
PREDEFINED = DALI_CORE_API \
DALI_ADAPTOR_API \
DALI_TOOLKIT_API \
- DALI_SCENE_LOADER_API \
+ DALI_SCENE3D_API \
DALI_INTERNAL \
# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
@prefix@/include/dali/devel-api \
../../../dali-toolkit/public-api \
../../../dali-toolkit/devel-api \
- ../../../dali-scene-loader/public-api \
+ ../../../dali-scene3d/public-api \
../../../automated-tests/README.md
# This tag can be used to specify the character encoding of the source files
PREDEFINED = DALI_CORE_API \
DALI_ADAPTOR_API \
DALI_TOOLKIT_API \
- DALI_SCENE_LOADER_API \
+ DALI_SCENE3D_API \
DALI_INTERNAL \
# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
+++ /dev/null
-set(scene_loader_internal_dir "${scene_loader_dir}/internal")
-
-set(scene_loader_src_files ${scene_loader_src_files}
- ${scene_loader_internal_dir}/gltf2-asset.cpp
- ${scene_loader_internal_dir}/hash.cpp
- ${scene_loader_internal_dir}/json-reader.cpp
- ${scene_loader_internal_dir}/json-util.cpp
- ${scene_loader_internal_dir}/controls/model-view/model-view-impl.cpp
-)
+++ /dev/null
-set(scene_loader_public_api_dir "${scene_loader_dir}/public-api")
-
-set(scene_loader_src_files ${scene_loader_src_files}
- ${scene_loader_public_api_dir}/alpha-function-helper.cpp
- ${scene_loader_public_api_dir}/animated-property.cpp
- ${scene_loader_public_api_dir}/animation-definition.cpp
- ${scene_loader_public_api_dir}/blend-shape-details.cpp
- ${scene_loader_public_api_dir}/camera-parameters.cpp
- ${scene_loader_public_api_dir}/cube-data.cpp
- ${scene_loader_public_api_dir}/cube-loader.cpp
- ${scene_loader_public_api_dir}/cube-map-loader.cpp
- ${scene_loader_public_api_dir}/customization.cpp
- ${scene_loader_public_api_dir}/dli-loader.cpp
- ${scene_loader_public_api_dir}/environment-definition.cpp
- ${scene_loader_public_api_dir}/facial-animation-loader.cpp
- ${scene_loader_public_api_dir}/gltf2-loader.cpp
- ${scene_loader_public_api_dir}/ktx-loader.cpp
- ${scene_loader_public_api_dir}/material-definition.cpp
- ${scene_loader_public_api_dir}/matrix-stack.cpp
- ${scene_loader_public_api_dir}/mesh-definition.cpp
- ${scene_loader_public_api_dir}/controls/model-view/model-view.cpp
- ${scene_loader_public_api_dir}/node-definition.cpp
- ${scene_loader_public_api_dir}/parse-renderer-state.cpp
- ${scene_loader_public_api_dir}/renderer-state.cpp
- ${scene_loader_public_api_dir}/resource-bundle.cpp
- ${scene_loader_public_api_dir}/scene-definition.cpp
- ${scene_loader_public_api_dir}/shader-definition.cpp
- ${scene_loader_public_api_dir}/shader-definition-factory.cpp
- ${scene_loader_public_api_dir}/skinning-details.cpp
- ${scene_loader_public_api_dir}/string-callback.cpp
- ${scene_loader_public_api_dir}/utils.cpp
- ${scene_loader_public_api_dir}/view-projection.cpp
-)
\ No newline at end of file
* `joints0` and `weights0` attributes, as above.
* A [`skeleton`](#skeletons) ID, to specify which (joint) nodes' transformations affect the mesh.
-:warning: The maximum number of bones supported by DALi Scene Loader is `64`.
+:warning: The maximum number of bones supported by DALi Scene3D is `64`.
## Blend shapes
Blend shapes provide alternate configurations of vertex `positions`, `normals` and/or `tangents` that may be blended with the same attributes of the base mesh, controlled by an animatable `weight`.
```
A `blendShapesHeader`, if present, must define:
* the `version` of the blend shapes; supported values are `1.0` and `2.0`. The difference between the versions is that v1.0 requires a per-blend shape definition of an un-normalization factor.
- * the `byteOffset` and `byteLength` of a buffer in the binary which defines the width (2 bytes) and height (2 bytes) of the texture that dali-scene-loader creates for blend shape data.
+ * the `byteOffset` and `byteLength` of a buffer in the binary which defines the width (2 bytes) and height (2 bytes) of the texture that dali-scene3d creates for blend shape data.
The `blendShapes` array then defines the shapes that are available to blend between, comprising of:
* An initial `weight` numerical, the default is 0;
#include <dali-toolkit/devel-api/controls/control-devel.h>
#include <dali-toolkit/internal/controls/control/control-data-impl.h>
#include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
+#include <dali/integration-api/debug.h>
#include <dali/public-api/object/type-registry-helper.h>
#include <dali/public-api/object/type-registry.h>
-#include <dali/integration-api/debug.h>
#include <filesystem>
// INTERNAL INCLUDES
-#include <dali-scene-loader/public-api/animation-definition.h>
-#include <dali-scene-loader/public-api/camera-parameters.h>
-#include <dali-scene-loader/public-api/dli-loader.h>
-#include <dali-scene-loader/public-api/gltf2-loader.h>
-#include <dali-scene-loader/public-api/light-parameters.h>
-#include <dali-scene-loader/public-api/load-result.h>
-#include <dali-scene-loader/public-api/node-definition.h>
-#include <dali-scene-loader/public-api/scene-definition.h>
-#include <dali-scene-loader/public-api/shader-definition-factory.h>
-#include <dali-scene-loader/public-api/controls/model-view/model-view.h>
-#include <dali-scene-loader/public-api/cube-map-loader.h>
-#include <dali-scene-loader/public-api/cube-data.h>
+#include <dali-scene3d/public-api/controls/model-view/model-view.h>
+#include <dali-scene3d/public-api/loader/animation-definition.h>
+#include <dali-scene3d/public-api/loader/camera-parameters.h>
+#include <dali-scene3d/public-api/loader/cube-data.h>
+#include <dali-scene3d/public-api/loader/cube-map-loader.h>
+#include <dali-scene3d/public-api/loader/dli-loader.h>
+#include <dali-scene3d/public-api/loader/gltf2-loader.h>
+#include <dali-scene3d/public-api/loader/light-parameters.h>
+#include <dali-scene3d/public-api/loader/load-result.h>
+#include <dali-scene3d/public-api/loader/node-definition.h>
+#include <dali-scene3d/public-api/loader/scene-definition.h>
+#include <dali-scene3d/public-api/loader/shader-definition-factory.h>
using namespace Dali;
Texture LoadCubeMap(const std::string& cubeMapPath)
{
- Texture cubeTexture;
- SceneLoader::CubeData cubeData;
- if(SceneLoader::LoadCubeMapData(cubeMapPath, cubeData))
+ Texture cubeTexture;
+ Dali::Scene3D::Loader::CubeData cubeData;
+ if(Dali::Scene3D::Loader::LoadCubeMapData(cubeMapPath, cubeData))
{
cubeTexture = cubeData.CreateTexture();
}
}
void ConfigureBlendShapeShaders(
- SceneLoader::ResourceBundle& resources, const SceneLoader::SceneDefinition& scene, Actor root, std::vector<SceneLoader::BlendshapeShaderConfigurationRequest>&& requests)
+ Dali::Scene3D::Loader::ResourceBundle& resources, const Dali::Scene3D::Loader::SceneDefinition& scene, Actor root, std::vector<Dali::Scene3D::Loader::BlendshapeShaderConfigurationRequest>&& requests)
{
std::vector<std::string> errors;
auto onError = [&errors](const std::string& msg) { errors.push_back(msg); };
if(!scene.ConfigureBlendshapeShaders(resources, root, std::move(requests), onError))
{
- SceneLoader::ExceptionFlinger flinger(ASSERT_LOCATION);
+ Dali::Scene3D::Loader::ExceptionFlinger flinger(ASSERT_LOCATION);
for(auto& msg : errors)
{
flinger << msg << '\n';
}
}
-void AddModelTreeToAABB(BoundingVolume& AABB, const SceneLoader::SceneDefinition& scene, const Dali::SceneLoader::Customization::Choices& choices, Dali::SceneLoader::Index iNode, Dali::SceneLoader::NodeDefinition::CreateParams& nodeParams, Matrix parentMatrix)
+void AddModelTreeToAABB(BoundingVolume& AABB, const Dali::Scene3D::Loader::SceneDefinition& scene, const Dali::Scene3D::Loader::Customization::Choices& choices, Dali::Scene3D::Loader::Index iNode, Dali::Scene3D::Loader::NodeDefinition::CreateParams& nodeParams, Matrix parentMatrix)
{
static constexpr uint32_t BOX_POINT_COUNT = 8;
static uint32_t BBIndex[BOX_POINT_COUNT][3] = {{0, 0, 0}, {0, 1, 0}, {1, 0, 0}, {1, 1, 0}, {0, 0, 1}, {0, 1, 1}, {1, 0, 1}, {1, 1, 1}};
- Matrix nodeMatrix;
- const SceneLoader::NodeDefinition* node = scene.GetNode(iNode);
- Matrix localMatrix = node->GetLocalSpace();
+ Matrix nodeMatrix;
+ const Dali::Scene3D::Loader::NodeDefinition* node = scene.GetNode(iNode);
+ Matrix localMatrix = node->GetLocalSpace();
Matrix::Multiply(nodeMatrix, localMatrix, parentMatrix);
Vector3 volume[2];
{
if(!node->mChildren.empty())
{
- auto choice = choices.Get(node->mCustomization->mTag);
- Dali::SceneLoader::Index i = std::min(choice != Dali::SceneLoader::Customization::NONE ? choice : 0, static_cast<Dali::SceneLoader::Index>(node->mChildren.size() - 1));
+ auto choice = choices.Get(node->mCustomization->mTag);
+ Dali::Scene3D::Loader::Index i = std::min(choice != Dali::Scene3D::Loader::Customization::NONE ? choice : 0, static_cast<Dali::Scene3D::Loader::Index>(node->mChildren.size() - 1));
AddModelTreeToAABB(AABB, scene, choices, node->mChildren[i], nodeParams, nodeMatrix);
}
std::string extension = modelPath.extension();
std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
- SceneLoader::ResourceBundle::PathProvider pathProvider = [&](SceneLoader::ResourceType::Value type) {
+ Dali::Scene3D::Loader::ResourceBundle::PathProvider pathProvider = [&](Dali::Scene3D::Loader::ResourceType::Value type) {
return mResourcePath;
};
- SceneLoader::ResourceBundle resources;
- SceneLoader::SceneDefinition scene;
- std::vector<SceneLoader::AnimationGroupDefinition> animGroups;
- std::vector<SceneLoader::CameraParameters> cameraParameters;
- std::vector<SceneLoader::LightParameters> lights;
+ Dali::Scene3D::Loader::ResourceBundle resources;
+ Dali::Scene3D::Loader::SceneDefinition scene;
+ std::vector<Dali::Scene3D::Loader::AnimationGroupDefinition> animGroups;
+ std::vector<Dali::Scene3D::Loader::CameraParameters> cameraParameters;
+ std::vector<Dali::Scene3D::Loader::LightParameters> lights;
- std::vector<Dali::SceneLoader::AnimationDefinition> animations;
+ std::vector<Dali::Scene3D::Loader::AnimationDefinition> animations;
animations.clear();
- SceneLoader::LoadResult output{resources, scene, animations, animGroups, cameraParameters, lights};
+ Dali::Scene3D::Loader::LoadResult output{resources, scene, animations, animGroups, cameraParameters, lights};
if(extension == DLI_EXTENSION)
{
- SceneLoader::DliLoader loader;
- SceneLoader::DliLoader::InputParams input{
- pathProvider(SceneLoader::ResourceType::Mesh),
+ Dali::Scene3D::Loader::DliLoader loader;
+ Dali::Scene3D::Loader::DliLoader::InputParams input{
+ pathProvider(Dali::Scene3D::Loader::ResourceType::Mesh),
nullptr,
{},
{},
nullptr,
{}};
- SceneLoader::DliLoader::LoadParams loadParams{input, output};
+ Dali::Scene3D::Loader::DliLoader::LoadParams loadParams{input, output};
if(!loader.LoadScene(mModelPath, loadParams))
{
- SceneLoader::ExceptionFlinger(ASSERT_LOCATION) << "Failed to load scene from '" << mModelPath << "': " << loader.GetParseError();
+ Dali::Scene3D::Loader::ExceptionFlinger(ASSERT_LOCATION) << "Failed to load scene from '" << mModelPath << "': " << loader.GetParseError();
}
}
else if(extension == GLTF_EXTENSION)
{
- SceneLoader::ShaderDefinitionFactory sdf;
+ Dali::Scene3D::Loader::ShaderDefinitionFactory sdf;
sdf.SetResources(resources);
- SceneLoader::LoadGltfScene(mModelPath, sdf, output);
+ Dali::Scene3D::Loader::LoadGltfScene(mModelPath, sdf, output);
resources.mEnvironmentMaps.push_back({});
}
DALI_LOG_ERROR("Unsupported model type.\n");
}
- SceneLoader::Transforms xforms{SceneLoader::MatrixStack{}, SceneLoader::ViewProjection{}};
- SceneLoader::NodeDefinition::CreateParams nodeParams{resources, xforms, {}, {}, {}};
- SceneLoader::Customization::Choices choices;
+ Dali::Scene3D::Loader::Transforms xforms{Dali::Scene3D::Loader::MatrixStack{}, Dali::Scene3D::Loader::ViewProjection{}};
+ Dali::Scene3D::Loader::NodeDefinition::CreateParams nodeParams{resources, xforms, {}, {}, {}};
+ Dali::Scene3D::Loader::Customization::Choices choices;
mModelRoot = Actor::New();
SetImageBasedLight(mModelRoot);
mNaturalSize = AABB.CalculateSize();
- mModelPivot = AABB.CalculatePivot();
+ mModelPivot = AABB.CalculatePivot();
mModelRoot.SetProperty(Dali::Actor::Property::SIZE, mNaturalSize);
FitModelPosition();
uint32_t rendererCount = node.GetRendererCount();
if(rendererCount)
{
- node.RegisterProperty(SceneLoader::NodeDefinition::GetIblScaleFactorUniformName().data(), mIblScaleFactor);
+ node.RegisterProperty(Dali::Scene3D::Loader::NodeDefinition::GetIblScaleFactorUniformName().data(), mIblScaleFactor);
}
for(uint32_t i = 0; i < rendererCount; ++i)
-#ifndef DALI_SCENE_LOADER_INTERNAL_MODEL_VIEW_H
-#define DALI_SCENE_LOADER_INTERNAL_MODEL_VIEW_H
+#ifndef DALI_SCENE3D_INTERNAL_MODEL_VIEW_H
+#define DALI_SCENE3D_INTERNAL_MODEL_VIEW_H
/*
* Copyright (c) 2022 Samsung Electronics Co., Ltd.
*/
// EXTERNAL INCLUDES
+#include <dali-toolkit/public-api/controls/control-impl.h>
#include <dali/public-api/actors/layer.h>
#include <dali/public-api/animation/animation.h>
#include <dali/public-api/rendering/texture.h>
-#include <dali-toolkit/public-api/controls/control-impl.h>
// INTERNAL INCLUDES
-#include <dali-scene-loader/public-api/controls/model-view/model-view.h>
+#include <dali-scene3d/public-api/controls/model-view/model-view.h>
namespace Dali
{
void SetImageBasedLight(Actor node);
private:
- std::string mModelPath;
- std::string mResourcePath;
- Dali::Layer mModelLayer;
- Dali::Actor mModelRoot;
- std::vector<AnimationData> mAnimations;
-
- Dali::Texture mSpecularTexture;
- Dali::Texture mDiffuseTexture;
- Vector3 mNaturalSize;
- Vector3 mModelPivot;
- float mIblScaleFactor;
- bool mFitSize;
- bool mFitCenter;
+ std::string mModelPath;
+ std::string mResourcePath;
+ Dali::Layer mModelLayer;
+ Dali::Actor mModelRoot;
+ std::vector<AnimationData> mAnimations;
+
+ Dali::Texture mSpecularTexture;
+ Dali::Texture mDiffuseTexture;
+ Vector3 mNaturalSize;
+ Vector3 mModelPivot;
+ float mIblScaleFactor;
+ bool mFitSize;
+ bool mFitCenter;
};
} // namespace Internal
return static_cast<const Dali::Scene3D::Internal::ModelView&>(handle);
}
-} // namespace Toolkit
+} // namespace Scene3D
} // namespace Dali
-#endif // DALI_SCENE_LOADER_INTERNAL_MODEL_VIEW_H
+#endif // DALI_SCENE3D_INTERNAL_MODEL_VIEW_H
--- /dev/null
+set(scene3d_internal_dir "${scene3d_dir}/internal")
+
+set(scene3d_src_files ${scene3d_src_files}
+ ${scene3d_internal_dir}/loader/gltf2-asset.cpp
+ ${scene3d_internal_dir}/loader/hash.cpp
+ ${scene3d_internal_dir}/loader/json-reader.cpp
+ ${scene3d_internal_dir}/loader/json-util.cpp
+ ${scene3d_internal_dir}/controls/model-view/model-view-impl.cpp
+)
/*
-* Copyright (c) 2021 Samsung Electronics Co., Ltd.
+* Copyright (c) 2022 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.
* limitations under the License.
*
*/
-#include "dali-scene-loader/internal/gltf2-asset.h"
+#include "dali-scene3d/internal/loader/gltf2-asset.h"
#include <algorithm>
#include <map>
#include "dali/public-api/math/matrix.h"
-#ifndef DALI_SCENE_LOADER_GLTF2_ASSET_H_
-#define DALI_SCENE_LOADER_GLTF2_ASSET_H_
+#ifndef DALI_SCENE3D_LOADER_GLTF2_ASSET_H_
+#define DALI_SCENE3D_LOADER_GLTF2_ASSET_H_
/*
* Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/internal/json-reader.h"
-#include "dali-scene-loader/public-api/index.h"
+#include "dali-scene3d/internal/loader/json-reader.h"
+#include "dali-scene3d/public-api/loader/index.h"
// EXTERNAL INCLUDES
#include <cstdint>
namespace gltf2
{
-using Index = Dali::SceneLoader::Index;
+using Index = Dali::Scene3D::Loader::Index;
template<typename T>
class Ref
private:
std::vector<T>* mVector = nullptr;
- Index mIndex = Dali::SceneLoader::INVALID_INDEX;
+ Index mIndex = Dali::Scene3D::Loader::INVALID_INDEX;
};
struct Asset
} // namespace gltf2
-#endif //DALI_SCENE_LOADER_GLTF2_ASSET_H_
+#endif //DALI_SCENE3D_LOADER_GLTF2_ASSET_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
* limitations under the License.
*
*/
-#include "dali-scene-loader/internal/hash.h"
+#include "dali-scene3d/internal/loader/hash.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
Hash::Hash(uint64_t initial)
: mValue(initial)
return mValue * 31 + value;
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_HASH_H_
-#define DALI_SCENE_LOADER_HASH_H_
+#ifndef DALI_SCENE3D_LOADER_HASH_H_
+#define DALI_SCENE3D_LOADER_HASH_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
/**
* @brief Rudimentary hash generator that follows a builder pattern.
return *this;
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif // DALI_SCENE_LOADER_HASH_H_
+#endif // DALI_SCENE3D_LOADER_HASH_H_
/*
-* Copyright (c) 2021 Samsung Electronics Co., Ltd.
+* Copyright (c) 2022 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.
* limitations under the License.
*
*/
-#include "dali-scene-loader/internal/json-reader.h"
+#include "dali-scene3d/internal/loader/json-reader.h"
#include <algorithm>
#include <cstring>
-#ifndef DALI_SCENE_LOADER_JSON_READER_H_
-#define DALI_SCENE_LOADER_JSON_READER_H_
+#ifndef DALI_SCENE3D_LOADER_JSON_READER_H_
+#define DALI_SCENE3D_LOADER_JSON_READER_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/third-party/json.h"
+#include "dali-scene3d/third-party/json.h"
// EXTERNAL INCLUDES
#include <algorithm>
} // namespace json
-#endif //DALI_SCENE_LOADER_JSON_READER_H_
+#endif //DALI_SCENE3D_LOADER_JSON_READER_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
* limitations under the License.
*
*/
-#include "dali-scene-loader/internal/json-util.h"
+#include "dali-scene3d/internal/loader/json-util.h"
// EXTERNAL INCLUDES
#include <array>
{
using namespace Toolkit;
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
namespace
{
return propValue;
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_JSON_UTIL_H_
-#define DALI_SCENE_LOADER_JSON_UTIL_H_
+#ifndef DALI_SCENE3D_LOADER_JSON_UTIL_H_
+#define DALI_SCENE3D_LOADER_JSON_UTIL_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/index.h"
+#include "dali-scene3d/public-api/loader/index.h"
// EXTERNAL INCLUDES
#include "dali-toolkit/devel-api/builder/tree-node.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
bool ReadBool(const Toolkit::TreeNode* node, bool& num);
*/
Property::Value ReadPropertyValue(const Toolkit::TreeNode& tn);
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_JSON_UTIL_H_
+#endif //DALI_SCENE3D_LOADER_JSON_UTIL_H_
-#ifndef DALI_SCENE_LOADER_API_H
-#define DALI_SCENE_LOADER_API_H
+#ifndef DALI_SCENE3D_API_H
+#define DALI_SCENE3D_API_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
#if __GNUC__ >= 4
-#define DALI_SCENE_LOADER_API __attribute__((visibility("default")))
+#define DALI_SCENE3D_API __attribute__((visibility("default")))
#elif defined(WIN32)
-#ifdef BUILDING_DALI_SCENE_LOADER
-#define DALI_SCENE_LOADER_API __declspec(dllexport)
+#ifdef BUILDING_DALI_SCENE3D
+#define DALI_SCENE3D_API __declspec(dllexport)
#else
-#define DALI_SCENE_LOADER_API __declspec(dllimport)
-#endif // BUILDING_DALI_SCENE_LOADER
+#define DALI_SCENE3D_API __declspec(dllimport)
+#endif // BUILDING_DALI_SCENE3D
#endif
-#endif //DALI_SCENE_LOADER_API_H
+#endif //DALI_SCENE3D_API_H
*/
// CLASS HEADER
-#include <dali-scene-loader/public-api/controls/model-view/model-view.h>
+#include <dali-scene3d/public-api/controls/model-view/model-view.h>
// INTERNAL INCLUDES
-#include <dali-scene-loader/internal/controls/model-view/model-view-impl.h>
+#include <dali-scene3d/internal/controls/model-view/model-view-impl.h>
namespace Dali
{
-#ifndef DALI_SCENE_LOADER_MODEL_VIEW_H
-#define DALI_SCENE_LOADER_MODEL_VIEW_H
+#ifndef DALI_SCENE3D_MODEL_VIEW_H
+#define DALI_SCENE3D_MODEL_VIEW_H
/*
* Copyright (c) 2022 Samsung Electronics Co., Ltd.
*/
// INTERNAL INCLUDES
-#include <dali-scene-loader/public-api/api.h>
+#include <dali-scene3d/public-api/api.h>
// EXTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
*
* @endcode
*/
-class DALI_SCENE_LOADER_API ModelView : public Dali::Toolkit::Control
+class DALI_SCENE3D_API ModelView : public Dali::Toolkit::Control
{
public:
/**
} // namespace Dali
-#endif // DALI_SCENE_LOADER_MODEL_VIEW_H
+#endif // DALI_SCENE3D_MODEL_VIEW_H
--- /dev/null
+set(scene3d_public_api_dir "${scene3d_dir}/public-api")
+
+set(scene3d_src_files ${scene3d_src_files}
+ ${scene3d_public_api_dir}/controls/model-view/model-view.cpp
+ ${scene3d_public_api_dir}/loader/alpha-function-helper.cpp
+ ${scene3d_public_api_dir}/loader/animated-property.cpp
+ ${scene3d_public_api_dir}/loader/animation-definition.cpp
+ ${scene3d_public_api_dir}/loader/blend-shape-details.cpp
+ ${scene3d_public_api_dir}/loader/camera-parameters.cpp
+ ${scene3d_public_api_dir}/loader/cube-data.cpp
+ ${scene3d_public_api_dir}/loader/cube-loader.cpp
+ ${scene3d_public_api_dir}/loader/cube-map-loader.cpp
+ ${scene3d_public_api_dir}/loader/customization.cpp
+ ${scene3d_public_api_dir}/loader/dli-loader.cpp
+ ${scene3d_public_api_dir}/loader/environment-definition.cpp
+ ${scene3d_public_api_dir}/loader/facial-animation-loader.cpp
+ ${scene3d_public_api_dir}/loader/gltf2-loader.cpp
+ ${scene3d_public_api_dir}/loader/ktx-loader.cpp
+ ${scene3d_public_api_dir}/loader/material-definition.cpp
+ ${scene3d_public_api_dir}/loader/matrix-stack.cpp
+ ${scene3d_public_api_dir}/loader/mesh-definition.cpp
+ ${scene3d_public_api_dir}/loader/node-definition.cpp
+ ${scene3d_public_api_dir}/loader/parse-renderer-state.cpp
+ ${scene3d_public_api_dir}/loader/renderer-state.cpp
+ ${scene3d_public_api_dir}/loader/resource-bundle.cpp
+ ${scene3d_public_api_dir}/loader/scene-definition.cpp
+ ${scene3d_public_api_dir}/loader/shader-definition.cpp
+ ${scene3d_public_api_dir}/loader/shader-definition-factory.cpp
+ ${scene3d_public_api_dir}/loader/skinning-details.cpp
+ ${scene3d_public_api_dir}/loader/string-callback.cpp
+ ${scene3d_public_api_dir}/loader/utils.cpp
+ ${scene3d_public_api_dir}/loader/view-projection.cpp
+)
\ No newline at end of file
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
* limitations under the License.
*
*/
-#include "dali-scene-loader/public-api/alpha-function-helper.h"
+#include "dali-scene3d/public-api/loader/alpha-function-helper.h"
#include <unordered_map>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
namespace
{
"Function with given key already exists.");
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_ALPHA_FUNCTION_HELPER_H_
-#define DALI_SCENE_LOADER_ALPHA_FUNCTION_HELPER_H_
+#ifndef DALI_SCENE3D_LOADER_ALPHA_FUNCTION_HELPER_H_
+#define DALI_SCENE3D_LOADER_ALPHA_FUNCTION_HELPER_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*
*/
-#include "dali-scene-loader/public-api/api.h"
+#include "dali-scene3d/public-api/api.h"
#include <string>
#include "dali/public-api/animation/alpha-function.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
/**
* @return Given a name, provide a AlphaFunction; if the name was not
* recognised, get the default one.
*/
-AlphaFunction DALI_SCENE_LOADER_API GetAlphaFunction(const std::string& name, bool* found = nullptr);
+AlphaFunction DALI_SCENE3D_API GetAlphaFunction(const std::string& name, bool* found = nullptr);
/**
* @brief Registers an alpha function only if one with the same @a name has
* not yet been registered. Throws Exception the name isn't unique.
*/
-void DALI_SCENE_LOADER_API RegisterAlphaFunction(const std::string& name, AlphaFunction alphaFn) noexcept(false);
+void DALI_SCENE3D_API RegisterAlphaFunction(const std::string& name, AlphaFunction alphaFn) noexcept(false);
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_ALPHA_FUNCTION_HELPER_H_
+#endif //DALI_SCENE3D_LOADER_ALPHA_FUNCTION_HELPER_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
* limitations under the License.
*
*/
-#include "dali-scene-loader/public-api/animated-property.h"
+#include "dali-scene3d/public-api/loader/animated-property.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
void AnimatedProperty::Animate(Animation& anim, GetActor getActor)
{
}
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_ANIMATED_PROPERTY_H
-#define DALI_SCENE_LOADER_ANIMATED_PROPERTY_H
+#ifndef DALI_SCENE3D_LOADER_ANIMATED_PROPERTY_H
+#define DALI_SCENE3D_LOADER_ANIMATED_PROPERTY_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
+#include "dali-scene3d/public-api/api.h"
// EXTERNAL INCLUDES
#include <functional>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
/**
* @brief Intermediate representation for a property that's given to
* changing properties (e.g. from the SDK) requires the whole Animation
* object to be recreated with all of its properties (incl. modifications).
*/
-struct DALI_SCENE_LOADER_API AnimatedProperty
+struct DALI_SCENE3D_API AnimatedProperty
{
public: // METHODS
/**
TimePeriod mTimePeriod = TimePeriod(0.f);
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_ANIMATED_PROPERTY_H
+#endif //DALI_SCENE3D_LOADER_ANIMATED_PROPERTY_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
* limitations under the License.
*
*/
-#include "dali-scene-loader/public-api/animation-definition.h"
+#include "dali-scene3d/public-api/loader/animation-definition.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
const float AnimationDefinition::DEFAULT_DURATION_SECONDS = 1.f;
const float AnimationDefinition::MIN_DURATION_SECONDS = 1e-2f;
return *this;
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_ANIMATION_DEFINITION_H
-#define DALI_SCENE_LOADER_ANIMATION_DEFINITION_H
+#ifndef DALI_SCENE3D_LOADER_ANIMATION_DEFINITION_H
+#define DALI_SCENE3D_LOADER_ANIMATION_DEFINITION_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*
*/
-#include "dali-scene-loader/public-api/animated-property.h"
-#include "dali-scene-loader/public-api/api.h"
+#include "dali-scene3d/public-api/api.h"
+#include "dali-scene3d/public-api/loader/animated-property.h"
#include "dali/public-api/common/vector-wrapper.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
/**
* @brief Animation handle + name + definition of properties.
*/
-class DALI_SCENE_LOADER_API AnimationDefinition
+class DALI_SCENE3D_API AnimationDefinition
{
public: // STATIC
// For Animations created in the SDK.
std::vector<std::string> mAnimations;
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_ANIMATION_DEFINITION_H
+#endif //DALI_SCENE3D_LOADER_ANIMATION_DEFINITION_H
*/
// FILE HEADER
-#include <dali-scene-loader/public-api/blend-shape-details.h>
+#include <dali-scene3d/public-api/loader/blend-shape-details.h>
// EXTERNAL INCLUDES
#include <dali/public-api/animation/constraints.h>
#include <dali/public-api/object/property.h>
// INTERNAL INCLUDES
-#include <dali-scene-loader/public-api/resource-bundle.h>
+#include <dali-scene3d/public-api/loader/resource-bundle.h>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
const std::string BlendShapes::NUMBER_OF_BLEND_SHAPES("uNumberOfBlendShapes");
const std::string BlendShapes::UNNORMALIZE_FACTOR("uBlendShapeUnnormalizeFactor");
}
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_BLEND_SHAPE_DETAILS_H
-#define DALI_SCENE_LOADER_BLEND_SHAPE_DETAILS_H
+#ifndef DALI_SCENE3D_LOADER_BLEND_SHAPE_DETAILS_H
+#define DALI_SCENE3D_LOADER_BLEND_SHAPE_DETAILS_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
+#include "dali-scene3d/public-api/api.h"
// EXTERNAL INCLUDES
#include <string>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
struct MeshDefinition;
struct MeshGeometry;
-struct DALI_SCENE_LOADER_API BlendShapes
+struct DALI_SCENE3D_API BlendShapes
{
enum class Version
{
BlendShapes() = delete;
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif // DALI_SCENE_LOADER_BLEND_SHAPE_DETAILS_H
+#endif // DALI_SCENE3D_LOADER_BLEND_SHAPE_DETAILS_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
* limitations under the License.
*
*/
-#include "dali-scene-loader/public-api/camera-parameters.h"
-#include "dali-scene-loader/public-api/utils.h"
+#include "dali-scene3d/public-api/loader/camera-parameters.h"
+#include "dali-scene3d/public-api/loader/utils.h"
#include "dali/integration-api/debug.h"
#include "dali/public-api/actors/camera-actor.h"
#include "dali/public-api/math/quaternion.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
namespace
{
camera.SetProperty(Actor::Property::SCALE, camScale);
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_CAMERA_PARAMETERS_H
-#define DALI_SCENE_LOADER_CAMERA_PARAMETERS_H
+#ifndef DALI_SCENE3D_LOADER_CAMERA_PARAMETERS_H
+#define DALI_SCENE3D_LOADER_CAMERA_PARAMETERS_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
-#include "dali-scene-loader/public-api/view-projection.h"
+#include "dali-scene3d/public-api/api.h"
+#include "dali-scene3d/public-api/loader/view-projection.h"
// EXTERNAL INCLUDES
#include "dali/public-api/math/matrix.h"
{
class CameraActor;
-namespace SceneLoader
+namespace Scene3D
{
-struct DALI_SCENE_LOADER_API CameraParameters
+namespace Loader
+{
+struct DALI_SCENE3D_API CameraParameters
{
Matrix matrix = Matrix::IDENTITY;
Vector4 orthographicSize = Vector4{-1.f, 1.f, 1.f, -1.f};
/**
* @brief Configures the camera in the way that it is supposed to be used with
- * scene-loader scenes. This means inverted Y and a rotation of 180 degrees
+ * scene3d scenes. This means inverted Y and a rotation of 180 degrees
* along the Y axis, plus whatever the parameters define.
*/
void ConfigureCamera(CameraActor& camera) const;
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif // DALI_SCENE_LOADER_CAMERA_PARAMETERS_H
+#endif // DALI_SCENE3D_LOADER_CAMERA_PARAMETERS_H
*/
// FILE HEADER
-#include "dali-scene-loader/public-api/cube-data.h"
+#include "dali-scene3d/public-api/loader/cube-data.h"
// EXTERNAL INCLUDES
#include "dali/public-api/rendering/texture.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
-
Texture CubeData::CreateTexture() const
{
Texture texture = Texture::New(TextureType::TEXTURE_CUBE, data[0][0].GetPixelFormat(), data[0][0].GetWidth(), data[0][0].GetHeight());
return texture;
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_CUBE_DATA_H
-#define DALI_SCENE_LOADER_CUBE_DATA_H
+#ifndef DALI_SCENE3D_LOADER_CUBE_DATA_H
+#define DALI_SCENE3D_LOADER_CUBE_DATA_H
/*
* Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
+#include "dali-scene3d/public-api/api.h"
// EXTERNAL INCLUDES
#include "dali/public-api/common/vector-wrapper.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
/**
* @brief Stores the pixel data objects for each face of the cube texture and their mipmaps.
*/
-class DALI_SCENE_LOADER_API CubeData
+class DALI_SCENE3D_API CubeData
{
public:
/**
std::vector<std::vector<PixelData> > data;
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif // DALI_SCENE_LOADER_CUBE_DATA_H
+#endif // DALI_SCENE3D_LOADER_CUBE_DATA_H
*/
// FILE HEADER
-#include <dali-scene-loader/public-api/cube-loader.h>
+#include <dali-scene3d/public-api/loader/cube-loader.h>
// EXTERNAL INCLUDES
#include <dali/devel-api/adaptor-framework/image-loading.h>
}
} // namespace
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
bool LoadCubeData(const std::string& path, CubeData& cubedata)
{
return false;
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_CUBE_LOADER_H
-#define DALI_SCENE_LOADER_CUBE_LOADER_H
+#ifndef DALI_SCENE3D_LOADER_CUBE_LOADER_H
+#define DALI_SCENE3D_LOADER_CUBE_LOADER_H
/*
* Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
*/
// INTERNAL INCLUDES
-#include <dali-scene-loader/public-api/api.h>
-#include <dali-scene-loader/public-api/cube-data.h>
+#include <dali-scene3d/public-api/api.h>
+#include <dali-scene3d/public-api/loader/cube-data.h>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
-
/**
* @brief Loads cube map data texture from a cube style image file.
*
*/
bool LoadCubeData(const std::string& path, CubeData& cubedata);
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif // DALI_SCENE_LOADER_CUBE_LOADER_H
+#endif // DALI_SCENE3D_LOADER_CUBE_LOADER_H
*/
// FILE HEADER
-#include <dali-scene-loader/public-api/cube-map-loader.h>
+#include <dali-scene3d/public-api/loader/cube-map-loader.h>
// INTERNAL INCLUDES
-#include <dali-scene-loader/public-api/ktx-loader.h>
-#include <dali-scene-loader/public-api/cube-loader.h>
+#include <dali-scene3d/public-api/loader/cube-loader.h>
+#include <dali-scene3d/public-api/loader/ktx-loader.h>
// EXTERNAL INCLUDES
#include <filesystem>
{
namespace
{
-
const std::string_view KTX_EXTENSION = ".ktx";
-
}
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
-
bool LoadCubeMapData(const std::string& path, CubeData& cubedata)
{
std::filesystem::path modelPath(path);
std::string extension = modelPath.extension();
std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
- return (extension == KTX_EXTENSION) ? SceneLoader::LoadKtxData(path, cubedata) : SceneLoader::LoadCubeData(path, cubedata);
+ return (extension == KTX_EXTENSION) ? Dali::Scene3D::Loader::LoadKtxData(path, cubedata) : Dali::Scene3D::Loader::LoadCubeData(path, cubedata);
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_CUBE_MAP_LOADER_H
-#define DALI_SCENE_LOADER_CUBE_MAP_LOADER_H
+#ifndef DALI_SCENE3D_LOADER_CUBE_MAP_LOADER_H
+#define DALI_SCENE3D_LOADER_CUBE_MAP_LOADER_H
/*
* Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
*/
// INTERNAL INCLUDES
-#include <dali-scene-loader/public-api/api.h>
-#include <dali-scene-loader/public-api/cube-data.h>
+#include <dali-scene3d/public-api/api.h>
+#include <dali-scene3d/public-api/loader/cube-data.h>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
-
/**
* @brief Loads cube map data texture from a cube map file.
*
*/
bool LoadCubeMapData(const std::string& path, CubeData& cubedata);
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif // DALI_SCENE_LOADER_CUBE_MAP_LOADER_H
+#endif // DALI_SCENE3D_LOADER_CUBE_MAP_LOADER_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
* limitations under the License.
*
*/
-#include "dali-scene-loader/public-api/customization.h"
+#include "dali-scene3d/public-api/loader/customization.h"
#include "dali/devel-api/common/map-wrapper.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
struct Customization::Map::Impl
{
mImpl->mOptions.clear();
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_CUSTOMIZATION_STATE_H_
-#define DALI_SCENE_LOADER_CUSTOMIZATION_STATE_H_
+#ifndef DALI_SCENE3D_LOADER_CUSTOMIZATION_STATE_H_
+#define DALI_SCENE3D_LOADER_CUSTOMIZATION_STATE_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
+#include "dali-scene3d/public-api/api.h"
// EXTERNAL INCLUDES
#include <memory>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
/**
* @brief Offers a description of an aspect of the scene that can be customized:
* the number of options, and the name of the nodes that are registered
* for the tag, whose children will be shown / hidden based on selection.
*/
-struct DALI_SCENE_LOADER_API Customization
+struct DALI_SCENE3D_API Customization
{
using Tag = std::string;
using OptionType = uint32_t;
/**
* @brief A mapping of customizations to tags.
*/
- struct DALI_SCENE_LOADER_API Map
+ struct DALI_SCENE3D_API Map
{
Map();
~Map();
/**
* @brief A mapping of choices - indices of children of customization nodes to use - to tags.
*/
- struct DALI_SCENE_LOADER_API Choices
+ struct DALI_SCENE3D_API Choices
{
Choices();
~Choices();
std::vector<std::string> nodes; // to apply option to.
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_CUSTOMIZATION_STATE_H_
+#endif //DALI_SCENE3D_LOADER_CUSTOMIZATION_STATE_H_
*/
// CLASS HEADER
-#include "dali-scene-loader/public-api/dli-loader.h"
+#include "dali-scene3d/public-api/loader/dli-loader.h"
// EXTERNAL INCLUDES
#include <algorithm>
#include "dali/public-api/object/property-array.h"
// INTERNAL INCLUDES
-#include "dali-scene-loader/internal/json-util.h"
-#include "dali-scene-loader/public-api/alpha-function-helper.h"
-#include "dali-scene-loader/public-api/animation-definition.h"
-#include "dali-scene-loader/public-api/blend-shape-details.h"
-#include "dali-scene-loader/public-api/camera-parameters.h"
-#include "dali-scene-loader/public-api/ktx-loader.h"
-#include "dali-scene-loader/public-api/light-parameters.h"
-#include "dali-scene-loader/public-api/load-result.h"
-#include "dali-scene-loader/public-api/parse-renderer-state.h"
-#include "dali-scene-loader/public-api/scene-definition.h"
-#include "dali-scene-loader/public-api/skinning-details.h"
-#include "dali-scene-loader/public-api/utils.h"
+#include "dali-scene3d/internal/loader/json-util.h"
+#include "dali-scene3d/public-api/loader/alpha-function-helper.h"
+#include "dali-scene3d/public-api/loader/animation-definition.h"
+#include "dali-scene3d/public-api/loader/blend-shape-details.h"
+#include "dali-scene3d/public-api/loader/camera-parameters.h"
+#include "dali-scene3d/public-api/loader/ktx-loader.h"
+#include "dali-scene3d/public-api/loader/light-parameters.h"
+#include "dali-scene3d/public-api/loader/load-result.h"
+#include "dali-scene3d/public-api/loader/parse-renderer-state.h"
+#include "dali-scene3d/public-api/loader/scene-definition.h"
+#include "dali-scene3d/public-api/loader/skinning-details.h"
+#include "dali-scene3d/public-api/loader/utils.h"
#define DLI_0_1_COMPATIBILITY
{
using namespace Toolkit;
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
namespace rs = RendererState;
}
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_DLI_LOADER_H
-#define DALI_SCENE_LOADER_DLI_LOADER_H
+#ifndef DALI_SCENE3D_LOADER_DLI_LOADER_H
+#define DALI_SCENE3D_LOADER_DLI_LOADER_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/animation-definition.h"
-#include "dali-scene-loader/public-api/api.h"
-#include "dali-scene-loader/public-api/customization.h"
-#include "dali-scene-loader/public-api/index.h"
-#include "dali-scene-loader/public-api/string-callback.h"
+#include "dali-scene3d/public-api/api.h"
+#include "dali-scene3d/public-api/loader/animation-definition.h"
+#include "dali-scene3d/public-api/loader/customization.h"
+#include "dali-scene3d/public-api/loader/index.h"
+#include "dali-scene3d/public-api/loader/string-callback.h"
// EXTERNAL INCLUDES
#include "dali/public-api/common/vector-wrapper.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
typedef std::pair<std::string, std::string> Metadata;
struct NodeDefinition;
class SceneDefinition;
-class DALI_SCENE_LOADER_API DliLoader
+class DALI_SCENE3D_API DliLoader
{
public:
using ConvertFontCode = void (*)(const std::string& code, std::string& fontFamily, std::string& slant, std::string& weight, float& size);
const std::unique_ptr<Impl> mImpl;
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif // DALI_SCENE_LOADER_DLI_LOADER_H
+#endif // DALI_SCENE3D_LOADER_DLI_LOADER_H
#include <dali/devel-api/adaptor-framework/image-loading.h>
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/environment-definition.h"
-#include "dali-scene-loader/public-api/utils.h"
-#include "dali-scene-loader/public-api/cube-map-loader.h"
+#include "dali-scene3d/public-api/loader/cube-map-loader.h"
+#include "dali-scene3d/public-api/loader/environment-definition.h"
+#include "dali-scene3d/public-api/loader/utils.h"
namespace
{
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
namespace
{
return textures;
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_ENVIRONMENT_DEFINITION_H
-#define DALI_SCENE_LOADER_ENVIRONMENT_DEFINITION_H
+#ifndef DALI_SCENE3D_LOADER_ENVIRONMENT_DEFINITION_H
+#define DALI_SCENE3D_LOADER_ENVIRONMENT_DEFINITION_H
/*
* Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
-#include "dali-scene-loader/public-api/cube-data.h"
+#include "dali-scene3d/public-api/api.h"
+#include "dali-scene3d/public-api/loader/cube-data.h"
// EXTERNAL INCLUDES
#include "dali/public-api/math/quaternion.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
/**
* @brief Defines an environment map with either or both of radiance
* and irradiance maps.
*/
-struct DALI_SCENE_LOADER_API EnvironmentDefinition
+struct DALI_SCENE3D_API EnvironmentDefinition
{
struct Textures
{
bool mUseBrdfTexture = false;
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_ENVIRONMENT_DEFINITION_H
+#endif //DALI_SCENE3D_LOADER_ENVIRONMENT_DEFINITION_H
*/\r
\r
// FILE HEADER\r
-#include <dali-scene-loader/public-api/facial-animation-loader.h>\r
+#include <dali-scene3d/public-api/loader/facial-animation-loader.h>\r
\r
// EXTERNAL INCLUDES\r
#include <sstream>\r
\r
// INTERNAL INCLUDES\r
-#include <dali-scene-loader/internal/json-reader.h>\r
-#include <dali-scene-loader/public-api/blend-shape-details.h>\r
-#include <dali-scene-loader/public-api/utils.h>\r
+#include <dali-scene3d/internal/loader/json-reader.h>\r
+#include <dali-scene3d/public-api/loader/blend-shape-details.h>\r
+#include <dali-scene3d/public-api/loader/utils.h>\r
\r
namespace js = json;\r
\r
\r
} // unnamed namespace\r
\r
-namespace SceneLoader\r
+namespace Scene3D\r
+{\r
+namespace Loader\r
{\r
AnimationDefinition LoadFacialAnimation(const std::string& url)\r
{\r
return animationDefinition;\r
}\r
\r
-} // namespace SceneLoader\r
+} // namespace Loader\r
+} // namespace Scene3D\r
} // namespace Dali\r
-#ifndef DALI_SCENE_LOADER_FACIAL_ANIMATION_LOADER_H\r
-#define DALI_SCENE_LOADER_FACIAL_ANIMATION_LOADER_H\r
+#ifndef DALI_SCENE3D_LOADER_FACIAL_ANIMATION_LOADER_H\r
+#define DALI_SCENE3D_LOADER_FACIAL_ANIMATION_LOADER_H\r
\r
/*\r
* Copyright (c) 2022 Samsung Electronics Co., Ltd.\r
*/\r
\r
// INTERNAL INCLUDES\r
-#include <dali-scene-loader/public-api/animation-definition.h>\r
+#include <dali-scene3d/public-api/loader/animation-definition.h>\r
\r
-namespace Dali::SceneLoader\r
+namespace Dali::Scene3D::Loader\r
{\r
/**\r
* @brief Loads a facial animation encoded in a json file in the given @p url.\r
*\r
* @return An animation definition.\r
*/\r
-DALI_SCENE_LOADER_API AnimationDefinition LoadFacialAnimation(const std::string& url);\r
-} // namespace Dali::SceneLoader\r
+DALI_SCENE3D_API AnimationDefinition LoadFacialAnimation(const std::string& url);\r
+} // namespace Dali::Scene3D::Loader\r
\r
-#endif // DALI_SCENE_LOADER_FACIAL_ANIMATION_LOADER_H\r
+#endif // DALI_SCENE3D_LOADER_FACIAL_ANIMATION_LOADER_H\r
* limitations under the License.
*
*/
-#include "dali-scene-loader/public-api/gltf2-loader.h"
+#include "dali-scene3d/public-api/loader/gltf2-loader.h"
#include <fstream>
-#include "dali-scene-loader/internal/gltf2-asset.h"
-#include "dali-scene-loader/public-api/load-result.h"
-#include "dali-scene-loader/public-api/resource-bundle.h"
-#include "dali-scene-loader/public-api/scene-definition.h"
-#include "dali-scene-loader/public-api/shader-definition-factory.h"
-#include "dali-scene-loader/public-api/utils.h"
+#include "dali-scene3d/internal/loader/gltf2-asset.h"
+#include "dali-scene3d/public-api/loader/load-result.h"
+#include "dali-scene3d/public-api/loader/resource-bundle.h"
+#include "dali-scene3d/public-api/loader/scene-definition.h"
+#include "dali-scene3d/public-api/loader/shader-definition-factory.h"
+#include "dali-scene3d/public-api/loader/utils.h"
#include "dali/public-api/math/quaternion.h"
#define ENUM_STRING_MAPPING(t, x) \
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
namespace
{
return duration;
}
-float LoadBlendShapeKeyFrames(const std::string& path, const gt::Animation::Channel& channel, const std::string& nodeName, uint32_t& propertyIndex, std::vector<SceneLoader::AnimatedProperty>& properties)
+float LoadBlendShapeKeyFrames(const std::string& path, const gt::Animation::Channel& channel, const std::string& nodeName, uint32_t& propertyIndex, std::vector<Dali::Scene3D::Loader::AnimatedProperty>& properties)
{
const gltf2::Accessor& input = *channel.mSampler->mInput;
const gltf2::Accessor& output = *channel.mSampler->mOutput;
{
EnvironmentDefinition envDef;
envDef.mUseBrdfTexture = true;
- envDef.mIblIntensity = DEFAULT_INTENSITY;
+ envDef.mIblIntensity = DEFAULT_INTENSITY;
cctx.mOutput.mResources.mEnvironmentMaps.push_back({std::move(envDef), EnvironmentDefinition::Textures()});
}
isMRendererModel = (doc.mAsset.mGenerator.find(MRENDERER_MODEL_IDENTIFICATION) != std::string_view::npos);
}
-
gt::SetRefReaderObject(doc);
DOCUMENT_READER.Read(rootObj, doc);
SetDefaultEnvironmentMap(doc, cctx);
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_GLTF2_LOADER_H
-#define DALI_SCENE_LOADER_GLTF2_LOADER_H
+#ifndef DALI_SCENE3D_LOADER_GLTF2_LOADER_H
+#define DALI_SCENE3D_LOADER_GLTF2_LOADER_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
+#include "dali-scene3d/public-api/api.h"
// EXTERNAL INCLUDES
#include <string>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
struct CameraParameters;
struct LoadResult;
* @note Will throw std::runtime_error for JSON entities with types mismatching expectations, carrying
* invalid values, or I/O errors.
*/
-DALI_SCENE_LOADER_API void LoadGltfScene(const std::string& url, ShaderDefinitionFactory& shaderFactory, LoadResult& params);
+DALI_SCENE3D_API void LoadGltfScene(const std::string& url, ShaderDefinitionFactory& shaderFactory, LoadResult& params);
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_GLTF2_LOADER_H
+#endif //DALI_SCENE3D_LOADER_GLTF2_LOADER_H
-#ifndef DALI_SCENE_LOADER_INDEX_H_
-#define DALI_SCENE_LOADER_INDEX_H_
+#ifndef DALI_SCENE3D_LOADER_INDEX_H_
+#define DALI_SCENE3D_LOADER_INDEX_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
+#include "dali-scene3d/public-api/api.h"
// EXTERNAL INCLUDES
#include <cstdint>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
using Index = uint32_t;
constexpr Index INVALID_INDEX = static_cast<Index>(-1);
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_INDEX_H_
+#endif //DALI_SCENE3D_LOADER_INDEX_H_
*/
// FILE HEADER
-#include <dali-scene-loader/public-api/ktx-loader.h>
+#include <dali-scene3d/public-api/loader/ktx-loader.h>
// EXTERNAL INCLUDES
+#include <dali/public-api/rendering/texture.h>
#include <fstream>
#include <memory>
-#include <dali/public-api/rendering/texture.h>
namespace Dali
{
}
} // namespace
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
struct KtxFileHeader
{
return true;
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_KTX_LOADER_H
-#define DALI_SCENE_LOADER_KTX_LOADER_H
+#ifndef DALI_SCENE3D_LOADER_KTX_LOADER_H
+#define DALI_SCENE3D_LOADER_KTX_LOADER_H
/*
* Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
*/
// INTERNAL INCLUDES
-#include <dali-scene-loader/public-api/api.h>
-#include <dali-scene-loader/public-api/cube-data.h>
+#include <dali-scene3d/public-api/api.h>
+#include <dali-scene3d/public-api/loader/cube-data.h>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
-
/**
* @brief Loads cube map data texture from a ktx file.
*
*/
bool LoadKtxData(const std::string& path, CubeData& cubedata);
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif // DALI_SCENE_LOADER_KTX_LOADER_H
+#endif // DALI_SCENE3D_LOADER_KTX_LOADER_H
-#ifndef DALI_SCENE_LOADER_LIGHT_PARAMETERS_H
-#define DALI_SCENE_LOADER_LIGHT_PARAMETERS_H
+#ifndef DALI_SCENE3D_LOADER_LIGHT_PARAMETERS_H
+#define DALI_SCENE3D_LOADER_LIGHT_PARAMETERS_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
+#include "dali-scene3d/public-api/api.h"
// EXTERNAL INCLUDES
#include <stdint.h>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
{
-struct DALI_SCENE_LOADER_API LightParameters
+namespace Loader
+{
+struct DALI_SCENE3D_API LightParameters
{
Matrix transform;
float orthographicSize;
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif // DALI_SCENE_LOADER_LIGHT_PARAMETERS_H
+#endif // DALI_SCENE3D_LOADER_LIGHT_PARAMETERS_H
-#ifndef DALI_SCENE_LOADER_OUTPUT_H
-#define DALI_SCENE_LOADER_OUTPUT_H
+#ifndef DALI_SCENE3D_LOADER_OUTPUT_H
+#define DALI_SCENE3D_LOADER_OUTPUT_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/animation-definition.h"
-#include "dali-scene-loader/public-api/api.h"
-#include "dali-scene-loader/public-api/camera-parameters.h"
-#include "dali-scene-loader/public-api/light-parameters.h"
+#include "dali-scene3d/public-api/api.h"
+#include "dali-scene3d/public-api/loader/animation-definition.h"
+#include "dali-scene3d/public-api/loader/camera-parameters.h"
+#include "dali-scene3d/public-api/loader/light-parameters.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
class ResourceBundle;
class SceneDefinition;
/**
* @brief The outputs from loading and processing a scene.
*/
-struct DALI_SCENE_LOADER_API LoadResult
+struct DALI_SCENE3D_API LoadResult
{
/**
* @brief The bundle to store resources in.
std::vector<LightParameters>& mLightParameters;
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_OUTPUT_H
+#endif //DALI_SCENE3D_LOADER_OUTPUT_H
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/material-definition.h"
+#include "dali-scene3d/public-api/loader/material-definition.h"
// EXTERNAL INCLUDES
#include "dali-toolkit/public-api/image-loader/sync-image-loader.h"
{
using namespace Toolkit;
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
namespace
{
}) != mTextureStages.end();
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_MATERIAL_DEFINITION_H
-#define DALI_SCENE_LOADER_MATERIAL_DEFINITION_H
+#ifndef DALI_SCENE3D_LOADER_MATERIAL_DEFINITION_H
+#define DALI_SCENE3D_LOADER_MATERIAL_DEFINITION_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
-#include "dali-scene-loader/public-api/environment-definition.h"
-#include "dali-scene-loader/public-api/index.h"
-#include "dali-scene-loader/public-api/utils.h"
+#include "dali-scene3d/public-api/api.h"
+#include "dali-scene3d/public-api/loader/environment-definition.h"
+#include "dali-scene3d/public-api/loader/index.h"
+#include "dali-scene3d/public-api/loader/utils.h"
// EXTERNAL INCLUDES
#include <cmath>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
/**
* @brief Helper enum for encoding and decoding sampler states.
*/
-struct DALI_SCENE_LOADER_API SamplerFlags
+struct DALI_SCENE3D_API SamplerFlags
{
using Type = uint8_t;
/**
* @brief Defines a texture from a combination of an image URI and its sampler definition.
*/
-struct DALI_SCENE_LOADER_API TextureDefinition
+struct DALI_SCENE3D_API TextureDefinition
{
std::string mImageUri;
SamplerFlags::Type mSamplerFlags;
* scene). Textures from the environment are added last when the DALi TextureSet
* is being created.
*/
-struct DALI_SCENE_LOADER_API MaterialDefinition
+struct DALI_SCENE3D_API MaterialDefinition
{
enum Flags : uint32_t
{
std::vector<TextureStage> mTextureStages;
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_MATERIAL_DEFINITION_H
+#endif //DALI_SCENE3D_LOADER_MATERIAL_DEFINITION_H
/*
-* Copyright (c) 2021 Samsung Electronics Co., Ltd.
+* Copyright (c) 2022 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.
* limitations under the License.
*
*/
-#include "dali-scene-loader/public-api/matrix-stack.h"
-#include "dali-scene-loader/public-api/utils.h"
+#include "dali-scene3d/public-api/loader/matrix-stack.h"
+#include "dali-scene3d/public-api/loader/utils.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
MatrixStack::MatrixStack()
{
mStack.clear();
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_MATRIX_STACK_H_
-#define DALI_SCENE_LOADER_MATRIX_STACK_H_
+#ifndef DALI_SCENE3D_LOADERER_MATRIX_STACK_H_
+#define DALI_SCENE3D_LOADERER_MATRIX_STACK_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
+#include "dali-scene3d/public-api/api.h"
// EXTERNAL INCLUDES
#include "dali/public-api/common/vector-wrapper.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
/**
* @brief A stack of matrices whereby each newly pushed matrix is stored
* after being multiplied by the previous one (if any).
* @note Current implementation reserves space for 16 matrices.
*/
-class DALI_SCENE_LOADER_API MatrixStack
+class DALI_SCENE3D_API MatrixStack
{
public:
MatrixStack();
std::vector<Matrix> mStack;
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_MATRIX_STACK_H_
+#endif //DALI_SCENE3D_LOADERER_MATRIX_STACK_H_
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/mesh-definition.h"
+#include "dali-scene3d/public-api/loader/mesh-definition.h"
// EXTERNAL INCLUDES
#include <cstring>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
namespace
{
if(mColors.IsDefined())
{
- uint32_t propertySize = mColors.mBlob.mElementSizeHint;
+ uint32_t propertySize = mColors.mBlob.mElementSizeHint;
Property::Type propertyType = (propertySize == sizeof(Vector4)) ? Property::VECTOR4 : ((propertySize == sizeof(Vector3)) ? Property::VECTOR3 : Property::NONE);
if(propertyType != Property::NONE)
{
return meshGeometry;
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_MESH_DEFINITION_H
-#define DALI_SCENE_LOADER_MESH_DEFINITION_H
+#ifndef DALI_SCENE3D_LOADER_MESH_DEFINITION_H
+#define DALI_SCENE3D_LOADER_MESH_DEFINITION_H
/*
* Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
-#include "dali-scene-loader/public-api/blend-shape-details.h"
-#include "dali-scene-loader/public-api/index.h"
-#include "dali-scene-loader/public-api/mesh-geometry.h"
-#include "dali-scene-loader/public-api/utils.h"
+#include "dali-scene3d/public-api/api.h"
+#include "dali-scene3d/public-api/loader/blend-shape-details.h"
+#include "dali-scene3d/public-api/loader/index.h"
+#include "dali-scene3d/public-api/loader/mesh-geometry.h"
+#include "dali-scene3d/public-api/loader/utils.h"
// EXTERNAL INCLUDES
#include <memory>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
/**
* @brief Defines a mesh with its attributes, the primitive type to render it as,
* and the file to load it from with the offset and length information for the
* individual attribute buffers.
*/
-struct DALI_SCENE_LOADER_API MeshDefinition
+struct DALI_SCENE3D_API MeshDefinition
{
using Vector = std::vector<std::pair<MeshDefinition, MeshGeometry>>;
Index mSkeletonIdx = INVALID_INDEX;
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_MESH_DEFINITION_H
+#endif //DALI_SCENE3D_LOADER_MESH_DEFINITION_H
-#ifndef DALI_SCENE_LOADER_MESH_GEOMETRY_H
-#define DALI_SCENE_LOADER_MESH_GEOMETRY_H
+#ifndef DALI_SCENE3D_LOADERER_MESH_GEOMETRY_H
+#define DALI_SCENE3D_LOADERER_MESH_GEOMETRY_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
+#include "dali-scene3d/public-api/api.h"
// EXTERNAL INCLUDES
#include "dali/public-api/rendering/geometry.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
{
-struct DALI_SCENE_LOADER_API MeshGeometry
+namespace Loader
+{
+struct DALI_SCENE3D_API MeshGeometry
{
Geometry geometry; ///< The array of vertices.
Texture blendShapeGeometry; ///< The array of vertices of the different blend shapes encoded inside a texture with power of two dimensions.
unsigned int blendShapeBufferOffset{0}; ///< Offset used to calculate the start of each blend shape.
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif // DALI_SCENE_LOADER_MESH_GEOMETRY_H
+#endif // DALI_SCENE3D_LOADERER_MESH_GEOMETRY_H
*/
// INTERNAL
-#include "dali-scene-loader/public-api/node-definition.h"
-#include "dali-scene-loader/public-api/renderer-state.h"
-#include "dali-scene-loader/public-api/utils.h"
+#include "dali-scene3d/public-api/loader/node-definition.h"
+#include "dali-scene3d/public-api/loader/renderer-state.h"
+#include "dali-scene3d/public-api/loader/utils.h"
namespace Dali
{
{
constexpr std::string_view IBL_INTENSITY_STRING("uIblIntensity");
constexpr std::string_view IBL_Y_DIRECTION("uYDirection");
-}
+} // namespace
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
bool NodeDefinition::Renderable::GetExtents(const ResourceBundle& resources, Vector3& min, Vector3& max) const
{
bool ModelNode::GetExtents(const ResourceBundle& resources, Vector3& min, Vector3& max) const
{
- auto& mesh = resources.mMeshes[mMeshIdx];
+ auto& mesh = resources.mMeshes[mMeshIdx];
uint32_t minSize = mesh.first.mPositions.mBlob.mMin.size();
uint32_t maxSize = mesh.first.mPositions.mBlob.mMax.size();
if(minSize == maxSize && minSize >= 2u && maxSize >= 2u)
endVector.y = sinf(endAngle * Math::PI_OVER_180);
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_NODE_DEFINITION_H_
-#define DALI_SCENE_LOADER_NODE_DEFINITION_H_
+#ifndef DALI_SCENE3D_LOADER_NODE_DEFINITION_H_
+#define DALI_SCENE3D_LOADER_NODE_DEFINITION_H_
/*
* Copyright (c) 2022 Samsung Electronics Co., Ltd.
*
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/customization.h"
-#include "dali-scene-loader/public-api/matrix-stack.h"
-#include "dali-scene-loader/public-api/resource-bundle.h"
+#include "dali-scene3d/public-api/loader/customization.h"
+#include "dali-scene3d/public-api/loader/matrix-stack.h"
+#include "dali-scene3d/public-api/loader/resource-bundle.h"
// EXTERNAL INCLUDES
#include <functional>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
class ViewProjection;
/**
* @brief Interface to report (const) resource ids to.
*/
-class DALI_SCENE_LOADER_API IResourceReceiver
+class DALI_SCENE3D_API IResourceReceiver
{
public:
virtual ~IResourceReceiver() = default;
* @note These are supposed to be transient. Obviously, the references collected
* this way must not outlive the objects that they came from.
*/
-class DALI_SCENE_LOADER_API IResourceReflector
+class DALI_SCENE3D_API IResourceReflector
{
public:
virtual ~IResourceReflector() = default;
* set up after the Actors were created. The target of the constraint
* is the node definition that carries it.
*/
-struct DALI_SCENE_LOADER_API ConstraintDefinition
+struct DALI_SCENE3D_API ConstraintDefinition
{
std::string mProperty; ///< name of the property to constrain.
Index mSourceIdx; ///< index of the node to serve as the source of the constraint.
}
};
-struct DALI_SCENE_LOADER_API Transforms
+struct DALI_SCENE3D_API Transforms
{
MatrixStack modelStack;
const ViewProjection& viewProjection;
* @brief Information about a skeleton and the shader that needs to be configured with it.
* @note Multiple skeletons shalt not share the same shader.
*/
-struct DALI_SCENE_LOADER_API SkinningShaderConfigurationRequest
+struct DALI_SCENE3D_API SkinningShaderConfigurationRequest
{
Index mSkeletonIdx;
Shader mShader;
/**
* @brief Needed to configure blend shape properties.
*/
-struct DALI_SCENE_LOADER_API BlendshapeShaderConfigurationRequest
+struct DALI_SCENE3D_API BlendshapeShaderConfigurationRequest
{
std::string mNodeName;
Index mMeshIdx;
/**
* @brief Request for creating a constraint, output from NodeDefinition::OnCreate.
*/
-struct DALI_SCENE_LOADER_API ConstraintRequest
+struct DALI_SCENE3D_API ConstraintRequest
{
const ConstraintDefinition* const mConstraint; ///< Definition of the constraint to create.
Actor mTarget; ///< Target of the constraint.
* and slots for customization and rendering logic, which are mutually exclusive in the
* current implementation.
*/
-struct DALI_SCENE_LOADER_API NodeDefinition
+struct DALI_SCENE3D_API NodeDefinition
{
public: // TYPES
using Vector = std::vector<NodeDefinition>;
std::vector<BlendshapeShaderConfigurationRequest> mBlendshapeRequests;
};
- class DALI_SCENE_LOADER_API Renderable
+ class DALI_SCENE3D_API Renderable
{
public: // DATA
Index mShaderIdx = INVALID_INDEX;
Index mParentIdx = INVALID_INDEX;
};
-class DALI_SCENE_LOADER_API ModelNode : public NodeDefinition::Renderable
+class DALI_SCENE3D_API ModelNode : public NodeDefinition::Renderable
{
public: // DATA
Vector4 mColor = Color::WHITE;
/**
* @brief Parameters for an Arc node.
*/
-class DALI_SCENE_LOADER_API ArcNode : public ModelNode
+class DALI_SCENE3D_API ArcNode : public ModelNode
{
public: // DATA
bool mAntiAliasing = true;
void OnCreate(const NodeDefinition& node, NodeDefinition::CreateParams& params, Actor& actor) const override;
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_NODE_DEFINITION_H_
+#endif //DALI_SCENE3D_LOADER_NODE_DEFINITION_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*
*/
-#include "dali-scene-loader/public-api/parse-renderer-state.h"
+#include "dali-scene3d/public-api/loader/parse-renderer-state.h"
#include <cstring>
#include "dali/devel-api/common/map-wrapper.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
namespace RendererState
{
}
std::map<std::string_view, Type> BLEND_FACTORS{
-#define DECL_BLEND_FACTOR(x) {#x, SceneLoader::BlendFactor::x}
+#define DECL_BLEND_FACTOR(x) {#x, Dali::Scene3D::Loader::BlendFactor::x}
DECL_BLEND_FACTOR(ZERO),
DECL_BLEND_FACTOR(ONE),
DECL_BLEND_FACTOR(SRC_COLOR),
}
} // namespace RendererState
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_INTERPRET_RENDERER_STATE_H
-#define DALI_SCENE_LOADER_INTERPRET_RENDERER_STATE_H
+#ifndef DALI_SCENE3D_LOADERERER_INTERPRET_RENDERER_STATE_H
+#define DALI_SCENE3D_LOADERERER_INTERPRET_RENDERER_STATE_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*
*/
-#include "dali-scene-loader/public-api/renderer-state.h"
-#include "dali-scene-loader/public-api/string-callback.h"
+#include "dali-scene3d/public-api/loader/renderer-state.h"
+#include "dali-scene3d/public-api/loader/string-callback.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
namespace RendererState
{
* @param onError The callback to call when an error occurred.
* @note No other characters are allowed.
*/
-DALI_SCENE_LOADER_API Type Parse(const char* string, size_t length = 0, StringCallback onError = DefaultErrorCallback);
+DALI_SCENE3D_API Type Parse(const char* string, size_t length = 0, StringCallback onError = DefaultErrorCallback);
} // namespace RendererState
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_INTERPRET_RENDERER_STATE_H
+#endif //DALI_SCENE3D_LOADERERER_INTERPRET_RENDERER_STATE_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
* limitations under the License.
*
*/
-#include "dali-scene-loader/public-api/renderer-state.h"
-#include "dali-scene-loader/public-api/utils.h"
+#include "dali-scene3d/public-api/loader/renderer-state.h"
+#include "dali-scene3d/public-api/loader/utils.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
namespace
{
} // namespace RendererState
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_RENDERER_STATE_H
-#define DALI_SCENE_LOADER_RENDERER_STATE_H
+#ifndef DALI_SCENE3D_LOADER_RENDERER_STATE_H
+#define DALI_SCENE3D_LOADER_RENDERER_STATE_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
+#include "dali-scene3d/public-api/api.h"
// EXTERNAL INCLUDES
#include "dali/public-api/rendering/renderer.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
/*
* @brief Contains values for comparison functions used in depth and stencil testing.
* @note Relative order of members must match DepthFunction::Type and StencilFunction::Type.
*/
-struct DALI_SCENE_LOADER_API Comparison
+struct DALI_SCENE3D_API Comparison
{
enum Type
{
* @brief Determines the blend factor used.
* @note Relative order of members must match BlendFactor::Type.
*/
-struct DALI_SCENE_LOADER_API BlendFactor
+struct DALI_SCENE3D_API BlendFactor
{
enum Type
{
* @brief Determines which buffers shall the Renderer write into.
* @note Relative order of members must match RenderMode::Type.
*/
-struct DALI_SCENE_LOADER_API BufferMode
+struct DALI_SCENE3D_API BufferMode
{
enum Type
{
{
using Type = uint32_t; // 8 bits reserved for flags, 4 * 4 bit for blend factors, 4 bits for depth function
-enum DALI_SCENE_LOADER_API Value : Type
+enum DALI_SCENE3D_API Value : Type
{
NONE = 0x0,
* @brief Encodes the given blend factors into a RenderMode value, maskable into other options,
* passable into ApplyRenderMode().
*/
-inline DALI_SCENE_LOADER_API constexpr uint32_t FromBlendFactors(BlendFactor::Type srcRgb, BlendFactor::Type destRgb, BlendFactor::Type srcAlpha, BlendFactor::Type destAlpha)
+inline DALI_SCENE3D_API constexpr uint32_t FromBlendFactors(BlendFactor::Type srcRgb, BlendFactor::Type destRgb, BlendFactor::Type srcAlpha, BlendFactor::Type destAlpha)
{
return (srcRgb | (destRgb << BLEND_FACTOR_ITEM_BITS) | (srcAlpha << (BLEND_FACTOR_ITEM_BITS * 2)) |
(destAlpha << (BLEND_FACTOR_ITEM_BITS * 3)))
* @note Blend factors are only set if not BlendFactor::OMIT.
* @note Buffer mode is only set is not BufferMode::OMIT.
*/
-DALI_SCENE_LOADER_API void Apply(Type rendererState, Renderer& renderer);
+DALI_SCENE3D_API void Apply(Type rendererState, Renderer& renderer);
} // namespace RendererState
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_RENDERER_STATE_H
+#endif //DALI_SCENE3D_LOADER_RENDERER_STATE_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// FILE HEADER
-#include "dali-scene-loader/public-api/resource-bundle.h"
+#include "dali-scene3d/public-api/loader/resource-bundle.h"
// EXTERNAL
#include <cstring>
{
using namespace Toolkit;
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
namespace
{
}
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_RESOURCE_BUNDLE_H_
-#define DALI_SCENE_LOADER_RESOURCE_BUNDLE_H_
+#ifndef DALI_SCENE3D_LOADERERERERER_RESOURCE_BUNDLE_H_
+#define DALI_SCENE3D_LOADERERERERER_RESOURCE_BUNDLE_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL
-#include "dali-scene-loader/public-api/environment-definition.h"
-#include "dali-scene-loader/public-api/material-definition.h"
-#include "dali-scene-loader/public-api/mesh-definition.h"
-#include "dali-scene-loader/public-api/shader-definition.h"
-#include "dali-scene-loader/public-api/skeleton-definition.h"
+#include "dali-scene3d/public-api/loader/environment-definition.h"
+#include "dali-scene3d/public-api/loader/material-definition.h"
+#include "dali-scene3d/public-api/loader/mesh-definition.h"
+#include "dali-scene3d/public-api/loader/shader-definition.h"
+#include "dali-scene3d/public-api/loader/skeleton-definition.h"
// EXTERNAL
#include <functional>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
/*
* @brief The types of resources that .dli may define.
*/
-struct DALI_SCENE_LOADER_API ResourceType
+struct DALI_SCENE3D_API ResourceType
{
enum Value
{
/*
* @return The string value corresponding to the given resource @a type.
*/
-DALI_SCENE_LOADER_API const char* GetResourceTypeName(ResourceType::Value type);
+DALI_SCENE3D_API const char* GetResourceTypeName(ResourceType::Value type);
using ResourceRefCounts = std::vector<Vector<uint32_t>>;
* could be created from them, directly indexible into with values from a dli
* document.
*/
-class DALI_SCENE_LOADER_API ResourceBundle
+class DALI_SCENE3D_API ResourceBundle
{
public:
struct Options
SkeletonDefinition::Vector mSkeletons;
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_RESOURCE_BUNDLE_H_
+#endif //DALI_SCENE3D_LOADERERERERER_RESOURCE_BUNDLE_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
#include "dali/public-api/animation/constraints.h"
// INTERNAL
-#include "dali-scene-loader/internal/graphics/builtin-shader-extern-gen.h"
-#include "dali-scene-loader/public-api/blend-shape-details.h"
-#include "dali-scene-loader/public-api/scene-definition.h"
-#include "dali-scene-loader/public-api/skinning-details.h"
-#include "dali-scene-loader/public-api/utils.h"
+#include "dali-scene3d/internal/graphics/builtin-shader-extern-gen.h"
+#include "dali-scene3d/public-api/loader/blend-shape-details.h"
+#include "dali-scene3d/public-api/loader/scene-definition.h"
+#include "dali-scene3d/public-api/loader/skinning-details.h"
+#include "dali-scene3d/public-api/loader/utils.h"
//#define DEBUG_SCENE_DEFINITION
//#define DEBUG_JOINTS
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
namespace
{
{
if(0 == sNumScenes)
{
- sJointDebugShader = Shader::New(SHADER_SCENE_LOADER_JOINT_DEBUG_VERT, SHADER_SCENE_LOADER_JOINT_DEBUG_FRAG);
+ sJointDebugShader = Shader::New(SHADER_SCENE3D_JOINT_DEBUG_VERT, SHADER_SCENE3D_JOINT_DEBUG_FRAG);
}
++sNumScenes;
}
#endif
}
-uint32_t SceneLoader::SceneDefinition::AddRootNode(Index iNode)
+uint32_t Dali::Scene3D::Loader::SceneDefinition::AddRootNode(Index iNode)
{
if(iNode < mNodes.size())
{
return success;
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_SCENE_DEFINITION_H_
-#define DALI_SCENE_LOADER_SCENE_DEFINITION_H_
+#ifndef DALI_SCENE3D_LOADERER_SCENE_DEFINITION_H_
+#define DALI_SCENE3D_LOADERER_SCENE_DEFINITION_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/customization.h"
-#include "dali-scene-loader/public-api/node-definition.h"
-#include "dali-scene-loader/public-api/string-callback.h"
-#include "dali-scene-loader/public-api/utils.h"
+#include "dali-scene3d/public-api/loader/customization.h"
+#include "dali-scene3d/public-api/loader/node-definition.h"
+#include "dali-scene3d/public-api/loader/string-callback.h"
+#include "dali-scene3d/public-api/loader/utils.h"
// EXTERNAL INCLUDES
#include <memory>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
class MatrixStack;
* @brief Intermediate representation of a scene with functionality required to
* create DALi objects (Actors, Renderers) from it.
*/
-class DALI_SCENE_LOADER_API SceneDefinition
+class DALI_SCENE3D_API SceneDefinition
{
public: // TYPES
using NodePredicate = std::function<bool(const NodeDefinition&)>;
std::vector<Index> mRootNodeIds;
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_SCENE_DEFINITION_H_
+#endif //DALI_SCENE3D_LOADERER_SCENE_DEFINITION_H_
* limitations under the License.
*
*/
-#include "dali-scene-loader/public-api/shader-definition-factory.h"
+#include "dali-scene3d/public-api/loader/shader-definition-factory.h"
#include <cstring>
-#include "dali-scene-loader/internal/hash.h"
-#include "dali-scene-loader/public-api/blend-shape-details.h"
-#include "dali-scene-loader/public-api/node-definition.h"
+#include "dali-scene3d/internal/loader/hash.h"
+#include "dali-scene3d/public-api/loader/blend-shape-details.h"
+#include "dali-scene3d/public-api/loader/node-definition.h"
#include "dali/devel-api/common/map-wrapper.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
namespace
{
ShaderDefinition shaderDef;
shaderDef.mUseBuiltInShader = true;
- shaderDef.mRendererState = RendererState::DEPTH_TEST | RendererState::DEPTH_WRITE | RendererState::CULL_BACK;
+ shaderDef.mRendererState = RendererState::DEPTH_TEST | RendererState::DEPTH_WRITE | RendererState::CULL_BACK;
auto& materialDef = *receiver.mMaterialDef;
const bool hasTransparency = MaskMatch(materialDef.mFlags, MaterialDefinition::TRANSPARENCY);
return result;
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_SHADER_DEFINITION_FACTORY_H_
-#define DALI_SCENE_LOADER_SHADER_DEFINITION_FACTORY_H_
+#ifndef DALI_SCENE3D_LOADER_SHADER_DEFINITION_FACTORY_H_
+#define DALI_SCENE3D_LOADER_SHADER_DEFINITION_FACTORY_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
-#include "dali-scene-loader/public-api/index.h"
+#include "dali-scene3d/public-api/api.h"
+#include "dali-scene3d/public-api/loader/index.h"
// EXTERNAL INCLUDER
#include <memory>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
struct NodeDefinition;
class ResourceBundle;
-class DALI_SCENE_LOADER_API ShaderDefinitionFactory
+class DALI_SCENE3D_API ShaderDefinitionFactory
{
public:
ShaderDefinitionFactory();
const std::unique_ptr<Impl> mImpl;
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_SHADER_DEFINITION_FACTORY_H_
+#endif //DALI_SCENE3D_LOADER_SHADER_DEFINITION_FACTORY_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/shader-definition.h"
-#include "dali-scene-loader/public-api/utils.h"
-#include <dali-scene-loader/internal/graphics/builtin-shader-extern-gen.h>
+#include "dali-scene3d/public-api/loader/shader-definition.h"
+#include <dali-scene3d/internal/graphics/builtin-shader-extern-gen.h>
+#include "dali-scene3d/public-api/loader/utils.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
namespace
{
return shader;
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_SHADER_DEFINITION_H
-#define DALI_SCENE_LOADER_SHADER_DEFINITION_H
+#ifndef DALI_SCENE3D_LOADER_SHADER_DEFINITION_H
+#define DALI_SCENE3D_LOADER_SHADER_DEFINITION_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/renderer-state.h"
+#include "dali-scene3d/public-api/loader/renderer-state.h"
// EXTERNAL INCLUDES
#include <memory>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
/*
* @brief Defines a shader with paths to the files which define its
* vertex and fragment components, and a mapping of uniform names (which are
* used to refer to them in GLSL) to data.
*/
-struct DALI_SCENE_LOADER_API ShaderDefinition
+struct DALI_SCENE3D_API ShaderDefinition
{
using Vector = std::vector<std::pair<ShaderDefinition, Shader>>;
bool mUseBuiltInShader{false};
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_SHADER_DEFINITION_H
+#endif //DALI_SCENE3D_LOADER_SHADER_DEFINITION_H
-#ifndef DALI_SCENE_LOADER_SKELETON_H
-#define DALI_SCENE_LOADER_SKELETON_H
+#ifndef DALI_SCENE3D_LOADERER_SKELETON_H
+#define DALI_SCENE3D_LOADERER_SKELETON_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/index.h"
+#include "dali-scene3d/public-api/loader/index.h"
// EXTERNAL INCLUDES
#include "dali/public-api/common/vector-wrapper.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
/*
* @brief A set of joints (stored as node indices), and an optional root node index.
* @note Client code should not change the order of joints, as they are indexed by mesh vertex data.
* @note Client code should make no assumption about the relation of the joint IDs.
*/
-struct DALI_SCENE_LOADER_API SkeletonDefinition
+struct DALI_SCENE3D_API SkeletonDefinition
{
struct Joint
{
std::vector<Joint> mJoints;
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_SKELETON_H
+#endif //DALI_SCENE3D_LOADERER_SKELETON_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
* limitations under the License.
*
*/
-#include "dali-scene-loader/public-api/skinning-details.h"
+#include "dali-scene3d/public-api/loader/skinning-details.h"
#include "dali/public-api/animation/constraints.h"
#include "dali/public-api/object/property.h"
#include "dali/public-api/rendering/shader.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
const unsigned int Skinning::MAX_JOINTS = 64;
const std::string Skinning::BONE_UNIFORM_NAME = "uBone";
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_SKINNING_DETAILS_H_
-#define DALI_SCENE_LOADER_SKINNING_DETAILS_H_
+#ifndef DALI_SCENE3D_LOADER_SKINNING_DETAILS_H_
+#define DALI_SCENE3D_LOADER_SKINNING_DETAILS_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
+#include "dali-scene3d/public-api/api.h"
// EXTERNAL INCLUDES
#include <string>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
{
-struct DALI_SCENE_LOADER_API Skinning
+namespace Loader
+{
+struct DALI_SCENE3D_API Skinning
{
/*
* @brief Upper limit on the number of joints supported.
Skinning() = delete;
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif // DALI_SCENE_LOADER_SKINNING_DETAILS_H_
+#endif // DALI_SCENE3D_LOADER_SKINNING_DETAILS_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
* limitations under the License.
*
*/
-#include "dali-scene-loader/public-api/string-callback.h"
+#include "dali-scene3d/public-api/loader/string-callback.h"
#include "dali/integration-api/debug.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
void DefaultErrorCallback(const std::string& message)
{
DALI_LOG_ERROR("%s", message.c_str());
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_STRING_CALLBACK_H
-#define DALI_SCENE_LOADER_STRING_CALLBACK_H
+#ifndef DALI_SCENE3D_LOADER_STRING_CALLBACK_H
+#define DALI_SCENE3D_LOADER_STRING_CALLBACK_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
+#include "dali-scene3d/public-api/api.h"
// EXTERNAL INCLUDES
#include <functional>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
/*
* @brief A callback to post strings to.
/*
* @brief Simply passes the formatted message to LOGE().
*/
-DALI_SCENE_LOADER_API void DefaultErrorCallback(const std::string& message);
+DALI_SCENE3D_API void DefaultErrorCallback(const std::string& message);
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_STRING_CALLBACK_H
+#endif //DALI_SCENE3D_LOADER_STRING_CALLBACK_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL
-#include "dali-scene-loader/public-api/utils.h"
+#include "dali-scene3d/public-api/loader/utils.h"
// EXTERNAL
#include <stdarg.h>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
namespace
{
std::replace(path.begin(), path.end(), '\\', '/');
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_UTILS_H_
-#define DALI_SCENE_LOADER_UTILS_H_
+#ifndef DALI_SCENE3D_LOADER_UTILS_H_
+#define DALI_SCENE3D_LOADER_UTILS_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
+#include "dali-scene3d/public-api/api.h"
// EXTERNAL INCLUDES
#include <cctype>
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
/*
* @brief Fixed size backing buffer to use with std::ostreams where control over
* @note All stream insertions that would overflow the buffer that StreamBuffer
* was created with, will fail.
*/
-class DALI_SCENE_LOADER_API StreamBuffer : public std::basic_streambuf<char>
+class DALI_SCENE3D_API StreamBuffer : public std::basic_streambuf<char>
{
public:
StreamBuffer(char* buffer, size_t size) noexcept(true);
* which a message can be formatted into. Upon destruction, it throws a
* DaliException with the message.
*/
-class DALI_SCENE_LOADER_API ExceptionFlinger
+class DALI_SCENE3D_API ExceptionFlinger
{
public:
enum
/*
* @brief Formats the given printf-style varargs into a std::string.
*/
-DALI_SCENE_LOADER_API std::string FormatString(const char* format, ...);
+DALI_SCENE3D_API std::string FormatString(const char* format, ...);
/*
* @return The @n th bit in a bitmask.
*/
-DALI_SCENE_LOADER_API constexpr size_t NthBit(size_t n)
+DALI_SCENE3D_API constexpr size_t NthBit(size_t n)
{
return 1 << n;
}
/*
* @return Whether all of @a mask 's bits are set on @a value.
*/
-inline DALI_SCENE_LOADER_API bool MaskMatch(uint32_t value, uint32_t mask)
+inline DALI_SCENE3D_API bool MaskMatch(uint32_t value, uint32_t mask)
{
return (value & mask) == mask;
}
/*
* @brief Convert a four-letter(, null-terminated) string literal into a uint32_t.
*/
-inline DALI_SCENE_LOADER_API constexpr uint32_t FourCC(const char (&fourCC)[5])
+inline DALI_SCENE3D_API constexpr uint32_t FourCC(const char (&fourCC)[5])
{
return (fourCC[3] << 24) | (fourCC[2] << 16) | (fourCC[1] << 8) | fourCC[0];
}
* @param[in] b, compare string
* @return true if strings are equal
*/
-inline DALI_SCENE_LOADER_API bool CaseInsensitiveCharacterCompare(unsigned char a, unsigned char b)
+inline DALI_SCENE3D_API bool CaseInsensitiveCharacterCompare(unsigned char a, unsigned char b)
{
// Converts to lower case in the current locale.
return std::tolower(a) == std::tolower(b);
* @param[in] a, compare string
* @param[in] b, compare string
*/
-inline DALI_SCENE_LOADER_API bool CaseInsensitiveStringCompare(const std::string& a, const std::string& b)
+inline DALI_SCENE3D_API bool CaseInsensitiveStringCompare(const std::string& a, const std::string& b)
{
bool result = false;
if(a.length() == b.length())
* to true in case of failure (should only be checked if the returned string
* was empty()).
*/
-DALI_SCENE_LOADER_API std::string LoadTextFile(const char* path, bool* fail = nullptr);
+DALI_SCENE3D_API std::string LoadTextFile(const char* path, bool* fail = nullptr);
/*
* @brief Makes a number of calls to @a fn, passing to each one the given
* for performance and stability reasons.
*/
template<typename Func>
-inline DALI_SCENE_LOADER_API void VisitActor(Actor a, Func fn)
+inline DALI_SCENE3D_API void VisitActor(Actor a, Func fn)
{
fn(a);
* @brief Convenience function to set the given actor @a 's anchor point
* and parent origin to center.
*/
-inline DALI_SCENE_LOADER_API void SetActorCentered(Actor a)
+inline DALI_SCENE3D_API void SetActorCentered(Actor a)
{
a.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
a.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
{
using Type = uint32_t;
-enum DALI_SCENE_LOADER_API Values : Type
+enum DALI_SCENE3D_API Values : Type
{
NONE = 0x00,
FLIP_VERTICAL = 0x01,
/*
* @brief Makes... geometry for a textured quad.
*/
-DALI_SCENE_LOADER_API Geometry MakeTexturedQuadGeometry(TexturedQuadOptions::Type options = TexturedQuadOptions::NONE);
+DALI_SCENE3D_API Geometry MakeTexturedQuadGeometry(TexturedQuadOptions::Type options = TexturedQuadOptions::NONE);
/*
* @brief Fixes the path of a file. Replaces the '\\' separator by the '/' one.
* @param[in,out] path The path to be fixed.
*/
-DALI_SCENE_LOADER_API void ToUnixFileSeparators(std::string& path);
+DALI_SCENE3D_API void ToUnixFileSeparators(std::string& path);
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif /* DALI_SCENE_LOADER_UTILS_H_ */
+#endif /* DALI_SCENE3D_LOADER_UTILS_H_ */
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
* limitations under the License.
*
*/
-#include "dali-scene-loader/public-api/view-projection.h"
-#include "dali-scene-loader/public-api/utils.h"
+#include "dali-scene3d/public-api/loader/view-projection.h"
+#include "dali-scene3d/public-api/loader/utils.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
void ViewProjection::Update()
{
}
}
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#ifndef DALI_SCENE_LOADER_VIEW_PROJECTION_H_
-#define DALI_SCENE_LOADER_VIEW_PROJECTION_H_
+#ifndef DALI_SCENE3D_LOADER_VIEW_PROJECTION_H_
+#define DALI_SCENE3D_LOADER_VIEW_PROJECTION_H_
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// INTERNAL INCLUDES
-#include "dali-scene-loader/public-api/api.h"
+#include "dali-scene3d/public-api/api.h"
// EXTERNAL INCLUDES
#include "dali/public-api/math/matrix.h"
namespace Dali
{
-namespace SceneLoader
+namespace Scene3D
+{
+namespace Loader
{
/**
* @brief Contains view and projection matrices, also caching the view-projection
Matrix mViewProjection;
};
-} // namespace SceneLoader
+} // namespace Loader
+} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE_LOADER_VIEW_PROJECTION_H_
+#endif //DALI_SCENE3D_LOADER_VIEW_PROJECTION_H_
Application development package for Dali 3D engine toolkit - headers and package config
##############################
-# dali-scene-loader
+# dali-scene3d
##############################
-%define dali2_scene_loader dali2-scene-loader
-%package -n %{dali2_scene_loader}
+%define dali2_scene3d dali2-scene3d
+%package -n %{dali2_scene3d}
Summary: DLI scene loading library
Group: System/Libraries
License: Apache-2.0
Requires: dali2-toolkit
-%description -n %{dali2_scene_loader}
+%description -n %{dali2_scene3d}
Provides functionality for loading and displaying DLI format scenes. See README.md for more details.
-%package -n %{dali2_scene_loader}-devel
-Summary: Development components for dali-scene-loader
+%package -n %{dali2_scene3d}-devel
+Summary: Development components for dali-scene3d
Group: Development/Building
-Requires: %{dali2_scene_loader} = %{version}-%{release}
+Requires: %{dali2_scene3d} = %{version}-%{release}
-%description -n %{dali2_scene_loader}-devel
-Development components for dali-scene-loader.
+%description -n %{dali2_scene3d}-devel
+Development components for dali-scene3d.
%define dali_data_rw_dir %TZ_SYS_SHARE/dali/
%define dali_data_ro_dir %TZ_SYS_RO_SHARE/dali/
%{dali_toolkit_style_files}/default-feedback-theme.json
%{_datadir}/locale/*/LC_MESSAGES/*
-%files -n %{dali2_scene_loader}
+%files -n %{dali2_scene3d}
%if 0%{?enable_dali_smack_rules}
-%manifest dali-scene-loader.manifest-smack
+%manifest dali-scene3d.manifest-smack
%else
-%manifest dali-scene-loader.manifest
+%manifest dali-scene3d.manifest
%endif
%defattr(-,root,root,-)
-%{_libdir}/lib%{dali2_scene_loader}.so
+%{_libdir}/lib%{dali2_scene3d}.so
%license LICENSE
-%files -n %{dali2_scene_loader}-devel
+%files -n %{dali2_scene3d}-devel
%defattr(-,root,root,-)
-%{_includedir}/dali-scene-loader/public-api/*
-%{_libdir}/pkgconfig/dali2-scene-loader.pc
+%{_includedir}/dali-scene3d/public-api/*
+%{_libdir}/pkgconfig/dali2-scene3d.pc
projects / platform / core / uifw / dali-toolkit.git / commitdiff