From 7ecbd2e8d10fde34fbde67401f6b7f0466e579a3 Mon Sep 17 00:00:00 2001 From: Elias Steurer Date: Thu, 31 Aug 2023 14:53:59 +0200 Subject: [PATCH] Add default Godot project with GDExtension Add Godot Editor download Add Godot Editor start in launch.json --- .gitignore | 1 + .gitmodules | 4 + .vscode/launch.json | 14 + CMakeLists.txt | 5 + .../Godot/GDExtention/CMakeLists.txt | 128 +++++ .../Godot/GDExtention/CMakePresets.json | 87 ++++ .../Godot/GDExtention/cmake/ClangFormat.cmake | 32 ++ .../GDExtention/cmake/CompilerWarnings.cmake | 115 +++++ .../cmake/GetGitRevisionDescription.cmake | 284 +++++++++++ .../cmake/GetGitRevisionDescription.cmake.in | 43 ++ .../GDExtention/cmake/GitVersionInfo.cmake | 46 ++ .../Godot/GDExtention/cmake/ccache.cmake | 22 + .../Godot/GDExtention/extern/godot-cpp | 1 + .../Godot/GDExtention/src/CMakeLists.txt | 15 + .../GDExtention/src/GDExtensionTemplate.cpp | 32 ++ .../GDExtention/src/GDExtensionTemplate.h | 20 + .../GDExtention/src/RegisterExtension.cpp | 74 +++ .../GDExtention/src/ScreenPlayWallpaper.cpp | 475 ++++++++++++++++++ .../GDExtention/src/ScreenPlayWallpaper.h | 135 +++++ .../Godot/GDExtention/src/Version.h.in | 45 ++ .../GDExtention/templates/CMakeLists.txt | 41 ++ .../templates/template.debug.gdextension.in | 10 + .../templates/template.release.gdextension.in | 10 + .../Godot/ScreenPlayGodot/.gitattributes | 2 + .../Godot/ScreenPlayGodot/.gitignore | 2 + .../Godot/ScreenPlayGodot/export_presets.cfg | 61 +++ .../Godot/ScreenPlayGodot/icon.svg | 1 + .../Godot/ScreenPlayGodot/icon.svg.import | 37 ++ .../Godot/ScreenPlayGodot/main.gd | 15 + .../Godot/ScreenPlayGodot/main.tscn | 6 + .../Godot/ScreenPlayGodot/project.godot | 21 + Tools/defines.py | 1 + Tools/requirements.txt | 3 +- Tools/setup.py | 2 + Tools/setup_godot.py | 58 +++ 35 files changed, 1847 insertions(+), 1 deletion(-) create mode 100644 .gitmodules create mode 100644 ScreenPlayWallpaper/Godot/GDExtention/CMakeLists.txt create mode 100644 ScreenPlayWallpaper/Godot/GDExtention/CMakePresets.json create mode 100644 ScreenPlayWallpaper/Godot/GDExtention/cmake/ClangFormat.cmake create mode 100644 ScreenPlayWallpaper/Godot/GDExtention/cmake/CompilerWarnings.cmake create mode 100644 ScreenPlayWallpaper/Godot/GDExtention/cmake/GetGitRevisionDescription.cmake create mode 100644 ScreenPlayWallpaper/Godot/GDExtention/cmake/GetGitRevisionDescription.cmake.in create mode 100644 ScreenPlayWallpaper/Godot/GDExtention/cmake/GitVersionInfo.cmake create mode 100644 ScreenPlayWallpaper/Godot/GDExtention/cmake/ccache.cmake create mode 160000 ScreenPlayWallpaper/Godot/GDExtention/extern/godot-cpp create mode 100644 ScreenPlayWallpaper/Godot/GDExtention/src/CMakeLists.txt create mode 100644 ScreenPlayWallpaper/Godot/GDExtention/src/GDExtensionTemplate.cpp create mode 100644 ScreenPlayWallpaper/Godot/GDExtention/src/GDExtensionTemplate.h create mode 100644 ScreenPlayWallpaper/Godot/GDExtention/src/RegisterExtension.cpp create mode 100644 ScreenPlayWallpaper/Godot/GDExtention/src/ScreenPlayWallpaper.cpp create mode 100644 ScreenPlayWallpaper/Godot/GDExtention/src/ScreenPlayWallpaper.h create mode 100644 ScreenPlayWallpaper/Godot/GDExtention/src/Version.h.in create mode 100644 ScreenPlayWallpaper/Godot/GDExtention/templates/CMakeLists.txt create mode 100644 ScreenPlayWallpaper/Godot/GDExtention/templates/template.debug.gdextension.in create mode 100644 ScreenPlayWallpaper/Godot/GDExtention/templates/template.release.gdextension.in create mode 100644 ScreenPlayWallpaper/Godot/ScreenPlayGodot/.gitattributes create mode 100644 ScreenPlayWallpaper/Godot/ScreenPlayGodot/.gitignore create mode 100644 ScreenPlayWallpaper/Godot/ScreenPlayGodot/export_presets.cfg create mode 100644 ScreenPlayWallpaper/Godot/ScreenPlayGodot/icon.svg create mode 100644 ScreenPlayWallpaper/Godot/ScreenPlayGodot/icon.svg.import create mode 100644 ScreenPlayWallpaper/Godot/ScreenPlayGodot/main.gd create mode 100644 ScreenPlayWallpaper/Godot/ScreenPlayGodot/main.tscn create mode 100644 ScreenPlayWallpaper/Godot/ScreenPlayGodot/project.godot create mode 100644 Tools/setup_godot.py diff --git a/.gitignore b/.gitignore index 281ac916..be657cd4 100644 --- a/.gitignore +++ b/.gitignore @@ -261,3 +261,4 @@ cython_debug/ /ThirdParty/qml-archive/** /ThirdParty/qml-plausible/ /ThirdParty/ffmpeg/** +/Tools/Apps/Godot/* diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 00000000..d9f3cdde --- /dev/null +++ b/.gitmodules @@ -0,0 +1,4 @@ +[submodule "ScreenPlayWallpaper/Godot/GDExtention/extern/godot-cpp"] + path = ScreenPlayWallpaper/Godot/GDExtention/extern/godot-cpp + url = https://github.com/godotengine/godot-cpp.git + branch = 4.1 diff --git a/.vscode/launch.json b/.vscode/launch.json index 56cef0bb..6ec72414 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -22,6 +22,20 @@ ], "visualizerFile": "${workspaceFolder}/.vscode/qt.natvis.xml" }, + { + "name": "Godot Editor", + "type": "cppvsdbg", + "request": "launch", + "program": "${workspaceFolder}\\Tools\\Apps\\Godot\\Godot_v4.1.1-stable_win64.exe", + "args": [ + "--path", + "${workspaceFolder}\\ScreenPlayWallpaper\\Godot\\ScreenPlayGodot", + "--editor" + ], + "stopAtEntry": false, + "preLaunchTask": "CMake: build", + "externalConsole": false + }, { "name": "macOS Launch", "type": "lldb", diff --git a/CMakeLists.txt b/CMakeLists.txt index 9142baf7..2679eb2e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -27,6 +27,7 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) set(CMAKE_CXX_STANDARD 20) set(THIRD_PARTY_PATH "${CMAKE_CURRENT_SOURCE_DIR}/ThirdParty/") +option(GODOT_WALLPAPER "Godot Wallpaper support" ON) option(OSX_BUNDLE "Enable distribution macOS bundle" OFF) set(CMAKE_OSX_DEPLOYMENT_TARGET "13.0") @@ -122,6 +123,10 @@ add_subdirectory(ScreenPlayWidget) add_subdirectory(ScreenPlayUtil) add_subdirectory(ScreenPlayWeather) +if(GODOT_WALLPAPER) + add_subdirectory(ScreenPlayWallpaper/Godot/GDExtention) +endif() + if(${SCREENPLAY_TESTS}) enable_testing() endif() diff --git a/ScreenPlayWallpaper/Godot/GDExtention/CMakeLists.txt b/ScreenPlayWallpaper/Godot/GDExtention/CMakeLists.txt new file mode 100644 index 00000000..41a43cf2 --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/CMakeLists.txt @@ -0,0 +1,128 @@ +# SPDX-License-Identifier: Unlicense + +cmake_minimum_required( VERSION 3.22 ) + +message( STATUS "Using CMake ${CMAKE_VERSION}" ) + +# Require out-of-source builds +file( TO_CMAKE_PATH "${PROJECT_BINARY_DIR}/CMakeLists.txt" LOC_PATH ) + +if ( EXISTS "${LOC_PATH}" ) + message( FATAL_ERROR "You cannot build in the source directory. Please use a build subdirectory." ) +endif() + +# Add paths to modules +list( APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/" ) + +# Turn on link time optimization for everything +set( CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE ON ) + +# Output compile commands to compile_commands.json (for debugging CMake issues) +set( CMAKE_EXPORT_COMPILE_COMMANDS ON ) + +# Build universal lib on macOS +# Note that CMAKE_OSX_ARCHITECTURES must be set before project(). +if ( APPLE ) + set( CMAKE_OSX_ARCHITECTURES "x86_64;arm64" CACHE STRING "" ) +endif() + +# Main project information +project( GDExtensionTemplate + LANGUAGES + CXX + VERSION + 0.1.0 +) + +# Create our library +add_library( ${PROJECT_NAME} SHARED ) + +target_compile_features( ${PROJECT_NAME} + PRIVATE + cxx_std_17 +) + +# LIB_ARCH is the architecture being built. It is set to the build system's architecture. +# For macOS, we build a universal library (both arm64 and x86_64). +set( LIB_ARCH ${CMAKE_SYSTEM_PROCESSOR} ) +if ( APPLE ) + set( LIB_ARCH "universal" ) +endif() + +# LIB_DIR is where the actual library ends up. This is used in both the build directory and the +# install directory and needs to be consistent with the paths in the gdextension file. +# e.g. linux.release.x86_64 = "lib/Linux-x86_64/libGDExtensionTemplate.so" +set( LIB_DIR "lib/${CMAKE_SYSTEM_NAME}-${LIB_ARCH}" ) + +message( STATUS "Building ${PROJECT_NAME} for ${LIB_ARCH} on ${CMAKE_SYSTEM_NAME}") + +# BUILD_OUTPUT_DIR is where we put the resulting library (in the build directory) +set( BUILD_OUTPUT_DIR "${PROJECT_BINARY_DIR}/${PROJECT_NAME}/" ) + +set_target_properties( ${PROJECT_NAME} + PROPERTIES + CXX_VISIBILITY_PRESET hidden + VISIBILITY_INLINES_HIDDEN true + RUNTIME_OUTPUT_DIRECTORY "${BUILD_OUTPUT_DIR}/${LIB_DIR}" + LIBRARY_OUTPUT_DIRECTORY "${BUILD_OUTPUT_DIR}/${LIB_DIR}" +) + +if( NOT DEFINED CMAKE_DEBUG_POSTFIX ) + set_target_properties( ${PROJECT_NAME} + PROPERTIES + DEBUG_POSTFIX "-d" + ) +endif() + +# Warnings +include( CompilerWarnings ) + +# Create and include version info file from git +include( GitVersionInfo ) + +add_subdirectory( src ) + +# Install library and extension file in ${CMAKE_INSTALL_PREFIX}/${PROJECT_NAME} +set( INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/${PROJECT_NAME}/" ) + +message( STATUS "Install directory: ${INSTALL_DIR}") + +install( TARGETS ${PROJECT_NAME} + LIBRARY + DESTINATION ${INSTALL_DIR}/${LIB_DIR} + RUNTIME + DESTINATION ${INSTALL_DIR}/${LIB_DIR} +) + +add_subdirectory( templates ) + +# ccache +# Turns on ccache if found +include( ccache ) + +# Formatting +# Adds a custom target to format all the code at once +include( ClangFormat ) + +# godot-cpp +# From here: https://github.com/godotengine/godot-cpp +if ( NOT EXISTS "${CMAKE_CURRENT_LIST_DIR}/extern/godot-cpp/Makefile" ) + message( + FATAL_ERROR + "[${PROJECT_NAME}] The godot-cpp submodule was not downloaded. Please update submodules: git submodule update --init --recursive." + ) +endif() + +set( GODOT_CPP_SYSTEM_HEADERS ON CACHE BOOL "" FORCE ) + +add_subdirectory( extern/godot-cpp ) + +set_target_properties( godot-cpp + PROPERTIES + CXX_VISIBILITY_PRESET hidden # visibility needs to be the same as the main library +) + +target_link_libraries( ${PROJECT_NAME} + PRIVATE + godot-cpp +) diff --git a/ScreenPlayWallpaper/Godot/GDExtention/CMakePresets.json b/ScreenPlayWallpaper/Godot/GDExtention/CMakePresets.json new file mode 100644 index 00000000..2f925072 --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/CMakePresets.json @@ -0,0 +1,87 @@ +{ + "version": 5, + "cmakeMinimumRequired": { + "major": 3, + "minor": 23, + "patch": 0 + }, + "configurePresets": [ + { + "name": "default", + "displayName": "default", + "description": "Default preset that are inherited by all", + "generator": "Ninja", + "hidden": true, + "binaryDir": "${sourceDir}/../build_MyGodotProject" + }, + { + "name": "default-windows", + "displayName": "64bit Windows", + "description": "Windows only!", + "inherits": "default", + "condition": { + "type": "equals", + "lhs": "${hostSystemName}", + "rhs": "Windows" + }, + "toolset": { + "value": "host=x64", + "strategy": "external" + }, + "architecture": { + "value": "x64", + "strategy": "external" + }, + "cacheVariables": { + "CMAKE_C_COMPILER": "cl.exe", + "CMAKE_CXX_COMPILER": "cl.exe" + } + }, + { + "name": "linux-debug", + "displayName": "64bit Debug Linux", + "description": "Linux only!", + "generator": "Ninja", + "condition": { + "type": "equals", + "lhs": "${hostSystemName}", + "rhs": "Linux" + }, + "cacheVariables": { + "CMAKE_CXX_COMPILER": "g++", + "CMAKE_C_COMPILER": "gcc", + "CMAKE_BUILD_TYPE": "Debug" + } + }, + { + "name": "osx-debug", + "displayName": "64bit Debug osx", + "description": "Osx only!", + "generator": "Ninja", + "condition": { + "type": "equals", + "lhs": "${hostSystemName}", + "rhs": "Darwin" + }, + "cacheVariables": { + "CMAKE_CXX_COMPILER": "clang++", + "CMAKE_C_COMPILER": "clang", + "CMAKE_BUILD_TYPE": "Debug" + } + } + ], + "buildPresets": [ + { + "name": "linux-debug", + "configurePreset": "linux-debug" + }, + { + "name": "default-windows", + "configurePreset": "default-windows" + }, + { + "name": "osx-debug", + "configurePreset": "osx-debug" + } + ] +} diff --git a/ScreenPlayWallpaper/Godot/GDExtention/cmake/ClangFormat.cmake b/ScreenPlayWallpaper/Godot/GDExtention/cmake/ClangFormat.cmake new file mode 100644 index 00000000..a6eb8a0b --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/cmake/ClangFormat.cmake @@ -0,0 +1,32 @@ +# SPDX-License-Identifier: Unlicense + +find_program( CLANG_FORMAT_PROGRAM NAMES clang-format ) + +if ( CLANG_FORMAT_PROGRAM ) + # get version information + execute_process( + COMMAND "${CLANG_FORMAT_PROGRAM}" --version + OUTPUT_VARIABLE CLANG_FORMAT_VERSION + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + + message( STATUS "Using clang-format: ${CLANG_FORMAT_PROGRAM} (${CLANG_FORMAT_VERSION})" ) + + get_target_property( CLANG_FORMAT_SOURCES ${PROJECT_NAME} SOURCES ) + + # Remove some files from the list + list( FILTER CLANG_FORMAT_SOURCES EXCLUDE REGEX ".*/extern/.*" ) + list( FILTER CLANG_FORMAT_SOURCES EXCLUDE REGEX ".*/gen/.*" ) + list( FILTER CLANG_FORMAT_SOURCES EXCLUDE REGEX ".*/*.gdextension.in" ) + list( FILTER CLANG_FORMAT_SOURCES EXCLUDE REGEX ".*/Version.h.in" ) + + add_custom_target( clang-format + COMMAND "${CLANG_FORMAT_PROGRAM}" --style=file -i ${CLANG_FORMAT_SOURCES} + COMMENT "Running clang-format..." + COMMAND_EXPAND_LISTS + VERBATIM + ) + + unset( CLANG_FORMAT_VERSION ) + unset( CLANG_FORMAT_SOURCES ) +endif() diff --git a/ScreenPlayWallpaper/Godot/GDExtention/cmake/CompilerWarnings.cmake b/ScreenPlayWallpaper/Godot/GDExtention/cmake/CompilerWarnings.cmake new file mode 100644 index 00000000..bee0550f --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/cmake/CompilerWarnings.cmake @@ -0,0 +1,115 @@ +# SPDX-License-Identifier: Unlicense +# by Andy Maloney + +string( TOUPPER ${PROJECT_NAME} PROJECT_NAME_UPPERCASE ) + +if ( NOT MSVC ) + option( ${PROJECT_NAME_UPPERCASE}_WARN_EVERYTHING "Turn on all warnings (not recommended - used for lib development)" OFF ) +endif() + +option( ${PROJECT_NAME_UPPERCASE}_WARNING_AS_ERROR "Treat warnings as errors" ON ) + +# Add warnings based on compiler +# Set some helper variables for readability +set( compiler_is_clang "$,$>" ) +set( compiler_is_gnu "$" ) +set( compiler_is_msvc "$" ) + +target_compile_options( ${PROJECT_NAME} + PRIVATE + # MSVC only + $<${compiler_is_msvc}: + /W4 + + /w14263 # 'function': member function does not override any base class virtual member function + /w14296 # 'operator': expression is always 'boolean_value' + /w14311 # 'variable': pointer truncation from 'type1' to 'type2' + /w14545 # expression before comma evaluates to a function which is missing an argument list + /w14546 # function call before comma missing argument list + /w14547 # 'operator': operator before comma has no effect; expected operator with side-effect + /w14549 # 'operator': operator before comma has no effect; did you intend 'operator'? + /w14619 # pragma warning: there is no warning number 'number' + /w14640 # thread un-safe static member initialization + /w14905 # wide string literal cast to 'LPSTR' + /w14906 # string literal cast to 'LPWSTR' + + # Disable warnings which bleed through from godot-cpp's macros. + /wd4100 # unreferenced formal parameter + > + + # Clang and GNU + $<$: + -Wall + -Wcast-align + -Wctor-dtor-privacy + -Wextra + -Wformat=2 + -Wnon-virtual-dtor + -Wnull-dereference + -Woverloaded-virtual + -Wpedantic + -Wshadow + -Wunused + -Wwrite-strings + + # Disable warnings which bleed through from godot-cpp's macros. + -Wno-unused-parameter + > + + # Clang only + $<${compiler_is_clang}: + -Wdocumentation + -Wimplicit-fallthrough + > + + # GNU only + $<${compiler_is_gnu}: + -Walloc-zero + -Wduplicated-branches + -Wduplicated-cond + -Wlogical-op + > +) + +# Turn on (almost) all warnings on Clang, Apple Clang, and GNU. +# Useful for internal development, but too noisy for general development. +function( set_warn_everything ) + message( STATUS "[${PROJECT_NAME}] Turning on (almost) all warnings") + + target_compile_options( ${PROJECT_NAME} + PRIVATE + # Clang and GNU + $<$: + -Weverything + -Wno-c++98-compat + -Wno-c++98-compat-pedantic + -Wno-padded + > + ) +endfunction() + +if ( NOT MSVC AND ${PROJECT_NAME_UPPERCASE}_WARN_EVERYTHING ) + set_warn_everything() +endif() + +# Treat warnings as errors +function( set_warning_as_error ) + message( STATUS "[${PROJECT_NAME}] Treating warnings as errors") + + if ( CMAKE_VERSION VERSION_GREATER_EQUAL "3.24" ) + set_target_properties( ${PROJECT_NAME} + PROPERTIES + COMPILE_WARNING_AS_ERROR ON + ) + else() + target_compile_options( ${PROJECT_NAME} + PRIVATE + $<${compiler_is_msvc}:/WX> + $<$:-Werror> + ) + endif() +endfunction() + +if ( ${PROJECT_NAME_UPPERCASE}_WARNING_AS_ERROR ) + set_warning_as_error() +endif() diff --git a/ScreenPlayWallpaper/Godot/GDExtention/cmake/GetGitRevisionDescription.cmake b/ScreenPlayWallpaper/Godot/GDExtention/cmake/GetGitRevisionDescription.cmake new file mode 100644 index 00000000..4fbd90db --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/cmake/GetGitRevisionDescription.cmake @@ -0,0 +1,284 @@ +# - Returns a version string from Git +# +# These functions force a re-configure on each git commit so that you can +# trust the values of the variables in your build system. +# +# get_git_head_revision( [ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR]) +# +# Returns the refspec and sha hash of the current head revision +# +# git_describe( [ ...]) +# +# Returns the results of git describe on the source tree, and adjusting +# the output so that it tests false if an error occurs. +# +# git_describe_working_tree( [ ...]) +# +# Returns the results of git describe on the working tree (--dirty option), +# and adjusting the output so that it tests false if an error occurs. +# +# git_get_exact_tag( [ ...]) +# +# Returns the results of git describe --exact-match on the source tree, +# and adjusting the output so that it tests false if there was no exact +# matching tag. +# +# git_local_changes() +# +# Returns either "CLEAN" or "DIRTY" with respect to uncommitted changes. +# Uses the return code of "git diff-index --quiet HEAD --". +# Does not regard untracked files. +# +# Requires CMake 2.6 or newer (uses the 'function' command) +# +# Original Author: +# 2009-2020 Ryan Pavlik +# http://academic.cleardefinition.com +# +# Copyright 2009-2013, Iowa State University. +# Copyright 2013-2020, Ryan Pavlik +# Copyright 2013-2020, Contributors +# SPDX-License-Identifier: BSL-1.0 +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt) + +if(__get_git_revision_description) + return() +endif() +set(__get_git_revision_description YES) + +# We must run the following at "include" time, not at function call time, +# to find the path to this module rather than the path to a calling list file +get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH) + +# Function _git_find_closest_git_dir finds the next closest .git directory +# that is part of any directory in the path defined by _start_dir. +# The result is returned in the parent scope variable whose name is passed +# as variable _git_dir_var. If no .git directory can be found, the +# function returns an empty string via _git_dir_var. +# +# Example: Given a path C:/bla/foo/bar and assuming C:/bla/.git exists and +# neither foo nor bar contain a file/directory .git. This wil return +# C:/bla/.git +# +function(_git_find_closest_git_dir _start_dir _git_dir_var) + set(cur_dir "${_start_dir}") + set(git_dir "${_start_dir}/.git") + while(NOT EXISTS "${git_dir}") + # .git dir not found, search parent directories + set(git_previous_parent "${cur_dir}") + get_filename_component(cur_dir "${cur_dir}" DIRECTORY) + if(cur_dir STREQUAL git_previous_parent) + # We have reached the root directory, we are not in git + set(${_git_dir_var} + "" + PARENT_SCOPE) + return() + endif() + set(git_dir "${cur_dir}/.git") + endwhile() + set(${_git_dir_var} + "${git_dir}" + PARENT_SCOPE) +endfunction() + +function(get_git_head_revision _refspecvar _hashvar) + _git_find_closest_git_dir("${CMAKE_CURRENT_SOURCE_DIR}" GIT_DIR) + + if("${ARGN}" STREQUAL "ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR") + set(ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR TRUE) + else() + set(ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR FALSE) + endif() + if(NOT "${GIT_DIR}" STREQUAL "") + file(RELATIVE_PATH _relative_to_source_dir "${CMAKE_SOURCE_DIR}" + "${GIT_DIR}") + if("${_relative_to_source_dir}" MATCHES "[.][.]" AND NOT ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR) + # We've gone above the CMake root dir. + set(GIT_DIR "") + endif() + endif() + if("${GIT_DIR}" STREQUAL "") + set(${_refspecvar} + "GITDIR-NOTFOUND" + PARENT_SCOPE) + set(${_hashvar} + "GITDIR-NOTFOUND" + PARENT_SCOPE) + return() + endif() + + # Check if the current source dir is a git submodule or a worktree. + # In both cases .git is a file instead of a directory. + # + if(NOT IS_DIRECTORY ${GIT_DIR}) + # The following git command will return a non empty string that + # points to the super project working tree if the current + # source dir is inside a git submodule. + # Otherwise the command will return an empty string. + # + execute_process( + COMMAND "${GIT_EXECUTABLE}" rev-parse + --show-superproject-working-tree + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + OUTPUT_VARIABLE out + ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) + if(NOT "${out}" STREQUAL "") + # If out is empty, GIT_DIR/CMAKE_CURRENT_SOURCE_DIR is in a submodule + file(READ ${GIT_DIR} submodule) + string(REGEX REPLACE "gitdir: (.*)$" "\\1" GIT_DIR_RELATIVE + ${submodule}) + string(STRIP ${GIT_DIR_RELATIVE} GIT_DIR_RELATIVE) + get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH) + get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE} + ABSOLUTE) + set(HEAD_SOURCE_FILE "${GIT_DIR}/HEAD") + else() + # GIT_DIR/CMAKE_CURRENT_SOURCE_DIR is in a worktree + file(READ ${GIT_DIR} worktree_ref) + # The .git directory contains a path to the worktree information directory + # inside the parent git repo of the worktree. + # + string(REGEX REPLACE "gitdir: (.*)$" "\\1" git_worktree_dir + ${worktree_ref}) + string(STRIP ${git_worktree_dir} git_worktree_dir) + _git_find_closest_git_dir("${git_worktree_dir}" GIT_DIR) + set(HEAD_SOURCE_FILE "${git_worktree_dir}/HEAD") + endif() + else() + set(HEAD_SOURCE_FILE "${GIT_DIR}/HEAD") + endif() + set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data") + if(NOT EXISTS "${GIT_DATA}") + file(MAKE_DIRECTORY "${GIT_DATA}") + endif() + + if(NOT EXISTS "${HEAD_SOURCE_FILE}") + return() + endif() + set(HEAD_FILE "${GIT_DATA}/HEAD") + configure_file("${HEAD_SOURCE_FILE}" "${HEAD_FILE}" COPYONLY) + + configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in" + "${GIT_DATA}/grabRef.cmake" @ONLY) + include("${GIT_DATA}/grabRef.cmake") + + set(${_refspecvar} + "${HEAD_REF}" + PARENT_SCOPE) + set(${_hashvar} + "${HEAD_HASH}" + PARENT_SCOPE) +endfunction() + +function(git_describe _var) + if(NOT GIT_FOUND) + find_package(Git QUIET) + endif() + get_git_head_revision(refspec hash) + if(NOT GIT_FOUND) + set(${_var} + "GIT-NOTFOUND" + PARENT_SCOPE) + return() + endif() + if(NOT hash) + set(${_var} + "HEAD-HASH-NOTFOUND" + PARENT_SCOPE) + return() + endif() + + # TODO sanitize + #if((${ARGN}" MATCHES "&&") OR + # (ARGN MATCHES "||") OR + # (ARGN MATCHES "\\;")) + # message("Please report the following error to the project!") + # message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}") + #endif() + + #message(STATUS "Arguments to execute_process: ${ARGN}") + + execute_process( + COMMAND "${GIT_EXECUTABLE}" describe --tags --always ${hash} ${ARGN} + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + RESULT_VARIABLE res + OUTPUT_VARIABLE out + ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) + if(NOT res EQUAL 0) + set(out "${out}-${res}-NOTFOUND") + endif() + + set(${_var} + "${out}" + PARENT_SCOPE) +endfunction() + +function(git_describe_working_tree _var) + if(NOT GIT_FOUND) + find_package(Git QUIET) + endif() + if(NOT GIT_FOUND) + set(${_var} + "GIT-NOTFOUND" + PARENT_SCOPE) + return() + endif() + + execute_process( + COMMAND "${GIT_EXECUTABLE}" describe --dirty ${ARGN} + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + RESULT_VARIABLE res + OUTPUT_VARIABLE out + ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) + if(NOT res EQUAL 0) + set(out "${out}-${res}-NOTFOUND") + endif() + + set(${_var} + "${out}" + PARENT_SCOPE) +endfunction() + +function(git_get_exact_tag _var) + git_describe(out --exact-match ${ARGN}) + set(${_var} + "${out}" + PARENT_SCOPE) +endfunction() + +function(git_local_changes _var) + if(NOT GIT_FOUND) + find_package(Git QUIET) + endif() + get_git_head_revision(refspec hash) + if(NOT GIT_FOUND) + set(${_var} + "GIT-NOTFOUND" + PARENT_SCOPE) + return() + endif() + if(NOT hash) + set(${_var} + "HEAD-HASH-NOTFOUND" + PARENT_SCOPE) + return() + endif() + + execute_process( + COMMAND "${GIT_EXECUTABLE}" diff-index --quiet HEAD -- + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + RESULT_VARIABLE res + OUTPUT_VARIABLE out + ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) + if(res EQUAL 0) + set(${_var} + "CLEAN" + PARENT_SCOPE) + else() + set(${_var} + "DIRTY" + PARENT_SCOPE) + endif() +endfunction() diff --git a/ScreenPlayWallpaper/Godot/GDExtention/cmake/GetGitRevisionDescription.cmake.in b/ScreenPlayWallpaper/Godot/GDExtention/cmake/GetGitRevisionDescription.cmake.in new file mode 100644 index 00000000..116efc4e --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/cmake/GetGitRevisionDescription.cmake.in @@ -0,0 +1,43 @@ +# +# Internal file for GetGitRevisionDescription.cmake +# +# Requires CMake 2.6 or newer (uses the 'function' command) +# +# Original Author: +# 2009-2010 Ryan Pavlik +# http://academic.cleardefinition.com +# Iowa State University HCI Graduate Program/VRAC +# +# Copyright 2009-2012, Iowa State University +# Copyright 2011-2015, Contributors +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt) +# SPDX-License-Identifier: BSL-1.0 + +set(HEAD_HASH) + +file(READ "@HEAD_FILE@" HEAD_CONTENTS LIMIT 1024) + +string(STRIP "${HEAD_CONTENTS}" HEAD_CONTENTS) +if(HEAD_CONTENTS MATCHES "ref") + # named branch + string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}") + if(EXISTS "@GIT_DIR@/${HEAD_REF}") + configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY) + else() + configure_file("@GIT_DIR@/packed-refs" "@GIT_DATA@/packed-refs" COPYONLY) + file(READ "@GIT_DATA@/packed-refs" PACKED_REFS) + if(${PACKED_REFS} MATCHES "([0-9a-z]*) ${HEAD_REF}") + set(HEAD_HASH "${CMAKE_MATCH_1}") + endif() + endif() +else() + # detached HEAD + configure_file("@GIT_DIR@/HEAD" "@GIT_DATA@/head-ref" COPYONLY) +endif() + +if(NOT HEAD_HASH) + file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024) + string(STRIP "${HEAD_HASH}" HEAD_HASH) +endif() diff --git a/ScreenPlayWallpaper/Godot/GDExtention/cmake/GitVersionInfo.cmake b/ScreenPlayWallpaper/Godot/GDExtention/cmake/GitVersionInfo.cmake new file mode 100644 index 00000000..c1285ab5 --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/cmake/GitVersionInfo.cmake @@ -0,0 +1,46 @@ +# SPDX-License-Identifier: Unlicense + +find_program( GIT_PROGRAM git ) + +if ( GIT_PROGRAM ) + # get version information + execute_process( + COMMAND "${GIT_PROGRAM}" --version + OUTPUT_VARIABLE GIT_VERSION + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + + message( STATUS "Using git: ${GIT_PROGRAM} (${GIT_VERSION})" ) + + include( GetGitRevisionDescription ) + + get_git_head_revision( GIT_REFSPEC GIT_SHA1 ) + git_describe( GIT_SHORT ) + + string( TOUPPER ${PROJECT_NAME} UPPER_PROJECT_NAME ) + + set( VERSION_INPUT_FILE "src/Version.h.in" ) + set( VERSION_OUTPUT_FILE "${CMAKE_BINARY_DIR}/gen/Version.h" ) + + configure_file( "${VERSION_INPUT_FILE}" "${VERSION_OUTPUT_FILE}" ) + + target_sources( ${PROJECT_NAME} + PRIVATE + "${VERSION_INPUT_FILE}" + "${VERSION_OUTPUT_FILE}" + ) + + get_filename_component( VERSION_OUTPUT_FILE_DIR ${VERSION_OUTPUT_FILE} DIRECTORY ) + + target_include_directories( ${PROJECT_NAME} + PRIVATE + ${VERSION_OUTPUT_FILE_DIR} + ) + + message( STATUS "${PROJECT_NAME} version: ${GIT_SHORT}" ) + + unset( VERSION_INPUT_FILE ) + unset( VERSION_OUTPUT_FILE ) + unset( VERSION_OUTPUT_FILE_DIR ) + unset( GIT_VERSION ) +endif() diff --git a/ScreenPlayWallpaper/Godot/GDExtention/cmake/ccache.cmake b/ScreenPlayWallpaper/Godot/GDExtention/cmake/ccache.cmake new file mode 100644 index 00000000..4bb5661b --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/cmake/ccache.cmake @@ -0,0 +1,22 @@ +# SPDX-License-Identifier: Unlicense + +# See: https://crascit.com/2016/04/09/using-ccache-with-cmake/ +find_program( CCACHE_PROGRAM ccache ) + +if ( CCACHE_PROGRAM ) + # get version information + execute_process( + COMMAND "${CCACHE_PROGRAM}" --version + OUTPUT_VARIABLE CCACHE_VERSION + ) + + string( REGEX MATCH "[^\r\n]*" CCACHE_VERSION ${CCACHE_VERSION} ) + + message( STATUS "Using ccache: ${CCACHE_PROGRAM} (${CCACHE_VERSION})" ) + + # Turn on ccache for all targets + set( CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}" ) + set( CMAKE_C_COMPILER_LAUNCHER "${CCACHE_PROGRAM}" ) + + unset( CCACHE_VERSION ) +endif() diff --git a/ScreenPlayWallpaper/Godot/GDExtention/extern/godot-cpp b/ScreenPlayWallpaper/Godot/GDExtention/extern/godot-cpp new file mode 160000 index 00000000..28494f0b --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/extern/godot-cpp @@ -0,0 +1 @@ +Subproject commit 28494f0bd59f9c35289524e503648ed8b4baaa59 diff --git a/ScreenPlayWallpaper/Godot/GDExtention/src/CMakeLists.txt b/ScreenPlayWallpaper/Godot/GDExtention/src/CMakeLists.txt new file mode 100644 index 00000000..9b378a18 --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/src/CMakeLists.txt @@ -0,0 +1,15 @@ +# SPDX-License-Identifier: Unlicense + +target_sources( ${PROJECT_NAME} + PRIVATE + ScreenPlayWallpaper.h + ScreenPlayWallpaper.cpp + GDExtensionTemplate.h + GDExtensionTemplate.cpp + RegisterExtension.cpp +) + +target_include_directories( ${PROJECT_NAME} + PRIVATE + "src" +) diff --git a/ScreenPlayWallpaper/Godot/GDExtention/src/GDExtensionTemplate.cpp b/ScreenPlayWallpaper/Godot/GDExtention/src/GDExtensionTemplate.cpp new file mode 100644 index 00000000..91fd7ea8 --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/src/GDExtensionTemplate.cpp @@ -0,0 +1,32 @@ +// SPDX-License-Identifier: Unlicense + +#include "godot_cpp/core/class_db.hpp" + +#include "GDExtensionTemplate.h" +#include "Version.h" + +/// @file +/// GDExtensionTemplate example implementation. + +/*! +@brief Get the version string for this extension. + +@details +The version string is generated by cmake using src/Version.h.in. + +It uses the form " -<# commits since last tag>-". +If there are no commits since the last tag, only the tag is shown. + +@return The version string (e.g. "Foo v1.2.3-gdedbd01"). +*/ +godot::String GDExtensionTemplate::version() +{ + return VersionInfo::VERSION_STR.data(); +} + +/// Bind our methods so GDScript can access them. +void GDExtensionTemplate::_bind_methods() +{ + godot::ClassDB::bind_static_method( "GDExtensionTemplate", godot::D_METHOD( "version" ), + &GDExtensionTemplate::version ); +} diff --git a/ScreenPlayWallpaper/Godot/GDExtention/src/GDExtensionTemplate.h b/ScreenPlayWallpaper/Godot/GDExtention/src/GDExtensionTemplate.h new file mode 100644 index 00000000..038aa40e --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/src/GDExtensionTemplate.h @@ -0,0 +1,20 @@ +#pragma once +// SPDX-License-Identifier: Unlicense + +#include "godot_cpp/classes/object.hpp" + +namespace godot +{ + class ClassDB; +}; + +class GDExtensionTemplate : public godot::Object +{ + GDCLASS( GDExtensionTemplate, godot::Object ) + +public: + static godot::String version(); + +private: + static void _bind_methods(); +}; diff --git a/ScreenPlayWallpaper/Godot/GDExtention/src/RegisterExtension.cpp b/ScreenPlayWallpaper/Godot/GDExtention/src/RegisterExtension.cpp new file mode 100644 index 00000000..8bbf988e --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/src/RegisterExtension.cpp @@ -0,0 +1,74 @@ +// Copied from godot-cpp/test/src and modified. + +#include "gdextension_interface.h" + +#include "godot_cpp/core/class_db.hpp" +#include "godot_cpp/core/defs.hpp" +#include "godot_cpp/godot.hpp" + +#include "GDExtensionTemplate.h" +#include "ScreenPlayWallpaper.h" + +/// @file +/// Register our classes with Godot. + +namespace { +/// @brief Called by Godot to let us register our classes with Godot. +/// +/// @param p_level the level being initialized by Godot +/// +/// @see GDExtensionInit +void initializeExtension(godot::ModuleInitializationLevel p_level) +{ + if (p_level != godot::MODULE_INITIALIZATION_LEVEL_SCENE) { + return; + } + + godot::ClassDB::register_class(); + godot::ClassDB::register_class(); + godot::ClassDB::register_class(); + godot::ClassDB::register_class(true); + godot::ClassDB::register_abstract_class(); + + godot::ClassDB::register_class(); +} + +/// @brief Called by Godot to let us do any cleanup. +/// +/// @see GDExtensionInit +void uninitializeExtension(godot::ModuleInitializationLevel p_level) +{ + if (p_level != godot::MODULE_INITIALIZATION_LEVEL_SCENE) { + return; + } +} +} + +extern "C" { +/// @brief This is the entry point for the shared library. +/// +/// @note The name of this function must match the "entry_symbol" in +/// templates/template.*.gdextension.in +/// +/// @param p_get_proc_address the interface (need more info) +/// @param p_library the library (need more info) +/// @param r_initialization the intialization (need more info) +/// +/// @returns GDExtensionBool +GDExtensionBool GDE_EXPORT GDExtensionInit( + GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library, + GDExtensionInitialization* r_initialization) +{ + { + godot::GDExtensionBinding::InitObject init_obj(p_get_proc_address, p_library, + r_initialization); + + init_obj.register_initializer(initializeExtension); + init_obj.register_terminator(uninitializeExtension); + init_obj.set_minimum_library_initialization_level( + godot::MODULE_INITIALIZATION_LEVEL_SCENE); + + return init_obj.init(); + } +} +} diff --git a/ScreenPlayWallpaper/Godot/GDExtention/src/ScreenPlayWallpaper.cpp b/ScreenPlayWallpaper/Godot/GDExtention/src/ScreenPlayWallpaper.cpp new file mode 100644 index 00000000..1eb98e18 --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/src/ScreenPlayWallpaper.cpp @@ -0,0 +1,475 @@ +// Copied from godot-cpp/test/src and modified. + +#include "godot_cpp/classes/global_constants.hpp" +#include "godot_cpp/classes/label.hpp" +#include "godot_cpp/core/class_db.hpp" +#include "godot_cpp/variant/utility_functions.hpp" + +#include "ScreenPlayWallpaper.h" + +// Used to mark unused parameters to indicate intent and suppress warnings. +#define UNUSED(expr) (void)(expr) + +namespace { +constexpr int MAGIC_NUMBER = 42; +} + +//// ScreenPlayWallpaper + +int ScreenPlayWallpaper::sInstanceCount = 0; +int ScreenPlayWallpaper::sLastID = 0; + +ScreenPlayWallpaper::ScreenPlayWallpaper() +{ + mID = ++sLastID; + sInstanceCount++; + + godot::UtilityFunctions::print( + "ScreenPlayWallpaper ", godot::itos(mID), + " created, current instance count: ", godot::itos(sInstanceCount)); +} + +ScreenPlayWallpaper::~ScreenPlayWallpaper() +{ + sInstanceCount--; + godot::UtilityFunctions::print( + "ScreenPlayWallpaper ", godot::itos(mID), + " destroyed, current instance count: ", godot::itos(sInstanceCount)); +} + +int ScreenPlayWallpaper::getID() const +{ + return mID; +} + +void ScreenPlayWallpaper::_bind_methods() +{ + godot::ClassDB::bind_method(godot::D_METHOD("get_id"), &ScreenPlayWallpaper::getID); +} + +//// ExampleMin + +void ExampleMin::_bind_methods() +{ +} + +//// Example + +Example::Example() +{ + godot::UtilityFunctions::print("Constructor."); +} + +Example::~Example() +{ + godot::UtilityFunctions::print("Destructor."); +} + +// Methods. +void Example::simpleFunc() +{ + godot::UtilityFunctions::print(" Simple func called."); +} + +void Example::simpleConstFunc() const +{ + godot::UtilityFunctions::print(" Simple const func called."); +} + +godot::String Example::returnSomething(const godot::String& inBase) +{ + godot::UtilityFunctions::print(" Return something called."); + + return inBase; +} + +godot::Viewport* Example::returnSomethingConst() const +{ + godot::UtilityFunctions::print(" Return something const called."); + + if (is_inside_tree()) { + godot::Viewport* result = get_viewport(); + + return result; + } + + return nullptr; +} + +godot::Ref Example::returnEmptyRef() const +{ + godot::Ref ref; + return ref; +} + +ScreenPlayWallpaper* Example::returnExtendedRef() const +{ + // You can instance and return a refcounted object like this, but keep in mind that refcounting + // starts with the returned object and it will be destroyed when all references are destroyed. + // If you store this pointer you run the risk of having a pointer to a destroyed object. + return memnew(ScreenPlayWallpaper()); +} + +godot::Ref Example::extendedRefChecks(godot::Ref inRef) const +{ + // This is the preferred way of instancing and returning a refcounted object: + godot::Ref ref; + ref.instantiate(); + + godot::UtilityFunctions::print( + " Example ref checks called with value: ", inRef->get_instance_id(), + ", returning value: ", ref->get_instance_id()); + + return ref; +} + +godot::Variant Example::varargsFunc(const godot::Variant** inArgs, GDExtensionInt inArgCount, + GDExtensionCallError& outError) +{ + UNUSED(inArgs); + UNUSED(outError); + + godot::UtilityFunctions::print(" Varargs (Variant return) called with ", + godot::String::num_int64(inArgCount), " arguments"); + + return inArgCount; +} + +int Example::varargsFuncNonVoidReturn(const godot::Variant** inArgs, GDExtensionInt inArgCount, + GDExtensionCallError& outError) +{ + UNUSED(inArgs); + UNUSED(outError); + + godot::UtilityFunctions::print(" Varargs (int return) called with ", + godot::String::num_int64(inArgCount), " arguments"); + + return MAGIC_NUMBER; +} + +void Example::varargsFuncVoidReturn(const godot::Variant** inArgs, GDExtensionInt inArgCount, + GDExtensionCallError& outError) +{ + UNUSED(inArgs); + UNUSED(outError); + + godot::UtilityFunctions::print(" Varargs (no return) called with ", + godot::String::num_int64(inArgCount), " arguments"); +} + +void Example::emitCustomSignal(const godot::String& inName, int inValue) +{ + emit_signal("custom_signal", inName, inValue); +} + +int Example::defArgs(int inA, int inB) const +{ + return inA + inB; +} + +godot::Array Example::testArray() const +{ + godot::Array arr; + + arr.resize(2); + arr[0] = godot::Variant(1); + arr[1] = godot::Variant(2); + + return arr; +} + +void Example::testTypedArrayArg(const godot::TypedArray& inArray) +{ + for (int i = 0; i < inArray.size(); ++i) { + godot::UtilityFunctions::print(inArray[i]); + } +} + +godot::TypedArray Example::testTypedArray() const +{ + godot::TypedArray arr; + + arr.resize(2); + arr[0] = godot::Vector2(1, 2); + arr[1] = godot::Vector2(2, 3); + + return arr; +} + +godot::Dictionary Example::testDictionary() const +{ + godot::Dictionary dict; + + dict["hello"] = "world"; + dict["foo"] = "bar"; + + return dict; +} + +Example* Example::testNodeArgument(Example* inNode) const +{ + // This should use godot::String::num_uint64(), but it is currently broken: + // https://github.com/godotengine/godot-cpp/issues/1014 + godot::UtilityFunctions::print( + " Test node argument called with ", + (inNode != nullptr) + ? godot::String::num_int64(static_cast(inNode->get_instance_id())) + : "null"); + return inNode; +} + +godot::String Example::testStringOps() const +{ + godot::String s = godot::String("A"); + s += "B"; + s += "C"; + s += char32_t(0x010E); + s = s + "E"; + + return s; +} + +int Example::testVectorOps() const +{ + godot::PackedInt32Array arr; + arr.push_back(10); + arr.push_back(20); + arr.push_back(30); + arr.push_back(45); + + int ret = 0; + for (const int32_t& E : arr) { + ret += E; + } + + return ret; +} + +godot::BitField Example::testBitfield(godot::BitField inFlags) +{ + godot::UtilityFunctions::print(" Got BitField: ", godot::String::num_int64(inFlags)); + return inFlags; +} + +// Properties. +void Example::setCustomPosition(const godot::Vector2& inPos) +{ + mCustomPosition = inPos; +} + +godot::Vector2 Example::getCustomPosition() const +{ + return mCustomPosition; +} + +godot::Vector4 Example::getV4() const +{ + return { 1.2f, 3.4f, 5.6f, 7.8f }; +} + +// Static methods +int Example::testStatic(int inA, int inB) +{ + return inA + inB; +} + +void Example::testStatic2() +{ + godot::UtilityFunctions::print(" void static"); +} + +// Virtual function override. +bool Example::_has_point(const godot::Vector2& inPoint) const +{ + auto* label = godot::Control::get_node("Label"); + + label->set_text("Got point: " + godot::Variant(inPoint).stringify()); + + return false; +} + +void Example::_bind_methods() +{ + // Methods. + godot::ClassDB::bind_method(godot::D_METHOD("simple_func"), &Example::simpleFunc); + godot::ClassDB::bind_method(godot::D_METHOD("simple_const_func"), + &Example::simpleConstFunc); + godot::ClassDB::bind_method(godot::D_METHOD("return_something"), &Example::returnSomething); + godot::ClassDB::bind_method(godot::D_METHOD("return_something_const"), + &Example::returnSomethingConst); + godot::ClassDB::bind_method(godot::D_METHOD("return_empty_ref"), &Example::returnEmptyRef); + godot::ClassDB::bind_method(godot::D_METHOD("return_extended_ref"), + &Example::returnExtendedRef); + godot::ClassDB::bind_method(godot::D_METHOD("extended_ref_checks", "ref"), + &Example::extendedRefChecks); + + godot::ClassDB::bind_method(godot::D_METHOD("test_array"), &Example::testArray); + godot::ClassDB::bind_method(godot::D_METHOD("test_tarray_arg", "array"), + &Example::testTypedArrayArg); + godot::ClassDB::bind_method(godot::D_METHOD("test_tarray"), &Example::testTypedArray); + godot::ClassDB::bind_method(godot::D_METHOD("test_dictionary"), &Example::testDictionary); + godot::ClassDB::bind_method(godot::D_METHOD("test_node_argument"), + &Example::testNodeArgument); + godot::ClassDB::bind_method(godot::D_METHOD("test_string_ops"), &Example::testStringOps); + godot::ClassDB::bind_method(godot::D_METHOD("test_vector_ops"), &Example::testVectorOps); + + godot::ClassDB::bind_method(godot::D_METHOD("test_bitfield", "flags"), + &Example::testBitfield); + + godot::ClassDB::bind_method(godot::D_METHOD("def_args", "a", "b"), &Example::defArgs, + DEFVAL(100), DEFVAL(200)); + + godot::ClassDB::bind_static_method("Example", godot::D_METHOD("test_static", "a", "b"), + &Example::testStatic); + godot::ClassDB::bind_static_method("Example", godot::D_METHOD("test_static2"), + &Example::testStatic2); + + { + godot::MethodInfo mi; + mi.arguments.emplace_back(godot::Variant::STRING, "some_argument"); + mi.name = "varargs_func"; + + godot::ClassDB::bind_vararg_method(godot::METHOD_FLAGS_DEFAULT, "varargs_func", + &Example::varargsFunc, mi); + } + + { + godot::MethodInfo mi; + mi.arguments.emplace_back(godot::Variant::STRING, "some_argument"); + mi.name = "varargs_func_nv"; + + godot::ClassDB::bind_vararg_method(godot::METHOD_FLAGS_DEFAULT, "varargs_func_nv", + &Example::varargsFuncNonVoidReturn, mi); + } + + { + godot::MethodInfo mi; + mi.arguments.emplace_back(godot::Variant::STRING, "some_argument"); + mi.name = "varargs_func_void"; + + godot::ClassDB::bind_vararg_method(godot::METHOD_FLAGS_DEFAULT, "varargs_func_void", + &Example::varargsFuncVoidReturn, mi); + } + + // Properties. + ADD_GROUP("Test group", "group_"); + ADD_SUBGROUP("Test subgroup", "group_subgroup_"); + + godot::ClassDB::bind_method(godot::D_METHOD("get_custom_position"), + &Example::getCustomPosition); + godot::ClassDB::bind_method(godot::D_METHOD("get_v4"), &Example::getV4); + godot::ClassDB::bind_method(godot::D_METHOD("set_custom_position", "position"), + &Example::setCustomPosition); + ADD_PROPERTY(godot::PropertyInfo(godot::Variant::VECTOR2, "group_subgroup_custom_position"), + "set_custom_position", "get_custom_position"); + + // Signals. + ADD_SIGNAL(godot::MethodInfo("custom_signal", + godot::PropertyInfo(godot::Variant::STRING, "name"), + godot::PropertyInfo(godot::Variant::INT, "value"))); + godot::ClassDB::bind_method(godot::D_METHOD("emit_custom_signal", "name", "value"), + &Example::emitCustomSignal); + + // Constants. + BIND_ENUM_CONSTANT(FIRST) + BIND_ENUM_CONSTANT(ANSWER_TO_EVERYTHING) + + BIND_BITFIELD_FLAG(FLAG_ONE); + BIND_BITFIELD_FLAG(FLAG_TWO); + + BIND_CONSTANT(CONSTANT_WITHOUT_ENUM); + BIND_ENUM_CONSTANT(OUTSIDE_OF_CLASS); +} + +void Example::_notification(int inWhat) +{ + godot::UtilityFunctions::print("Notification: ", godot::String::num(inWhat)); +} + +bool Example::_set(const godot::StringName& inName, const godot::Variant& inValue) +{ + godot::String name = inName; + + if (name.begins_with("dproperty")) { + int64_t index = name.get_slicec('_', 1).to_int(); + mDProp[index] = inValue; + + return true; + } + + if (name == "property_from_list") { + mPropertyFromList = inValue; + + return true; + } + + return false; +} + +bool Example::_get(const godot::StringName& inName, godot::Variant& outReturn) const +{ + godot::String name = inName; + + if (name.begins_with("dproperty")) { + int64_t index = name.get_slicec('_', 1).to_int(); + outReturn = mDProp[index]; + + return true; + } + + if (name == "property_from_list") { + outReturn = mPropertyFromList; + + return true; + } + + return false; +} + +void Example::_get_property_list(godot::List* outList) const +{ + outList->push_back(godot::PropertyInfo(godot::Variant::VECTOR3, "property_from_list")); + + for (int i = 0; i < 3; ++i) { + outList->push_back( + godot::PropertyInfo(godot::Variant::VECTOR2, "dproperty_" + godot::itos(i))); + } +} + +bool Example::_property_can_revert(const godot::StringName& inName) const +{ + if (inName == godot::StringName("property_from_list") && mPropertyFromList != godot::Vector3(MAGIC_NUMBER, MAGIC_NUMBER, MAGIC_NUMBER)) { + return true; + } + + return false; +}; + +bool Example::_property_get_revert(const godot::StringName& inName, + godot::Variant& outProperty) const +{ + if (inName == godot::StringName("property_from_list")) { + outProperty = godot::Vector3(MAGIC_NUMBER, MAGIC_NUMBER, MAGIC_NUMBER); + + return true; + } + + return false; +}; + +godot::String Example::_to_string() const +{ + return "[ GDExtension::Example <--> Instance ID:" + godot::uitos(get_instance_id()) + " ]"; +} + +//// ExampleVirtual + +void ExampleVirtual::_bind_methods() +{ +} + +//// ExampleAbstract + +void ExampleAbstract::_bind_methods() +{ +} diff --git a/ScreenPlayWallpaper/Godot/GDExtention/src/ScreenPlayWallpaper.h b/ScreenPlayWallpaper/Godot/GDExtention/src/ScreenPlayWallpaper.h new file mode 100644 index 00000000..bc540d3b --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/src/ScreenPlayWallpaper.h @@ -0,0 +1,135 @@ +#pragma once +// Copied from godot-cpp/test/src and modified. + +#include "godot_cpp/classes/control.hpp" +#include "godot_cpp/classes/global_constants.hpp" +#include "godot_cpp/classes/viewport.hpp" +#include "godot_cpp/core/binder_common.hpp" + +class ScreenPlayWallpaper : public godot::RefCounted { + GDCLASS(ScreenPlayWallpaper, RefCounted) + +public: + ScreenPlayWallpaper(); + ~ScreenPlayWallpaper() override; + + int getID() const; + +protected: + static void _bind_methods(); + +private: + static int sInstanceCount; + static int sLastID; + + int mID; +}; + +class ExampleMin : public godot::Control { + GDCLASS(ExampleMin, Control) + +protected: + static void _bind_methods(); +}; + +class Example : public godot::Control { + GDCLASS(Example, godot::Control) + +public: + // Constants. + enum Constants { + FIRST, + ANSWER_TO_EVERYTHING = 42, + }; + + enum { + CONSTANT_WITHOUT_ENUM = 314, + }; + + enum Flags { + FLAG_ONE = 1, + FLAG_TWO = 2, + }; + + Example(); + ~Example() override; + + // Functions. + void simpleFunc(); + void simpleConstFunc() const; + godot::String returnSomething(const godot::String& inBase); + godot::Viewport* returnSomethingConst() const; + godot::Ref returnEmptyRef() const; + ScreenPlayWallpaper* returnExtendedRef() const; + godot::Ref extendedRefChecks(godot::Ref inRef) const; + godot::Variant varargsFunc(const godot::Variant** inArgs, GDExtensionInt inArgCount, + GDExtensionCallError& outError); + int varargsFuncNonVoidReturn(const godot::Variant** inArgs, GDExtensionInt inArgCount, + GDExtensionCallError& outError); + void varargsFuncVoidReturn(const godot::Variant** inArgs, GDExtensionInt inArgCount, + GDExtensionCallError& outError); + + void emitCustomSignal(const godot::String& inName, int inValue); + int defArgs(int inA = 100, int inB = 200) const; + + godot::Array testArray() const; + void testTypedArrayArg(const godot::TypedArray& inArray); + godot::TypedArray testTypedArray() const; + godot::Dictionary testDictionary() const; + Example* testNodeArgument(Example* inNode) const; + godot::String testStringOps() const; + int testVectorOps() const; + + godot::BitField testBitfield(godot::BitField inFlags); + + // Property. + void setCustomPosition(const godot::Vector2& inPos); + godot::Vector2 getCustomPosition() const; + godot::Vector4 getV4() const; + + // Static method. + static int testStatic(int inA, int inB); + static void testStatic2(); + + // Virtual function override (no need to bind manually). + virtual bool _has_point(const godot::Vector2& inPoint) const override; + +protected: + static void _bind_methods(); + + void _notification(int inWhat); + bool _set(const godot::StringName& inName, const godot::Variant& inValue); + bool _get(const godot::StringName& inName, godot::Variant& outReturn) const; + void _get_property_list(godot::List* outList) const; + bool _property_can_revert(const godot::StringName& inName) const; + bool _property_get_revert(const godot::StringName& inName, godot::Variant& outProperty) const; + + godot::String _to_string() const; + +private: + godot::Vector2 mCustomPosition; + godot::Vector3 mPropertyFromList; + godot::Vector2 mDProp[3]; +}; + +VARIANT_ENUM_CAST(Example::Constants); +VARIANT_BITFIELD_CAST(Example::Flags); + +enum EnumWithoutClass { + OUTSIDE_OF_CLASS = 512 +}; +VARIANT_ENUM_CAST(EnumWithoutClass); + +class ExampleVirtual : public godot::Object { + GDCLASS(ExampleVirtual, godot::Object) + +protected: + static void _bind_methods(); +}; + +class ExampleAbstract : public godot::Object { + GDCLASS(ExampleAbstract, godot::Object) + +protected: + static void _bind_methods(); +}; diff --git a/ScreenPlayWallpaper/Godot/GDExtention/src/Version.h.in b/ScreenPlayWallpaper/Godot/GDExtention/src/Version.h.in new file mode 100644 index 00000000..10a52438 --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/src/Version.h.in @@ -0,0 +1,45 @@ +#pragma once +// This file is generated by cmake. Changes will be overwritten. +// clang-format off + +#include + +// Creates a version number for use in macro comparisons. +// +// Example: +// +// // Check if the version is less than 2.1.0 +// #if ${UPPER_PROJECT_NAME}_VERSION < ${UPPER_PROJECT_NAME}_VERSION_CHECK(2, 1, 0) +// // do stuff +// #endif +// +// Returns an integer which may be used in comparisons +#define ${UPPER_PROJECT_NAME}_VERSION_CHECK( major, minor, patch ) ( ((major)<<16) | ((minor)<<8) | (patch) ) + +#define ${UPPER_PROJECT_NAME}_VERSION_MAJOR ${PROJECT_VERSION_MAJOR} +#define ${UPPER_PROJECT_NAME}_VERSION_MINOR ${PROJECT_VERSION_MINOR} +#define ${UPPER_PROJECT_NAME}_VERSION_PATCH ${PROJECT_VERSION_PATCH} + +// The version number of this extension. Used for #if comparisons. +// This is generated using the version set in the CMake project macro. +#define ${UPPER_PROJECT_NAME}_VERSION ${UPPER_PROJECT_NAME}_VERSION_CHECK( ${PROJECT_VERSION_MAJOR}, ${PROJECT_VERSION_MINOR}, ${PROJECT_VERSION_PATCH} ) + +namespace VersionInfo { + // Project name and version as a string. + // This is generated using the project name from the cmake project macro and the current git commit information. + // + // It uses the form " -<# commits since last tag>-". + // If there are no commits since the last tag, only the tag is shown. + constexpr std::string_view VERSION_STR = "${PROJECT_NAME} ${GIT_SHORT}"; + + // The version information as a string. + // This is generated using the current git commit information. + // + // It uses the form "-<# commits since last tag>-". + // If there are no commits since the last tag, only the tag is shown. + constexpr std::string_view VERSION_SHORT_STR = "${GIT_SHORT}"; + + // The full git SHA1 hash as a string. + // This is generated using the current git commit information. + constexpr std::string_view GIT_SHA1_STR = "${GIT_SHA1}"; +} diff --git a/ScreenPlayWallpaper/Godot/GDExtention/templates/CMakeLists.txt b/ScreenPlayWallpaper/Godot/GDExtention/templates/CMakeLists.txt new file mode 100644 index 00000000..5467db0f --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/templates/CMakeLists.txt @@ -0,0 +1,41 @@ +# SPDX-License-Identifier: Unlicense + +add_custom_target( templates + SOURCES + template.debug.gdextension.in + template.release.gdextension.in +) + +add_dependencies( ${PROJECT_NAME} templates ) + +# We shouldn't be relying on CMAKE_BUILD_TYPE (see https://github.com/asmaloney/GDExtensionTemplate/issues/25) +# But until we fix it here and in godot-cpp, ensure it's one we expect. +set ( ALLOWED_BUILDS "Debug;Release" ) +if ( NOT "${CMAKE_BUILD_TYPE}" IN_LIST ALLOWED_BUILDS ) + message( FATAL_ERROR "CMAKE_BUILD_TYPE must be set to Debug or Release" ) +endif() + +# Get our gdextension input file name based on build type +string( TOLOWER ${CMAKE_BUILD_TYPE} BUILD_TYPE ) +set( GD_EXTENSION_FILE_INPUT template.${BUILD_TYPE}.gdextension.in ) + +# Workaround to add the "lib" prefix to the library in our template file if using MSYS2. +if ( MINGW ) + set( LIB_PREFIX "lib") +endif() + +# Generate our project's .gdextension file from the template +set( GD_EXTENSION_FILE ${PROJECT_NAME}.gdextension ) +configure_file( ${GD_EXTENSION_FILE_INPUT} ${PROJECT_BINARY_DIR}/${PROJECT_NAME}/${GD_EXTENSION_FILE} ) + +# Install the gdextension file from the build directory +install( + FILES ${BUILD_OUTPUT_DIR}/${GD_EXTENSION_FILE} + DESTINATION ${INSTALL_DIR} +) + +unset( ALLOWED_BUILDS ) +unset( BUILD_TYPE ) +unset( GD_EXTENSION_FILE ) +unset( GD_EXTENSION_FILE_INPUT ) +unset( LIB_PREFIX ) diff --git a/ScreenPlayWallpaper/Godot/GDExtention/templates/template.debug.gdextension.in b/ScreenPlayWallpaper/Godot/GDExtention/templates/template.debug.gdextension.in new file mode 100644 index 00000000..0765cee8 --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/templates/template.debug.gdextension.in @@ -0,0 +1,10 @@ +[configuration] + +entry_symbol = "GDExtensionInit" +compatibility_minimum = 4.1 + +[libraries] + +linux.debug.x86_64 = "lib/Linux-x86_64/lib${PROJECT_NAME}-d.so" +macos.debug = "lib/Darwin-Universal/lib${PROJECT_NAME}-d.dylib" +windows.debug.x86_64 = "lib/Windows-AMD64/${LIB_PREFIX}${PROJECT_NAME}-d.dll" diff --git a/ScreenPlayWallpaper/Godot/GDExtention/templates/template.release.gdextension.in b/ScreenPlayWallpaper/Godot/GDExtention/templates/template.release.gdextension.in new file mode 100644 index 00000000..dd1c9362 --- /dev/null +++ b/ScreenPlayWallpaper/Godot/GDExtention/templates/template.release.gdextension.in @@ -0,0 +1,10 @@ +[configuration] + +entry_symbol = "GDExtensionInit" +compatibility_minimum = 4.1 + +[libraries] + +linux.release.x86_64 = "lib/Linux-x86_64/lib${PROJECT_NAME}.so" +macos.release = "lib/Darwin-universal/lib${PROJECT_NAME}.dylib" +windows.release.x86_64 = "lib/Windows-AMD64/${LIB_PREFIX}${PROJECT_NAME}.dll" diff --git a/ScreenPlayWallpaper/Godot/ScreenPlayGodot/.gitattributes b/ScreenPlayWallpaper/Godot/ScreenPlayGodot/.gitattributes new file mode 100644 index 00000000..8ad74f78 --- /dev/null +++ b/ScreenPlayWallpaper/Godot/ScreenPlayGodot/.gitattributes @@ -0,0 +1,2 @@ +# Normalize EOL for all files that Git considers text files. +* text=auto eol=lf diff --git a/ScreenPlayWallpaper/Godot/ScreenPlayGodot/.gitignore b/ScreenPlayWallpaper/Godot/ScreenPlayGodot/.gitignore new file mode 100644 index 00000000..47091836 --- /dev/null +++ b/ScreenPlayWallpaper/Godot/ScreenPlayGodot/.gitignore @@ -0,0 +1,2 @@ +# Godot 4+ specific ignores +.godot/ diff --git a/ScreenPlayWallpaper/Godot/ScreenPlayGodot/export_presets.cfg b/ScreenPlayWallpaper/Godot/ScreenPlayGodot/export_presets.cfg new file mode 100644 index 00000000..81e43f95 --- /dev/null +++ b/ScreenPlayWallpaper/Godot/ScreenPlayGodot/export_presets.cfg @@ -0,0 +1,61 @@ +[preset.0] + +name="Windows Desktop" +platform="Windows Desktop" +runnable=true +dedicated_server=false +custom_features="" +export_filter="all_resources" +include_filter="" +exclude_filter="" +export_path="../SP_export/export.exe" +encryption_include_filters="" +encryption_exclude_filters="" +encrypt_pck=false +encrypt_directory=false + +[preset.0.options] + +custom_template/debug="" +custom_template/release="" +debug/export_console_wrapper=1 +binary_format/embed_pck=false +texture_format/bptc=true +texture_format/s3tc=true +texture_format/etc=false +texture_format/etc2=false +binary_format/architecture="x86_64" +codesign/enable=false +codesign/timestamp=true +codesign/timestamp_server_url="" +codesign/digest_algorithm=1 +codesign/description="" +codesign/custom_options=PackedStringArray() +application/modify_resources=true +application/icon="" +application/console_wrapper_icon="" +application/icon_interpolation=4 +application/file_version="" +application/product_version="" +application/company_name="" +application/product_name="" +application/file_description="" +application/copyright="" +application/trademarks="" +ssh_remote_deploy/enabled=false +ssh_remote_deploy/host="user@host_ip" +ssh_remote_deploy/port="22" +ssh_remote_deploy/extra_args_ssh="" +ssh_remote_deploy/extra_args_scp="" +ssh_remote_deploy/run_script="Expand-Archive -LiteralPath '{temp_dir}\\{archive_name}' -DestinationPath '{temp_dir}' +$action = New-ScheduledTaskAction -Execute '{temp_dir}\\{exe_name}' -Argument '{cmd_args}' +$trigger = New-ScheduledTaskTrigger -Once -At 00:00 +$settings = New-ScheduledTaskSettingsSet +$task = New-ScheduledTask -Action $action -Trigger $trigger -Settings $settings +Register-ScheduledTask godot_remote_debug -InputObject $task -Force:$true +Start-ScheduledTask -TaskName godot_remote_debug +while (Get-ScheduledTask -TaskName godot_remote_debug | ? State -eq running) { Start-Sleep -Milliseconds 100 } +Unregister-ScheduledTask -TaskName godot_remote_debug -Confirm:$false -ErrorAction:SilentlyContinue" +ssh_remote_deploy/cleanup_script="Stop-ScheduledTask -TaskName godot_remote_debug -ErrorAction:SilentlyContinue +Unregister-ScheduledTask -TaskName godot_remote_debug -Confirm:$false -ErrorAction:SilentlyContinue +Remove-Item -Recurse -Force '{temp_dir}'" diff --git a/ScreenPlayWallpaper/Godot/ScreenPlayGodot/icon.svg b/ScreenPlayWallpaper/Godot/ScreenPlayGodot/icon.svg new file mode 100644 index 00000000..b370ceb7 --- /dev/null +++ b/ScreenPlayWallpaper/Godot/ScreenPlayGodot/icon.svg @@ -0,0 +1 @@ + diff --git a/ScreenPlayWallpaper/Godot/ScreenPlayGodot/icon.svg.import b/ScreenPlayWallpaper/Godot/ScreenPlayGodot/icon.svg.import new file mode 100644 index 00000000..fb6aa80d --- /dev/null +++ b/ScreenPlayWallpaper/Godot/ScreenPlayGodot/icon.svg.import @@ -0,0 +1,37 @@ +[remap] + +importer="texture" +type="CompressedTexture2D" +uid="uid://by316gekc8lr7" +path="res://.godot/imported/icon.svg-218a8f2b3041327d8a5756f3a245f83b.ctex" +metadata={ +"vram_texture": false +} + +[deps] + +source_file="res://icon.svg" +dest_files=["res://.godot/imported/icon.svg-218a8f2b3041327d8a5756f3a245f83b.ctex"] + +[params] + +compress/mode=0 +compress/high_quality=false +compress/lossy_quality=0.7 +compress/hdr_compression=1 +compress/normal_map=0 +compress/channel_pack=0 +mipmaps/generate=false +mipmaps/limit=-1 +roughness/mode=0 +roughness/src_normal="" +process/fix_alpha_border=true +process/premult_alpha=false +process/normal_map_invert_y=false +process/hdr_as_srgb=false +process/hdr_clamp_exposure=false +process/size_limit=0 +detect_3d/compress_to=1 +svg/scale=1.0 +editor/scale_with_editor_scale=false +editor/convert_colors_with_editor_theme=false diff --git a/ScreenPlayWallpaper/Godot/ScreenPlayGodot/main.gd b/ScreenPlayWallpaper/Godot/ScreenPlayGodot/main.gd new file mode 100644 index 00000000..47808cba --- /dev/null +++ b/ScreenPlayWallpaper/Godot/ScreenPlayGodot/main.gd @@ -0,0 +1,15 @@ +extends Node3D + +func _ready(): + var path = "" + var success = ProjectSettings.load_resource_pack (path) + if success: + var scene_resource = load("res://wallpaper.tscn") + if scene_resource: + var scene_instance = scene_resource.instantiate() + add_child(scene_instance) + else: + print("Failed to load the wallpaper.tscn scene.") + else: + print("Failed to load the PCK file.") + Engine.set_max_fps(24) diff --git a/ScreenPlayWallpaper/Godot/ScreenPlayGodot/main.tscn b/ScreenPlayWallpaper/Godot/ScreenPlayGodot/main.tscn new file mode 100644 index 00000000..c5ef6456 --- /dev/null +++ b/ScreenPlayWallpaper/Godot/ScreenPlayGodot/main.tscn @@ -0,0 +1,6 @@ +[gd_scene load_steps=2 format=3 uid="uid://bc5caslt2tiuk"] + +[ext_resource type="Script" path="res://main.gd" id="1_ceeuk"] + +[node name="Wallpaper" type="Node3D"] +script = ExtResource("1_ceeuk") diff --git a/ScreenPlayWallpaper/Godot/ScreenPlayGodot/project.godot b/ScreenPlayWallpaper/Godot/ScreenPlayGodot/project.godot new file mode 100644 index 00000000..5dd8bb08 --- /dev/null +++ b/ScreenPlayWallpaper/Godot/ScreenPlayGodot/project.godot @@ -0,0 +1,21 @@ +; Engine configuration file. +; It's best edited using the editor UI and not directly, +; since the parameters that go here are not all obvious. +; +; Format: +; [section] ; section goes between [] +; param=value ; assign values to parameters + +config_version=5 + +[application] + +config/name="ScreenPlay" +run/main_scene="res://main.tscn" +config/features=PackedStringArray("4.1", "Mobile") +boot_splash/show_image=false +config/icon="res://icon.svg" + +[rendering] + +renderer/rendering_method="mobile" diff --git a/Tools/defines.py b/Tools/defines.py index 3650ae32..326b1eb4 100644 --- a/Tools/defines.py +++ b/Tools/defines.py @@ -28,3 +28,4 @@ QT_IFW_VERSION = "4.6" VCPKG_VERSION = "f06975f46d8c7a1dad916e1e997584f77ae0c34a" PYTHON_EXECUTABLE = "python" if sys.platform == "win32" else "python3" FFMPEG_VERSION = "5.0.1" +GODOT_VERSION = "4.1.1" diff --git a/Tools/requirements.txt b/Tools/requirements.txt index 9a567f28..f7a1531a 100644 --- a/Tools/requirements.txt +++ b/Tools/requirements.txt @@ -1,2 +1,3 @@ cmake-format -aqtinstall \ No newline at end of file +aqtinstall +requests \ No newline at end of file diff --git a/Tools/setup.py b/Tools/setup.py index 236ca0be..24d29c2f 100755 --- a/Tools/setup.py +++ b/Tools/setup.py @@ -8,6 +8,7 @@ import defines import argparse import util import datetime +import setup_godot from sys import stdout stdout.reconfigure(encoding='utf-8') @@ -119,6 +120,7 @@ def main(): setup_qt() download_ffmpeg.execute() + setup_godot.execute() if system() == "Windows": vcpkg_command = "vcpkg.exe" diff --git a/Tools/setup_godot.py b/Tools/setup_godot.py new file mode 100644 index 00000000..00b57315 --- /dev/null +++ b/Tools/setup_godot.py @@ -0,0 +1,58 @@ +import requests +import zipfile +import platform +from pathlib import Path +# Assuming defines.py exists and has GODOT_VERSION +from defines import GODOT_VERSION +from util import repo_root_path # Assuming util.py exists and has repo_root_path() + + +def execute(): + # Assuming repo_root_path() returns the git repo root path + root_path = Path(repo_root_path()) + godot_path = root_path / "Tools" / "Apps" / "Godot" + + # Create the directory if it doesn't exist + godot_path.mkdir(parents=True, exist_ok=True) + + # Check if Godot executable already exists + for file in godot_path.iterdir(): + if GODOT_VERSION in str(file): + print(f"Godot v{GODOT_VERSION} already exists.") + return + + # Determine OS type + os_type = platform.system().lower() + if os_type == "windows": + os_type = "win64.exe" + elif os_type == "linux": + os_type = "linux.x86_64" + elif os_type == "darwin": # macOS + os_type = "macos.universal" + else: + print("Unsupported OS") + return + + # Download Godot + base_url = "https://github.com/godotengine/godot/releases/download" + file_name = f"Godot_v{GODOT_VERSION}-stable_{os_type}.zip" + url = f"{base_url}/{GODOT_VERSION}-stable/{file_name}" + + response = requests.get(url) + if response.status_code == 200: + download_path = godot_path / file_name + download_path.write_bytes(response.content) + + # Extract ZIP file + with zipfile.ZipFile(download_path, 'r') as zip_ref: + zip_ref.extractall(godot_path) + + # Delete ZIP file + download_path.unlink() + print(f"Successfully installed Godot v{GODOT_VERSION}") + else: + print(f"Failed to download Godot v{GODOT_VERSION} for {os_type}") + + +if __name__ == "__main__": + execute()