@@ -26,144 +26,151 @@ The build_profile.py has a __main__ and is used as a tool
26
26
Its usage is listed as:
27
27
$ python build_profile.py BUILD_PROFILE INPUT_JSON [OUTPUT_JSON]
28
28
]]
29
- function ( build_profile_generate_trimmed_api BUILD_PROFILE INPUT_JSON OUTPUT_JSON )
29
+ function (build_profile_generate_trimmed_api BUILD_PROFILE INPUT_JSON OUTPUT_JSON)
30
30
execute_process (
31
- COMMAND "${Python3_EXECUTABLE} "
32
- "${godot-cpp_SOURCE_DIR}/build_profile.py"
33
- "${BUILD_PROFILE} "
34
- "${INPUT_JSON} "
35
- "${OUTPUT_JSON} "
36
- WORKING_DIRECTORY ${godot-cpp_SOURCE_DIR}
31
+ COMMAND
32
+ "${Python3_EXECUTABLE} " "${godot-cpp_SOURCE_DIR}/build_profile.py" "${BUILD_PROFILE} " "${INPUT_JSON} "
33
+ "${OUTPUT_JSON} "
34
+ WORKING_DIRECTORY ${godot-cpp_SOURCE_DIR}
37
35
)
38
- endfunction ( )
39
-
36
+ endfunction ()
40
37
41
38
#[[ Generate File List
42
39
43
40
Use the binding_generator.py Python script to determine the list of files that
44
41
will be passed to the code generator using extension_api.json.
45
42
NOTE: This happens for every configure.]]
46
- function ( binding_generator_get_file_list OUT_VAR_NAME API_FILEPATH OUTPUT_DIR )
47
-
43
+ function (binding_generator_get_file_list OUT_VAR_NAME API_FILEPATH OUTPUT_DIR)
48
44
# This code snippet will be squashed into a single line
49
45
# The two strings make this a list, in CMake lists are semicolon delimited strings.
50
- set ( PYTHON_SCRIPT
51
- "from binding_generator import print_file_list"
52
- "print_file_list( api_filepath='${API_FILEPATH} ',
46
+ set (PYTHON_SCRIPT
47
+ "from binding_generator import print_file_list"
48
+ "print_file_list( api_filepath='${API_FILEPATH} ',
53
49
output_dir='${OUTPUT_DIR} ',
54
50
headers=True,
55
- sources=True)" )
56
- message ( DEBUG "Python:\n ${PYTHON_SCRIPT} " )
51
+ sources=True)"
52
+ )
53
+ message (DEBUG "Python:\n ${PYTHON_SCRIPT} " )
57
54
58
55
# Strip newlines and whitespace to make it a one-liner.
59
- string ( REGEX REPLACE "\n *" " " PYTHON_SCRIPT "${PYTHON_SCRIPT} " )
56
+ string (REGEX REPLACE "\n *" " " PYTHON_SCRIPT "${PYTHON_SCRIPT} " )
60
57
61
- execute_process ( COMMAND "${Python3_EXECUTABLE} " "-c" "${PYTHON_SCRIPT} "
62
- WORKING_DIRECTORY "${godot-cpp_SOURCE_DIR}"
63
- OUTPUT_VARIABLE GENERATED_FILES_LIST
64
- OUTPUT_STRIP_TRAILING_WHITESPACE
58
+ execute_process (
59
+ COMMAND "${Python3_EXECUTABLE} " "-c" "${PYTHON_SCRIPT} "
60
+ WORKING_DIRECTORY "${godot-cpp_SOURCE_DIR}"
61
+ OUTPUT_VARIABLE GENERATED_FILES_LIST
62
+ OUTPUT_STRIP_TRAILING_WHITESPACE
65
63
)
66
64
67
65
# Debug output
68
- message ( DEBUG "FileList-Begin" )
69
- foreach ( PATH ${GENERATED_FILES_LIST} )
70
- message ( DEBUG ${PATH} )
66
+ message (DEBUG "FileList-Begin" )
67
+ foreach (PATH ${GENERATED_FILES_LIST} )
68
+ message (DEBUG ${PATH} )
71
69
endforeach ()
72
70
73
71
# Error out if the file list generator returned no files.
74
- list ( LENGTH GENERATED_FILES_LIST LIST_LENGTH )
75
- if ( NOT LIST_LENGTH GREATER 0 )
76
- message ( FATAL_ERROR "File List Generation Failed" )
72
+ list (LENGTH GENERATED_FILES_LIST LIST_LENGTH)
73
+ if (NOT LIST_LENGTH GREATER 0)
74
+ message (FATAL_ERROR "File List Generation Failed" )
77
75
endif ()
78
- message ( STATUS "There are ${LIST_LENGTH} Files to generate" )
79
-
80
- set ( ${OUT_VAR_NAME} ${GENERATED_FILES_LIST} PARENT_SCOPE )
81
- endfunction ( )
76
+ message (STATUS "There are ${LIST_LENGTH} Files to generate" )
82
77
78
+ set (${OUT_VAR_NAME} ${GENERATED_FILES_LIST} PARENT_SCOPE)
79
+ endfunction ()
83
80
84
81
#[[ Generate Bindings
85
82
86
83
Using the generated file list, use the binding_generator.py to generate the
87
84
godot-cpp bindings. This will run at build time only if there are files
88
85
missing. ]]
89
- function ( binding_generator_generate_bindings API_FILE USE_TEMPLATE_GET_NODE, BITS, PRECISION, OUTPUT_DIR )
86
+ function (
87
+ binding_generator_generate_bindings
88
+ API_FILE
89
+ USE_TEMPLATE_GET_NODE,
90
+ BITS,
91
+ PRECISION,
92
+ OUTPUT_DIR
93
+ )
90
94
# This code snippet will be squashed into a single line
91
- set ( PYTHON_SCRIPT
92
- "from binding_generator import generate_bindings"
93
- "generate_bindings(
95
+ set (PYTHON_SCRIPT
96
+ "from binding_generator import generate_bindings"
97
+ "generate_bindings(
94
98
api_filepath='${API_FILE} ',
95
99
use_template_get_node='${USE_TEMPLATE_GET_NODE} ',
96
100
bits='${BITS} ',
97
101
precision='${PRECISION} ',
98
- output_dir='${OUTPUT_DIR} ')" )
102
+ output_dir='${OUTPUT_DIR} ')"
103
+ )
99
104
100
- message ( DEBUG "Python:\n ${PYTHON_SCRIPT} " )
105
+ message (DEBUG "Python:\n ${PYTHON_SCRIPT} " )
101
106
102
107
# Strip newlines and whitespace to make it a one-liner.
103
- string ( REGEX REPLACE "\n *" " " PYTHON_SCRIPT "${PYTHON_SCRIPT} " )
104
-
105
- add_custom_command (OUTPUT ${GENERATED_FILES_LIST}
106
- COMMAND "${Python3_EXECUTABLE} " "-c" "${PYTHON_SCRIPT} "
107
- VERBATIM
108
- WORKING_DIRECTORY ${godot-cpp_SOURCE_DIR}
109
- MAIN_DEPENDENCY ${GODOTCPP_GDEXTENSION_API_FILE}
110
- DEPENDS ${godot-cpp_SOURCE_DIR}/binding_generator.py
111
- COMMENT "Generating bindings"
108
+ string (REGEX REPLACE "\n *" " " PYTHON_SCRIPT "${PYTHON_SCRIPT} " )
109
+
110
+ add_custom_command (
111
+ OUTPUT ${GENERATED_FILES_LIST}
112
+ COMMAND "${Python3_EXECUTABLE} " "-c" "${PYTHON_SCRIPT} "
113
+ VERBATIM
114
+ WORKING_DIRECTORY ${godot-cpp_SOURCE_DIR}
115
+ MAIN_DEPENDENCY ${GODOTCPP_GDEXTENSION_API_FILE}
116
+ DEPENDS ${godot-cpp_SOURCE_DIR}/binding_generator.py
117
+ COMMENT "Generating bindings"
112
118
)
113
- endfunction ( )
119
+ add_custom_target (generate_bindings DEPENDS ${GENERATED_FILES_LIST} )
120
+ set_target_properties (generate_bindings PROPERTIES FOLDER "godot-cpp" )
121
+ endfunction ()
114
122
115
123
#[[ Generate doc_data.cpp
116
124
The documentation displayed in the Godot editor is compiled into the extension.
117
125
It takes a list of XML source files, and transforms them into a cpp file that
118
126
is added to the sources list.]]
119
- function ( generate_doc_source OUTPUT_PATH SOURCES )
127
+ function (generate_doc_source OUTPUT_PATH SOURCES )
120
128
# Transform SOURCES CMake LIST
121
129
# quote each path with ''
122
130
# join with , to transform into a python list minus the surrounding []
123
- set ( PYTHON_LIST "${SOURCES} " )
124
- list ( TRANSFORM PYTHON_LIST REPLACE "(.*\. xml)" "'\\ 1'" )
125
- list ( JOIN PYTHON_LIST "," PYTHON_LIST )
131
+ set (PYTHON_LIST "${SOURCES} " )
132
+ list (TRANSFORM PYTHON_LIST REPLACE "(.*\. xml)" "'\\ 1'" )
133
+ list (JOIN PYTHON_LIST "," PYTHON_LIST)
126
134
127
135
get_filename_component (OUTPUT_DIR "${OUTPUT_PATH} " DIRECTORY )
128
- file (MAKE_DIRECTORY ${OUTPUT_DIR} )
136
+ file (MAKE_DIRECTORY ${OUTPUT_DIR} )
129
137
130
138
# Python one-liner to run our command
131
139
# lists in CMake are just strings delimited by ';', so this works.
132
- set ( PYTHON_SCRIPT "from doc_source_generator import generate_doc_source"
133
- "generate_doc_source( '${OUTPUT_PATH} ', [${PYTHON_LIST} ] )" )
134
-
135
- add_custom_command ( OUTPUT "${OUTPUT_PATH} "
136
- COMMAND "${Python3_EXECUTABLE} " "-c" "${PYTHON_SCRIPT} "
137
- VERBATIM
138
- WORKING_DIRECTORY "${godot-cpp_SOURCE_DIR}"
139
- DEPENDS
140
+ set (PYTHON_SCRIPT
141
+ "from doc_source_generator import generate_doc_source"
142
+ "generate_doc_source( '${OUTPUT_PATH} ', [${PYTHON_LIST} ] )"
143
+ )
144
+
145
+ add_custom_command (
146
+ OUTPUT "${OUTPUT_PATH} "
147
+ COMMAND "${Python3_EXECUTABLE} " "-c" "${PYTHON_SCRIPT} "
148
+ VERBATIM
149
+ WORKING_DIRECTORY "${godot-cpp_SOURCE_DIR}"
150
+ DEPENDS #
140
151
"${godot-cpp_SOURCE_DIR}/doc_source_generator.py"
141
152
"${SOURCES} "
142
- COMMENT "Generating: ${OUTPUT_PATH} "
153
+ COMMENT "Generating: ${OUTPUT_PATH} "
143
154
)
155
+ add_custom_target (generate_doc_source DEPENDS "${OUTPUT_PATH} " )
156
+ set_target_properties (generate_doc_source PROPERTIES FOLDER "godot-cpp" )
144
157
endfunction ()
145
158
146
159
#[[ target_doc_sources
147
160
A simpler interface to add xml files as doc source to a output target.
148
161
TARGET: The gdexension library target
149
- SOURCES: a list of xml files to use for source generation and inclusion.
150
- This function also adds a doc_gen target to test source generation.]]
151
- function ( target_doc_sources TARGET SOURCES )
162
+ SOURCES: a list of xml files to use for source generation and inclusion.]]
163
+ function (target_doc_sources TARGET SOURCES )
152
164
# set the generated file name
153
- set ( DOC_SOURCE_FILE "${CMAKE_CURRENT_BINARY_DIR} /gen/doc_source.cpp" )
165
+ set (DOC_SOURCE_FILE "${CMAKE_CURRENT_BINARY_DIR} /gen/doc_source.cpp" )
154
166
155
167
# Create the file generation target, this won't be triggered unless a target
156
168
# that depends on DOC_SOURCE_FILE is built
157
169
generate_doc_source( "${DOC_SOURCE_FILE} " ${SOURCES} )
158
170
159
171
# Add DOC_SOURCE_FILE as a dependency to TARGET
160
- target_sources ( ${TARGET} PRIVATE "${DOC_SOURCE_FILE} " )
172
+ target_sources (${TARGET} PRIVATE "${DOC_SOURCE_FILE} " )
161
173
162
- # Create a dummy target that depends on the source so that users can
163
- # test the file generation task.
164
- if ( TARGET doc_gen )
165
- else ()
166
- add_custom_target ( doc_gen )
167
- endif ()
168
- target_sources ( doc_gen PRIVATE "${DOC_SOURCE_FILE} " )
174
+ # Without adding this dependency to the doc_source_generator, XCode will complain.
175
+ add_dependencies (${TARGET} generate_doc_source)
169
176
endfunction ()
0 commit comments