Adding package scripts to build the sdformat13 library

The scripts build the sdformat13 library and its dependent libraries of tinyxml2, gz-cmake, gz-utils2, gz-math7 as well.

The build scripts are available to be run using either an Ubuntu 20.04+ distro or the ArchLinux distro.

The actual building of the library takes place in a Ubuntu 20.04 Docker image and the install artifacts are copied out of it.

The available libraries for use are exposed via the `3rdParty::sdformat` target.

The binary artifacts are `libsdformat13.so, `libtinyxml.a`, `libgz-utils2.so` and `libgz-math7.so`.

The package has been verified to build for both `x86_64` and `aarch64` Linux architectures and have been tested via adding using it as a dependency of the ROS2 Gem via specifying a local package directory via the `LY_PACKAGE_SERVER_URLS` ENV.

Signed-off-by: lumberyard-employee-dm <[email protected]>

Scripts/extras/pull_and_build_from_git.py

@@ -59,7 +59,7 @@ The following keys can exist at the root level or the target-platform level:
                           that is ingested by the lumberyard 3P system.
 * cmake_find_template   : If the find*.cmake in the target package requires template processing, then this is name of the template file that is used to
                           generate the contents of the find*.cmake file in the target package.
-                          * Note that either 'cmake_find_source' or 'cmake_fine_template' must be declared.
+                          * Note that either 'cmake_find_source' or 'cmake_find_template' must be declared.
 * cmake_find_target     : (required if prebuilt_source is not set) The name of the target find*.cmake file that is generated based on the template file and
                           additional arguments (described below)
 
@@ -99,7 +99,7 @@ The following keys can only exist at the target platform level as they describe
 
 * cmake_build_args                        : Additional build args to pass to cmake during the cmake build command
 
-* custom_build_cmd                        : A custom build script and arguments to build from the source that was pulled from git. This is a list 
+* custom_build_cmd                        : A custom build script and arguments to build from the source that was pulled from git. This is a list
                                             starting with the script to execute along with a list of optional arguments to the script. This is mutually
                                             exclusive from the cmake_generate_args and cmake_build_args options.
                                             Note: If the command is a python script, format the command with a {python} variable, for example: "{python} build_me.py"
@@ -884,7 +884,7 @@ class BuildInfo(object):
                                          env=env_to_use)
             if call_result.returncode != 0:
                 raise BuildError(f"Error executing custom install command {full_custom_install_cmd}")
-                
+
         # Allow libraries to define a list of files to include via a json script that stores folder paths and
         # individual files in the "Install_Paths" array
         custom_install_jsons = self.platform_config.get('custom_install_json', [])

package-system/sdformat/Dockerfile

@@ -0,0 +1,110 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+#
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+
+
+# PROTIP: ARG instructions declared before the FROM instruction
+# can only be used in the FROM instructions
+# Afterwards, it is required to redeclare the ARG instruction without a default value
+# to use IT in the build stage
+# Therefore it is better to not declare ARG instructions that are not used as part for the FROM instruction
+# until after it
+# https://docs.docker.com/engine/reference/builder/#understand-how-arg-and-from-interact
+# The cpu architecture to base the docker base script from
+ARG INPUT_ARCHITECTURE=amd64
+
+# The root to base the docker script base from
+ARG INPUT_IMAGE=ubuntu:20.04
+
+FROM ${INPUT_ARCHITECTURE}/${INPUT_IMAGE}
+
+# NOTE: Now it is safe to declare ARG instructions that are used in the build stage
+# of the image
+
+# The name of the build script to copy to the docker image to execute
+ARG INPUT_DOCKER_BUILD_SCRIPT=build.sh
+
+# The optional environment variable for list of folders in the mapped temp folders that represent additional 3P dependent packages
+ARG INPUT_DEPENDENT_PACKAGE_FOLDERS
+
+# Set the github tag for gz-cmake
+ARG INPUT_DEP_GZ_CMAKE_GIT_TAG=gz-cmake3_3.3.0
+ARG INPUT_DEP_TINYXML2_GIT_TAG=9.0.0
+# Pinning to the gz-math7 release which libsdformat has a dependency on
+ARG INPUT_DEP_GZ_MATH_GIT_TAG=gz-math7_7.2.0
+# Pinning to the gz-utils2 to the last release in September 2022
+# The libsdformat has an explicit dependencyt on gz-utils2
+ARG INPUT_DEP_GZ_UTILS_GIT_TAG=gz-utils2_2.0.0
+
+
+# Get access to the user ID and group ID of the user running the docker
+ARG USER_ID
+ARG GROUP_ID
+
+# The build subfolder where the binary artifacts are built to
+ARG INPUT_BUILD_FOLDER=build
+
+# The install subfolder where binary artifacts are copied to
+# It is being copied to /data/workspace/temp/instaall
+# which is a local filesystem mounted on the user machine
+ARG INPUT_INSTALL_FOLDER=install
+
+ENV WORKSPACE=/data/workspace
+ENV LOCAL_FILESYSTEM=$WORKSPACE/temp
+ENV DOCKER_BUILD_PATH=$WORKSPACE/$INPUT_BUILD_FOLDER
+ENV DOCKER_INSTALL_PATH=$LOCAL_FILESYSTEM/$INPUT_INSTALL_FOLDER
+ENV DOWNLOADED_PACKAGE_FOLDERS=$INPUT_DEPENDENT_PACKAGE_FOLDERS
+
+WORKDIR $WORKSPACE
+
+
+# Initialize apt cache
+RUN apt-get clean && apt-get update
+
+# Setup time zone and locale data (necessary for SSL and HTTPS packages)
+RUN DEBIAN_FRONTEND="noninteractive" apt-get -y install tzdata locales keyboard-configuration
+
+# Install the development packages needed to build libsdformat
+RUN apt-get install -y build-essential \
+                       cmake \
+                       git \
+                       ruby
+
+
+# Add a user called "user" that will inside the docker
+# It will have the same UID and GID as the outside user
+RUN addgroup --gid $GROUP_ID user && \
+    adduser --disabled-password --gecos '' --uid $USER_ID --gid $GROUP_ID user
+
+RUN chown -R user:user ${WORKSPACE}
+
+# Delete the deps folder as the root user in case it is owned by the root
+RUN sh -c "if [ -d ${WORKSPACE}/deps ]; then rm -rf ${WORKSPACE}/deps; fi"
+
+# Start running as the locally created user
+USER user
+
+# Pull dependent git repos needed to build libsdformat
+RUN mkdir -p ${WORKSPACE}/deps
+
+# Fetch tinyxml2
+# Fetch gz-cmake
+# Fetch gz-utils
+# Fetch gz-math
+RUN git clone https://github.com/leethomason/tinyxml2.git \
+    --single-branch --branch $INPUT_DEP_TINYXML2_GIT_TAG $WORKSPACE/deps/tinyxml2 && \
+    git clone https://github.com/gazebosim/gz-cmake.git \
+    --single-branch --branch $INPUT_DEP_GZ_CMAKE_GIT_TAG $WORKSPACE/deps/gz-cmake && \
+    git clone https://github.com/gazebosim/gz-utils.git \
+    --single-branch --branch $INPUT_DEP_GZ_UTILS_GIT_TAG $WORKSPACE/deps/gz-utils && \
+    git clone https://github.com/gazebosim/gz-math.git \
+    --single-branch --branch $INPUT_DEP_GZ_MATH_GIT_TAG $WORKSPACE/deps/gz-math
+
+# Prevent the copying of the src folder from being cached
+ARG CACHEBUST=1
+
+# Copy the build script specific to this Docker script in order to execute the build
+COPY ${INPUT_DOCKER_BUILD_SCRIPT} /data/workspace/

package-system/sdformat/Findsdformat.cmake.template

@@ -0,0 +1,152 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+#
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+set(LIB_NAME "sdformat")
+set(LIB_VERSION_FULL 13.5.0)
+set(LIB_VERSION_MAJOR 13)
+
+set(SDFORMAT_O3DE_NAMESPACE "3rdParty::$${LIB_NAME}")
+if (TARGET $${SDFORMAT_O3DE_NAMESPACE})
+    return()
+endif()
+
+# if we're not in O3DE, it's also extremely helpful to show a message to logs that indicate that this
+# library was successfully picked up, as opposed to the system one.
+# A good way to know if you're in O3DE or not is that O3DE sets various cache variables before
+# calling find_package, specifically, O3DE_ENGINE_NAME is always set very early:
+if (NOT O3DE_ENGINE_NAME)
+    message(STATUS "Using O3DE's sdformat library from $${CMAKE_CURRENT_LIST_DIR}")
+endif()
+
+set($${LIB_NAME}_INCLUDE_DIR_ROOT $${CMAKE_CURRENT_LIST_DIR}/$${LIB_NAME}/include)
+set($${LIB_NAME}_INCLUDE_DIRECTORIES $${$${LIB_NAME}_INCLUDE_DIR_ROOT}
+    $${$${LIB_NAME}_INCLUDE_DIR_ROOT}/gz/$${LIB_NAME}$${LIB_VERSION_MAJOR})
+set($${LIB_NAME}_LIBS_DIR $${CMAKE_CURRENT_LIST_DIR}/$${LIB_NAME}/lib)
+set($${LIB_NAME}_LIBRARY_RELEASE $${$${LIB_NAME}_LIBS_DIR}/$${CMAKE_SHARED_LIBRARY_PREFIX}$${LIB_NAME}$${LIB_VERSION_MAJOR}$${CMAKE_SHARED_LIBRARY_SUFFIX}.$${LIB_VERSION_FULL})
+
+add_library($${SDFORMAT_O3DE_NAMESPACE} SHARED IMPORTED GLOBAL)
+# If the find script is being called in an O3DE context use
+# the `ly_target_include_system_directories` function
+if(COMMAND ly_target_include_system_directories)
+    ly_target_include_system_directories(TARGET $${SDFORMAT_O3DE_NAMESPACE}
+        INTERFACE $${$${LIB_NAME}_INCLUDE_DIRECTORIES})
+else()
+    target_include_directories($${SDFORMAT_O3DE_NAMESPACE} SYSTEM
+        INTERFACE $${$${LIB_NAME}_INCLUDE_DIRECTORIES})
+endif()
+
+set_target_properties($${SDFORMAT_O3DE_NAMESPACE} PROPERTIES
+    IMPORTED_LOCATION $${$${LIB_NAME}_LIBRARY_RELEASE}
+)
+
+# If this Find script is run in context of O3DE,
+# make sure to copy over the symlinks as well to the cmake binary directory
+if (COMMAND ly_add_target_files)
+    ly_add_target_files(TARGETS $${SDFORMAT_O3DE_NAMESPACE}
+        FILES
+            "$${$${LIB_NAME}_LIBS_DIR}/$${CMAKE_SHARED_LIBRARY_PREFIX}$${LIB_NAME}$${LIB_VERSION_MAJOR}$${CMAKE_SHARED_LIBRARY_SUFFIX}.$${LIB_VERSION_MAJOR}"
+            "$${$${LIB_NAME}_LIBS_DIR}/$${CMAKE_SHARED_LIBRARY_PREFIX}$${LIB_NAME}$${LIB_VERSION_MAJOR}$${CMAKE_SHARED_LIBRARY_SUFFIX}")
+endif()
+
+# Add the tinyxml2 dependency
+set(tinyxml2_libname "tinyxml2")
+set(tinyxml2_include_directories "$${$${LIB_NAME}_INCLUDE_DIR_ROOT}")
+# Tinyxml2 is built as a STATIC library
+set(tinyxml2_lib_release "$${$${LIB_NAME}_LIBS_DIR}/$${CMAKE_STATIC_LIBRARY_PREFIX}$${tinyxml2_libname}$${CMAKE_SHARED_LIBRARY_SUFFIX}")
+
+# Add the 3rdParty::tinyxml2 target STATIC library
+set(tinyxml2_target "tinyxml2")
+set(tinyxml2_target_namespace "3rdParty::$${tinyxml2_target}")
+add_library($${tinyxml2_target_namespace} STATIC IMPORTED GLOBAL)
+# Add the include directories to the 3rdParty::tinyxml2 target
+if(COMMAND ly_target_include_system_directories)
+    ly_target_include_system_directories(TARGET $${tinyxml2_target_namespace}
+        INTERFACE $${tinyxml2_include_directories})
+else()
+    target_include_directories($${tinyxml2_target_namespace} SYSTEM
+        INTERFACE $${tinyxml2_include_directories})
+endif()
+
+# Associate the libtinyxml2.a file with the library location
+set_target_properties($${tinyxml2_target_namespace} PROPERTIES
+    IMPORTED_LOCATION $${tinyxml2_lib_release})
+
+# Add the gz-utils dependency
+set(gz_utils_raw_name "utils2")
+set(gz_utils_version_full "2.0.0")
+set(gz_utils_version_major "2")
+set(gz_utils_libname "gz-$${gz_utils_raw_name}")
+set(gz_utils_include_directories "$${$${LIB_NAME}_INCLUDE_DIR_ROOT}/gz/$${gz_utils_raw_name}")
+# gz-utils is built as a SHARED library
+set(gz_utils_lib_release "$${$${LIB_NAME}_LIBS_DIR}/$${CMAKE_SHARED_LIBRARY_PREFIX}$${gz_utils_libname}$${CMAKE_SHARED_LIBRARY_SUFFIX}.$${gz_utils_version_full}")
+
+# Add the 3rdParty::gz-utils target library
+set(gz_utils_target "gz-utils")
+set(gz_utils_target_namespace "3rdParty::$${gz_utils_target}")
+add_library($${gz_utils_target_namespace} STATIC IMPORTED GLOBAL)
+# Add the include directories to the 3rdParty::gz-utils target
+if(COMMAND ly_target_include_system_directories)
+    ly_target_include_system_directories(TARGET $${gz_utils_target_namespace}
+        INTERFACE $${gz_utils_include_directories})
+else()
+    target_include_directories($${gz_utils_target_namespace} SYSTEM
+        INTERFACE $${gz_utils_include_directories})
+endif()
+
+# Associate the libgz-utils2.so file with the library location
+set_target_properties($${gz_utils_target_namespace} PROPERTIES
+    IMPORTED_LOCATION $${gz_utils_lib_release})
+
+if (COMMAND ly_add_target_files)
+    ly_add_target_files(TARGETS $${gz_utils_target_namespace}
+        FILES
+            "$${$${LIB_NAME}_LIBS_DIR}/$${CMAKE_SHARED_LIBRARY_PREFIX}$${gz_utils_libname}$${CMAKE_SHARED_LIBRARY_SUFFIX}.$${gz_utils_version_major}"
+            "$${$${LIB_NAME}_LIBS_DIR}/$${CMAKE_SHARED_LIBRARY_PREFIX}$${gz_utils_libname}$${CMAKE_SHARED_LIBRARY_SUFFIX}")
+endif()
+
+# Add the gz-math dependency
+set(gz_math_raw_name "math7")
+set(gz_math_version_full "7.2.0")
+set(gz_math_version_major "7")
+set(gz_math_libname "gz-$${gz_math_raw_name}")
+set(gz_math_include_directories "$${$${LIB_NAME}_INCLUDE_DIR_ROOT}/gz/$${gz_math_raw_name}")
+# gz-math is built as a SHARED library
+set(gz_math_lib_release "$${$${LIB_NAME}_LIBS_DIR}/$${CMAKE_SHARED_LIBRARY_PREFIX}$${gz_math_libname}$${CMAKE_SHARED_LIBRARY_SUFFIX}.$${gz_math_version_full}")
+
+# Add the 3rdParty::gz-math target library
+set(gz_math_target "gz-math")
+set(gz_math_target_namespace "3rdParty::$${gz_math_target}")
+add_library($${gz_math_target_namespace} STATIC IMPORTED GLOBAL)
+# Add the include directories to the 3rdParty::gz-math target
+if(COMMAND ly_target_include_system_directories)
+    ly_target_include_system_directories(TARGET $${gz_math_target_namespace}
+        INTERFACE $${gz_math_include_directories})
+else()
+    target_include_directories($${gz_math_target_namespace} SYSTEM
+        INTERFACE $${gz_math_include_directories})
+endif()
+
+# Associate the libgz-math2.so file with the library location
+set_target_properties($${gz_math_target_namespace} PROPERTIES
+    IMPORTED_LOCATION $${gz_math_lib_release})
+
+if (COMMAND ly_add_target_files)
+    ly_add_target_files(TARGETS $${gz_math_target_namespace}
+        FILES
+            "$${$${LIB_NAME}_LIBS_DIR}/$${CMAKE_SHARED_LIBRARY_PREFIX}$${gz_math_libname}$${CMAKE_SHARED_LIBRARY_SUFFIX}.$${gz_math_version_major}"
+            "$${$${LIB_NAME}_LIBS_DIR}/$${CMAKE_SHARED_LIBRARY_PREFIX}$${gz_math_libname}$${CMAKE_SHARED_LIBRARY_SUFFIX}")
+endif()
+
+# Add the dependent libraries as target_link_libraries
+target_link_libraries($${SDFORMAT_O3DE_NAMESPACE}
+    INTERFACE
+        $${tinyxml_target_namespace}
+        $${gz_utils_target_namespace}
+        $${gz_math_target_namespace})
+
+set($${LIB_NAME}_FOUND True)

package-system/sdformat/build-archlinux.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+#
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+
+# The function below is used to check if the docker application
+# is installed via checking the ArchLinux package manager
+function check_docker_requirements()
+{
+    echo "Checking cross compiling requirements."
+    pkg_list=(docker docker-buildx docker-compose qemu qemu-user-static-binfmt)
+    for package_check in "${pkg_list[@]}"
+    do
+        echo "Checking package $package_check"
+        pacman -Qi $package_check > /dev/null 2>&1
+        if [ $? -ne 0 ]
+        then
+            echo ""
+            echo "Missing package $package_check. Make sure to install it with your local package manager."
+            echo ""
+            return 1
+        fi
+    done
+
+    # Only cross compilation of an ARM64 image on an x86_64 host is supported
+    if [ "${TARGET_ARCH}" = "aarch64" ]
+    then
+        # Make sure qemu-system-aarch64 is installed properly
+        pacman -Qi qemu-system-aarch64 > /dev/null 2>&1
+        if [ $? -ne 0 ]
+        then
+            echo ""
+            echo "qemu-system-aarch64 package needs to be installed."
+            echo "Use pacman to install it"
+            exit 1
+        fi
+
+        echo ""
+        echo "Cross compiling aarch64 on an amd64 machine validated."
+        echo ""
+    fi
+}
+
+source ./build-linux.sh "$@" "check_docker_requirements"

package-system/sdformat/build-host-os.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+#
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+
+# Query the Host OS from the the os-release file
+HOST_OS=$(cat /etc/os-release 2>/dev/null | grep "^NAME" | sed -E -e 's/NAME=(.+)/\1/')
+# Remove any surrounding quotes from the OS
+HOST_OS=$(sed -E 's/^"(.*)"$/\1/' <<< ${HOST_OS})
+
+if [ "${HOST_OS}" = "Arch Linux" ]; then
+    bash ./build-archlinux.sh "$@"
+elif [ "${HOST_OS}" = "Ubuntu" ]; then
+    bash ./build-ubuntu.sh "$@"
+else
+    echo "Build script for Host Platform \"${HOST_OS}\" is not available"
+    exit 1
+fi
+
+exit $?

package-system/sdformat/build-linux.sh

@@ -0,0 +1,162 @@
+#!/bin/bash
+
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+#
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+
+# This script will utilize Docker to build on either AMD64 or AARCH64 architectures. The script will
+# also build on both Ubuntu based docker images
+
+DOCKER_BUILD_SCRIPT=docker_build_sdformat.sh
+TARGET_INSTALL_FOLDER=install
+
+#
+# Collect the required arguments for this ubuntu docker-base build script
+#
+
+# Determine the host architecture
+CURRENT_HOST_ARCH=$(uname -m)
+
+# Use the host architecture if not supplied
+TARGET_ARCH=${1:-$(uname -m)}
+
+# Get the base docker image name
+DOCKER_IMAGE_NAME_BASE=${2:-sdformat13}
+
+# Get the ubuntu base version (20.04|22.04)
+# Default to Ubuntu 20.04
+UBUNTU_BASE=${3:-20.04}
+
+echo "Executing docker-based build from the following arguments"
+echo "    DOCKER_IMAGE_NAME_BASE=${DOCKER_IMAGE_NAME_BASE}"
+echo "    UBUNTU_BASE=${UBUNTU_BASE}"
+echo "    DOCKER_BUILD_SCRIPT=${DOCKER_BUILD_SCRIPT}"
+echo "    TARGET_INSTALL_FOLDER=${TARGET_INSTALL_FOLDER}"
+echo "    TARGET_ARCH=${TARGET_ARCH}"
+echo ""
+
+
+#
+# Make sure docker is installed
+#
+DOCKER_VERSION=$(docker --version)
+if [ $? -ne 0 ]
+then
+    echo "Required package docker is not installed"
+    echo "Follow instructions on https://docs.docker.com/engine/install to install docker properly"
+    exit 1
+fi
+echo "Detected Docker Version $DOCKER_VERSION"
+
+#
+# Check the target architecture and determine if the necessary cross compilation requirements are met
+#
+
+# If the host and target architecture does not match, make sure the necessary cross compilation packages are installed
+if [ "${CURRENT_HOST_ARCH}" != ${TARGET_ARCH} ]
+then
+    # Get the name of command to check that docker is installed
+    CHECK_DOCKER_FOR_OS_CALLBACK=$4
+    if [ "${CHECK_DOCKER_FOR_OS_CALLBACK}" == "" ]; then
+        echo "Missing argument 1: Docker callback function name. This is needed to validate that docker is installed"
+        exit 1
+    fi
+
+    # Triggers a OS specific callback for checking docker requirements
+    # This should be set for the host specific build script (archlinux, ubuntu, etc...)
+    ${CHECK_DOCKER_FOR_OS_CALLBACK}
+    # If the return code is non-0 then exit the script
+    # The callback function would output any error messages
+    return_code=$?
+    if [ $return_code -ne 0 ]; then
+        exit $return_code
+    fi
+else
+    echo "Building ${TARGET_ARCH} natively."
+fi
+
+
+# Setup the docker arguments
+if [ "${TARGET_ARCH}" = "x86_64" ]
+then
+    echo "Processing Docker for amd64"
+
+    DOCKER_INPUT_ARCHITECTURE=amd64
+    TARGET_DOCKER_PLATFORM_ARG=linux/amd64
+
+elif [ "${TARGET_ARCH}" = "aarch64" ]
+then
+    echo "Processing Docker for aarch64"
+
+    DOCKER_INPUT_ARCHITECTURE=arm64v8
+    TARGET_DOCKER_PLATFORM_ARG=linux/arm64/v8
+
+else
+    echo "Unsupported architecture ${TARGET_ARCH}"
+    exit 1
+fi
+
+
+#
+# Prepare the docker base context based on ${TEMP_FOLDER}
+mkdir -p ${TEMP_FOLDER}
+cp -f ${DOCKER_BUILD_SCRIPT} ${TEMP_FOLDER}/
+
+echo "Building on ubuntu public.ecr.aws/ubuntu/ubuntu:${UBUNTU_BASE}"
+
+# Build the Docker Image
+DOCKER_IMAGE_NAME=${DOCKER_IMAGE_NAME_BASE}_${DOCKER_INPUT_ARCHITECTURE}_3p
+echo DOCKER_IMAGE_NAME=${DOCKER_IMAGE_NAME}
+
+echo -e "Building the docker build script for ${DOCKER_IMAGE_NAME_BASE} on ${DOCKER_INPUT_ARCHITECTURE} for Ubuntu $1\n"
+CMD_DOCKER_BUILD="\
+docker build --build-arg INPUT_DOCKER_BUILD_SCRIPT=${DOCKER_BUILD_SCRIPT}\
+    --build-arg INPUT_ARCHITECTURE=${DOCKER_INPUT_ARCHITECTURE}\
+    --build-arg INPUT_IMAGE=ubuntu:${UBUNTU_BASE}\
+    --build-arg INPUT_DEPENDENT_PACKAGE_FOLDERS=${DOWNLOADED_PACKAGE_FOLDERS}\
+    --build-arg USER_ID=$(id -u)\
+    --build-arg GROUP_ID=$(id -g)\
+    -f Dockerfile -t ${DOCKER_IMAGE_NAME}:latest temp"
+echo ${CMD_DOCKER_BUILD}
+eval ${CMD_DOCKER_BUILD}
+if [ $? -ne 0 ]
+then
+    echo "Error occurred creating Docker image ${DOCKER_IMAGE_NAME}:latest."
+    exit 1
+fi
+
+# Prepare the target build folder to copy from the docker container on successful run of the docker script
+INSTALL_PACKAGE_PATH=${TEMP_FOLDER}/${TARGET_INSTALL_FOLDER}/
+
+# Run the build script in the docker image
+echo "Running build script in the docker image ${DOCKER_IMAGE_NAME}:latest"
+echo ""
+CMD_DOCKER_RUN="\
+docker run --platform ${TARGET_DOCKER_PLATFORM_ARG} \
+    --tty \
+    --user $(id -u):$(id -g)
+    -v ${TEMP_FOLDER}:/data/workspace/temp \
+    ${DOCKER_IMAGE_NAME}:latest /data/workspace/${DOCKER_BUILD_SCRIPT}"
+echo ${CMD_DOCKER_RUN}
+eval ${CMD_DOCKER_RUN}
+if [ $? -ne 0 ]
+then
+    echo Failed to build from docker image ${DOCKER_IMAGE_NAME}:latest
+    echo "To log into and troubleshoot the docker container, run the following command:"
+    echo ""
+    echo "docker run --platform ${TARGET_DOCKER_PLATFORM_ARG} -v ${TEMP_FOLDER}:/data/workspace/temp -it --tty ${DOCKER_IMAGE_NAME}:latest"
+    echo ""
+    exit 1
+fi
+
+echo "Build Complete"
+
+# Copy the build artifacts from the docker image
+
+
+echo "Built ${DOCKER_IMAGE_NAME_BASE} into ${INSTALL_PACKAGE_PATH} successfully"
+
+exit 0

package-system/sdformat/build-ubuntu.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+#
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+
+# The function below is used to check if the docker application
+# is installed via checking the ArchLinux package manager
+function check_docker_requirements()
+{
+    echo "Checking cross compiling requirements."
+    pkg_list=(docker-ce qemu binfmt-support qemu-user-static)
+    for package_check in "${pkg_list[@]}"
+    do
+        echo "Checking package $package_check"
+        dpkg -s $package_check > /dev/null 2>&1
+        if [ $? -ne 0 ]
+        then
+            echo ""
+            echo "Missing package $package_check. Make sure to install it with your local package manager."
+            echo ""
+            return 1
+        fi
+    done
+
+    # Only cross compilation of an ARM64 image on an x86_64 host is supported
+    if [ "${TARGET_ARCH}" = "aarch64" ]
+    then
+        # Make sure qemu-aarch64 is installed properly
+        QEMU_AARCH_COUNT=$(update-binfmts --display | grep qemu-aarch64 | wc -l)
+        if [ $QEMU_AARCH_COUNT -eq 0 ]
+        then
+            echo ""
+            echo "QEMU aarch64 binary format not registered."
+            echo "Run the following command to register"
+            echo ""
+            echo "sudo docker run --rm --privileged multiarch/qemu-user-static --reset -p yes"
+            echo ""
+            return 1
+        fi
+
+        echo ""
+        echo "Cross compiling aarch64 on an amd64 machine validated."
+        echo ""
+    fi
+}
+
+source ./build_linux.sh "$@" "check_docker_requirements"

package-system/sdformat/build_config.json

@@ -0,0 +1,48 @@
+{
+   "git_url":"https://github.com/gazebosim/sdformat.git",
+   "git_tag":"sdformat13_13.5.0",
+   "package_name":"sdformat",
+   "package_version":"13.5.0-rev0",
+   "package_url":"https://github.com/gazebosim/sdformat.git",
+   "package_license":"MIT",
+   "package_license_file":"LICENSE",
+   "cmake_find_target":"Findsdformat.cmake",
+   "Platforms":{
+      "Linux":{
+         "Linux":{
+            "cmake_find_template":"Findsdformat.cmake.template",
+            "custom_build_cmd": [
+               "./build-host-os.sh",
+               "x86_64",
+               "sdformat13",
+               "20.04"
+            ],
+            "custom_install_cmd": [
+               "./install-linux.sh",
+               "install"
+            ],
+            "custom_test_cmd" : [
+               "./test-linux.sh",
+               "x86_64"
+            ]
+         },
+         "Linux-aarch64":{
+            "cmake_find_template":"Findsdformat.cmake.template",
+            "custom_build_cmd": [
+               "./build-host-os.sh",
+               "aarch64",
+               "sdformat13",
+               "20.04"
+            ],
+            "custom_install_cmd": [
+               "./install-linux.sh",
+               "install"
+            ],
+            "custom_test_cmd" : [
+               "./test-linux.sh",
+               "aarch64"
+            ]
+         }
+      }
+   }
+}

package-system/sdformat/docker_build_sdformat.sh

@@ -0,0 +1,211 @@
+#!/bin/bash
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+#
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+
+LIB_NAME=sdformat
+# Validate the build directory
+BUILD_FOLDER=${DOCKER_BUILD_PATH}
+if [ "${BUILD_FOLDER}" == "" ]
+then
+    echo "Missing required build target folder environment"
+    exit 1
+elif [ "${BUILD_FOLDER}" == "temp" ]
+then
+    echo "Build target folder environment cannot be 'temp'"
+    exit 1
+fi
+
+# Set the install path from the DOCKER_INSTALL_PATH argument
+INSTALL_FOLDER=${DOCKER_INSTALL_PATH}
+
+# Stores array of each installed dependency after building locally
+DEP_INSTALL_PATHS=()
+
+# Get the base directory where the source file for dependencies will be fetched to
+GIT_DEPS_BASE=/data/workspace/deps
+GIT_DEPS_BUILD_ROOT=${GIT_DEPS_BASE}/build
+
+# Build the dependent tinyxml2 library
+DEP_NAME=tinyxml2
+GZ_TINYXML2_SRC_FOLDER=${GIT_DEPS_BASE}/$DEP_NAME
+GZ_TINYXML2_BUILD_FOLDER=${GIT_DEPS_BUILD_ROOT}/$DEP_NAME
+# Install the tinyxml2 library files to the local filesystem
+GZ_TINYXML2_INSTALL_FOLDER=${LOCAL_FILESYSTEM}/deps/install
+
+if [ -d ${GIT_DEPS_BUILD_ROOT} ]; then
+    rm -rf ${GIT_DEPS_BUILD_ROOT}
+fi
+
+# Append the tinyxml2 install folder
+DEP_INSTALL_PATHS+=( $GZ_TINYXML2_INSTALL_FOLDER )
+pushd $GZ_TINYXML2_SRC_FOLDER
+
+echo "Configuring $DEP_NAME"
+CMD="cmake -B ${GZ_TINYXML2_BUILD_FOLDER} -S. -DCMAKE_INSTALL_PREFIX=${GZ_TINYXML2_INSTALL_FOLDER} -DCMAKE_POSITION_INDEPENDENT_CODE=ON"
+echo $CMD
+eval $CMD
+if [ $? -ne 0 ]
+then
+    echo "Error configuring $DEP_NAME"
+    exit 1
+fi
+
+echo "Building and installing $DEP_NAME"
+CMD="cmake --build $GZ_TINYXML2_BUILD_FOLDER --target install --config Release"
+echo $CMD
+eval $CMD
+if [ $? -ne 0 ]
+then
+    echo "Error building $DEP_NAME"
+    exit 1
+fi
+
+popd
+
+# Build the dependent gz-cmake library
+DEP_NAME=gz-cmake
+GZ_CMAKE_SRC_FOLDER=${GIT_DEPS_BASE}/$DEP_NAME
+GZ_CMAKE_BUILD_FOLDER=${GIT_DEPS_BUILD_ROOT}/$DEP_NAME
+# Install gz-cmake to the mounted local filesystem
+GZ_CMAKE_INSTALL_FOLDER=${LOCAL_FILESYSTEM}/deps/install
+
+# Append the gz-cmake install folder
+DEP_INSTALL_PATHS+=( $GZ_CMAKE_INSTALL_FOLDER )
+
+pushd $GZ_CMAKE_SRC_FOLDER
+
+echo "Configuring $DEP_NAME"
+CMD="cmake -B ${GZ_CMAKE_BUILD_FOLDER} -S. -DCMAKE_INSTALL_PREFIX=${GZ_CMAKE_INSTALL_FOLDER} -DBUILD_TESTING=OFF"
+echo $CMD
+eval $CMD
+if [ $? -ne 0 ]
+then
+    echo "Error configuring $DEP_NAME"
+    exit 1
+fi
+
+echo "Building and installing $DEP_NAME"
+CMD="cmake --build $GZ_CMAKE_BUILD_FOLDER --target install --config Release"
+echo $CMD
+eval $CMD
+if [ $? -ne 0 ]
+then
+    echo "Error building $DEP_NAME"
+    exit 1
+fi
+
+popd
+
+# Build the dependent gz-utils library
+# NOTE: This must be done after gz-cmake it depends on that library
+DEP_NAME=gz-utils
+GZ_UTILS_SRC_FOLDER=${GIT_DEPS_BASE}/$DEP_NAME
+GZ_UTILS_BUILD_FOLDER=${GIT_DEPS_BUILD_ROOT}/$DEP_NAME
+# install gz-utils to the local filesystem
+GZ_UTILS_INSTALL_FOLDER=${LOCAL_FILESYSTEM}/deps/install
+
+# Append the gz-utils install folder
+DEP_INSTALL_PATHS+=( $GZ_UTILS_INSTALL_FOLDER )
+pushd $GZ_UTILS_SRC_FOLDER
+
+echo "Configuring $DEP_NAME"
+CMD="cmake -B ${GZ_UTILS_BUILD_FOLDER} -S. -DCMAKE_INSTALL_PREFIX=${GZ_UTILS_INSTALL_FOLDER} -DBUILD_TESTING=OFF"
+echo $CMD
+eval $CMD
+if [ $? -ne 0 ]
+then
+    echo "Error configuring $DEP_NAME"
+    exit 1
+fi
+
+echo "Building and installing $DEP_NAME"
+CMD="cmake --build $GZ_UTILS_BUILD_FOLDER --target install --config Release"
+echo $CMD
+eval $CMD
+if [ $? -ne 0 ]
+then
+    echo "Error building $DEP_NAME"
+    exit 1
+fi
+
+popd
+
+# Build the dependent gz-math library
+# NOTE: This must be done after gz-cmake and gz-utils as it depends on those libraries
+DEP_NAME=gz-math
+GZ_MATH_SRC_FOLDER=${GIT_DEPS_BASE}/$DEP_NAME
+GZ_MATH_BUILD_FOLDER=${GIT_DEPS_BUILD_ROOT}/$DEP_NAME
+GZ_MATH_INSTALL_FOLDER=${LOCAL_FILESYSTEM}/deps/install
+
+# Append the gz-math install folder
+DEP_INSTALL_PATHS+=( $GZ_MATH_INSTALL_FOLDER )
+pushd $GZ_MATH_SRC_FOLDER
+
+echo "Configuring $DEP_NAME"
+CMD="cmake -B ${GZ_MATH_BUILD_FOLDER} -S. -DCMAKE_INSTALL_PREFIX=${GZ_MATH_INSTALL_FOLDER} -DSKIP_SWIG=ON -DSKIP_PYBIND11=ON -DBUILD_TESTING=OFF"
+echo $CMD
+eval $CMD
+if [ $? -ne 0 ]
+then
+    echo "Error configuring $DEP_NAME"
+    exit 1
+fi
+
+echo "Building and installing $DEP_NAME"
+CMD="cmake --build $GZ_MATH_BUILD_FOLDER --target install --config Release"
+echo $CMD
+eval $CMD
+if [ $? -ne 0 ]
+then
+    echo "Error building $DEP_NAME"
+    exit 1
+fi
+
+popd
+
+# Now build the SDF library
+pushd ${LOCAL_FILESYSTEM}/src
+
+# Convert the dependent install path array in bash to a cmake list
+CMAKE_PREFIX_PATH=${DEP_INSTALL_PATHS[0]}
+# splace the first element of the array and then join with the semicolon CMake delimiter
+SPLICED_INSTALL_PATHS=(${DEP_INSTALL_PATHS[@]:1})
+CMAKE_PREFIX_PATH+=$(printf ";%s" "${SPLICED_INSTALL_PATHS[@]}")
+# Supply the CMAKE_PREFIX_PATH to allow the dependent libraries of gz-cmake to be located
+
+# Remove the build folder if it exist
+if [ -d ${BUILD_FOLDER} ]; then
+    rm -rf ${BUILD_FOLDER}
+fi
+
+echo "Configuring ${LIB_NAME}"
+CMD="cmake -B ${BUILD_FOLDER} -S. -DUSE_INTERNAL_URDF=ON -DBUILD_TESTING=OFF -DCMAKE_INSTALL_PREFIX=${INSTALL_FOLDER} -DCMAKE_PREFIX_PATH=\"${CMAKE_PREFIX_PATH}\""
+echo $CMD
+eval $CMD
+if [ $? -ne 0 ]
+then
+    echo "Error configuring ${LIB_NAME}"
+    exit 1
+fi
+
+if [ -d ${INSTALL_FOLDER} ]; then
+    echo "Removing artifacts from existing ${INSTALL_FOLDER}"
+    rm -rf ${INSTALL_FOLDER}
+fi
+echo "Building and installing ${LIB_NAME} to ${INSTALL_FOLDER}"
+CMD="cmake --build ${BUILD_FOLDER} --target install --config Release"
+echo $CMD
+eval $CMD
+if [ $? -ne 0 ]
+then
+    echo "Error building ${LIB_NAME}"
+    exit 1
+fi
+
+popd
+
+exit 0

package-system/sdformat/install-linux.sh

@@ -0,0 +1,88 @@
+#!/bin/bash
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+#
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+
+LIB_NAME=sdformat
+
+# Install from the install folder
+TARGET_INSTALL_FOLDER=$1
+if [ "${TARGET_INSTALL_FOLDER}" == "" ]
+then
+    echo "Missing the target install folder name to create the installation base from"
+    exit 1
+elif [ ${TARGET_INSTALL_FOLDER} == "src" ]
+then
+    echo "The target install folder cannot be 'src'"
+    exit 1
+fi
+
+SRC_PATH=${TEMP_FOLDER}/src
+BLD_PATH=${TEMP_FOLDER}/${TARGET_INSTALL_FOLDER}
+DEP_INSTALL_PATH=${TEMP_FOLDER}/deps/${TARGET_INSTALL_FOLDER}
+
+echo "SOURCE INSTALL FOLDER=${BLD_PATH}"
+echo "SOURCE DEPENDENCIES INSTALL FOLDER=${DEP_INSTALL_PATH}"
+echo "TARGET INSTALL ROOT=${TARGET_INSTALL_ROOT}"
+
+copy_folder_to_target() {
+
+    local FOLDER=$1
+
+    CMD="cp -rf ${BLD_PATH}/${FOLDER} ${TARGET_INSTALL_ROOT}/"
+    echo $CMD
+    $CMD
+    if [ $? -ne 0 ]
+    then
+        echo "Error copying the ${FOLDER} folder ${BLD_PATH}/${FOLDER} to ${TARGET_INSTALL_ROOT}/${FOLDER}"
+        exit 1
+    fi
+}
+
+rm -rf ${TARGET_INSTALL_ROOT}
+mkdir -p ${TARGET_INSTALL_ROOT}
+
+
+# Copy the license file
+echo "Copying LICENSE to ${TARGET_INSTALL_ROOT}"
+cp -f ${SRC_PATH}/LICENSE ${TARGET_INSTALL_ROOT}/
+if [ $? -ne 0 ]
+then
+    echo "Copying LICENSE to ${TARGET_INSTALL_ROOT} failed."
+    exit 1
+fi
+
+# Copy the sdformat include folder
+copy_folder_to_target include
+
+# Copy the bin folder
+# copy_folder_to_target bin
+
+# Copy the sdformat lib folder
+copy_folder_to_target lib
+
+# Copy the dependent libraries include files for sdformat (tinyxml2, gz-utils, gz-math)
+# exclude the gz-cmake folder, since it is not needed to use the library.
+
+# Change directory to the dependency install path so that `find`` can use relative paths
+pushd ${DEP_INSTALL_PATH}/include > /dev/null
+# Use cp --parents to preserve the directory structure
+# Skip copying directories via the `find -not -type d` command
+find . -path ./gz/cmake* -prune -o \( -not -type d \) -print | xargs -i{} cp --parents {} ${TARGET_INSTALL_ROOT}/include
+
+# Change back to 'temp' directory
+popd > /dev/null
+
+# Now change to the lib directory
+pushd ${DEP_INSTALL_PATH}/lib > /dev/null
+# Copy the dependent library archive and shared object files for sdformat (tinyxml2, gz-utils, gz-math)
+find . -not -type d | xargs -i{} cp --parents {} ${TARGET_INSTALL_ROOT}/lib
+
+# Change back to 'temp' directory
+popd > /dev/null
+echo "Custom Install for ${LIB_NAME} finished successfully"
+
+exit 0

package-system/sdformat/test-linux.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+#
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+
+# The expected SDF Version
+EXPECTED_SDF_VERSION="13.5.0"
+
+# Reset any existing test folder
+rm -rf temp/build_test
+mkdir temp/build_test
+
+# Make sure we are running on the target architecture
+TARGET_ARCH=${1:-$(uname -m)}
+
+CURRENT_HOST_ARCH=$(uname -m)
+if [ "${CURRENT_HOST_ARCH}" != ${TARGET_ARCH} ]
+then
+    echo "Warning: Tests for packages on target ${TARGET_ARCH} can only be run on ${TARGET_ARCH}. Skipping tests."
+    exit 0
+fi
+
+# Build the test program
+cmake -S test -B temp/build_test -DCMAKE_MODULE_PATH="$PACKAGE_ROOT" -DCMAKE_BUILD_TYPE=Release
+if [ $? -ne 0 ]
+then
+    echo "Error generating the test project"
+    exit 1
+fi
+
+cmake --build temp/build_test
+if [ $? -ne 0 ]
+then
+    echo "Error building the test project"
+    exit 1
+fi
+
+CMD="./temp/build_test/test_sdformat ${EXPECTED_SDF_VERSION}"
+echo "Executing $CMD"
+$CMD
+if [ $? -ne 0 ]
+then
+    echo "Package test failed"
+    exit 1
+fi
+
+echo "Package test passed"
+
+exit 0

package-system/sdformat/test/CMakeLists.txt

@@ -0,0 +1,18 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+#
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+
+cmake_minimum_required(VERSION 3.20)
+
+project(test_sdformat VERSION 1.0 LANGUAGES CXX)
+
+find_package(sdformat)
+
+add_executable(test_sdformat test_sdformat.cpp)
+
+# Make sure the O3DE sdformat is being used
+target_link_libraries(test_sdformat PRIVATE 3rdParty::sdformat)

package-system/sdformat/test/test_sdformat.cpp

@@ -0,0 +1,53 @@
+/*
+ Copyright (c) Contributors to the Open 3D Engine Project.
+ For complete copyright and license terms please see the LICENSE at the root of this distribution.
+
+ SPDX-License-Identifier: Apache-2.0 OR MIT
+*/
+
+#include <cstdio>
+#include <string_view>
+
+// This is just a basic include and compile test
+
+#include <sdformat.hh>
+
+int main(int argc, char** argv)
+{
+    if (argc < 2)
+    {
+        printf("Usage: %s [SDF VERSION_FULL]\n", argv[0]);
+        return 1;
+    }
+
+    std::string_view sdfVersionFull = argv[1];
+    printf(R"(Validating SDF version "%.*s": )", sdfVersionFull.size(), sdfVersionFull.data());
+
+    if (sdfVersionFull != SDF_VERSION_FULL)
+    {
+        printf("Failure\n"
+            R"(SDformat SDF_VERSION_FULL returned a version of "%s". Expecting "%.*s".)" "\n",
+            SDF_VERSION_FULL, sdfVersionFull.size(), sdfVersionFull.data());
+        return 1;
+    }
+    else
+    {
+        printf("OK\n");
+    }
+
+    sdf::SDF defaultSdf;
+    const std::string& sdfVersion = defaultSdf.Version();
+
+    printf(R"(Validating new SDF object has a non-empty version string: )");
+    if (sdfVersion.empty())
+    {
+        printf("Failure\n" "SDF object version string is empty\n");
+        return 1;
+    }
+    else
+    {
+        printf("OK\n");
+    }
+
+    return 0;
+}

package_build_list_host_linux-aarch64.json

@@ -35,6 +35,7 @@
         "pyside2-5.15.2.1-py3.10-rev4-linux-aarch64": "Scripts/extras/pull_and_build_from_git.py ../../package-system/pyside2 --platform-name Linux-aarch64 --clean",
         "python-3.10.5-rev4-linux-aarch64": "Scripts/extras/pull_and_build_from_git.py ../../package-system/python --platform-name Linux-aarch64 --clean",
         "qt-5.15.2-rev8-linux-aarch64": "Scripts/extras/pull_and_build_from_git.py ../../package-system/Qt --platform-name Linux-aarch64 --clean",
+        "sdformat-13.5.0-rev0-linux-aarch64": "Scripts/extras/pull_and_build_from_git.py ../../package-system/sdformat --platform-name Linux-aarch64 --clean",
         "SPIRVCross-2021.04.29-rev1-linux-aarch64": "Scripts/extras/pull_and_build_from_git.py ../../package-system/SPIRVCross --platform-name Linux-aarch64 --clean",
         "SQLite-3.37.2-rev1-linux-aarch64": "Scripts/extras/pull_and_build_from_git.py ../../package-system/sqlite --platform-name Linux-aarch64 --clean",
         "squish-ccr-deb557d-rev1-linux-aarch64": "Scripts/extras/pull_and_build_from_git.py ../../package-system/squish-ccr --platform-name Linux-aarch64 --clean",
@@ -75,6 +76,7 @@
         "pyside2-5.15.2.1-py3.10-rev4-linux-aarch64": "package-system/pyside2/temp/pyside2-linux-aarch64",
         "python-3.10.5-rev4-linux-aarch64": "package-system/python/temp/python-linux-aarch64",
         "qt-5.15.2-rev8-linux-aarch64": "package-system/Qt/temp/qt-linux-aarch64",
+        "sdformat-13.5.0-rev0-linux-aarch64": "package-system/sdformat/temp/sdformat-linux-aarch64",
         "SPIRVCross-2021.04.29-rev1-linux-aarch64": "package-system/SPIRVCross/temp/SPIRVCross-linux-aarch64",
         "SQLite-3.37.2-rev1-linux-aarch64": "package-system/sqlite/temp/SQLite-linux-aarch64",
         "squish-ccr-deb557d-rev1-linux-aarch64": "package-system/squish-ccr/temp/squish-ccr-linux-aarch64",

package_build_list_host_linux.json

@@ -31,6 +31,8 @@
         "NvCloth-v1.1.6-4-gd243404-pr58-rev1-linux": "package-system/NvCloth/build_package_image.py --platform-name linux",
         "poly2tri-7f0487a-rev1-linux": "package-system/poly2tri/build_package_image.py --platform-name linux",
         "v-hacd-2.3-1a49edf-rev1-linux": "package-system/v-hacd/build_package_image.py --platform-name linux",
+        "sdformat-13.5.0-rev0-linux": "Scripts/extras/pull_and_build_from_git.py ../../package-system/sdformat --platform-name Linux --clean",
+        "sdformat-13.5.0-rev0-linux-aarch64": "Scripts/extras/pull_and_build_from_git.py ../../package-system/sdformat --platform-name Linux-aarch64 --clean",
         "SPIRVCross-2021.04.29-rev1-linux": "Scripts/extras/pull_and_build_from_git.py ../../package-system/SPIRVCross --platform-name Linux --package-root ../../package-system --clean",
         "SQLite-3.37.2-rev1-linux": "Scripts/extras/pull_and_build_from_git.py ../../package-system/sqlite --platform-name Linux --package-root ../../package-system --clean",
         "squish-ccr-deb557d-rev1-linux": "Scripts/extras/pull_and_build_from_git.py ../../package-system/squish-ccr --platform-name Linux --clean",
@@ -71,6 +73,8 @@
         "openimageio-opencolorio-2.3.17-rev2-linux": "package-system/openimageio-opencolorio/temp/package-linux",
         "OpenSSL-1.1.1t-rev1-linux": "package-system/OpenSSL/temp/OpenSSL-linux",
         "OpenSSL-1.1.1t-rev1-linux-aarch64": "package-system/OpenSSL/temp/OpenSSL-linux-aarch64",
+        "sdformat-13.5.0-rev0-linux": "package-system/sdformat/temp/sdformat-linux",
+        "sdformat-13.5.0-rev0-linux-aarch64": "package-system/sdformat/temp/sdformat-linux-aarch64",
         "SPIRVCross-2021.04.29-rev1-linux": "package-system/SPIRVCross-linux",
         "squish-ccr-deb557d-rev1-linux": "package-system/squish-ccr/temp/squish-ccr-linux",
         "squish-ccr-deb557d-rev1-linux-aarch64": "package-system/squish-ccr/temp/squish-ccr-linux-aarch64",