better syntax, ALL include paths parsing support(TODO include CPPPATH), better headers,

experimental Cmake support

Author: Vano

.gitignore

@@ -10,3 +10,5 @@
 # Scons specific
 *.sconsign.dblite
 
+# Python
+*__pycache__

CMakeLists.txt

@@ -0,0 +1,66 @@
+# TEMPORARILY works only on top of my godot-cpp Cmake rewrite
+cmake_minimum_required(VERSION 3.24)
+project(scripts)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/")
+include(godot-cppscript)
+
+add_subdirectory(godot-cpp)
+
+# Get Sources
+file(GLOB_RECURSE SOURCES ../src/*.c**)
+
+###############################
+set(INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../src)
+set(GEN_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../.gen)
+set(GEN_HEADER ${CMAKE_CURRENT_SOURCE_DIR}/../src/scripts.gen.h)
+
+file(GLOB_RECURSE CPPSCRIPT_HEADERS ../src/*.hpp)
+
+create_cppscript_target(
+	cppscript.h
+	${CMAKE_CURRENT_SOURCE_DIR}
+	${INCLUDE_DIR}
+	${GEN_DIR}
+	${GEN_HEADER}
+	ON
+	CPPSCRIPT_MY_SOURCES
+)
+
+###############################
+# Define our godot-cpp library
+message("MY_SOURCES=${CPPSCRIPT_MY_SOURCES}")
+add_library(${PROJECT_NAME} SHARED
+	${SOURCES}
+	${CPPSCRIPT_MY_SOURCES}
+	${GEN_HEADER}
+	${CPPSCRIPT_HEADERS}
+	src/register_types.cpp
+)
+
+#add_dependencies(${PROJECT_NAME} cppscript-target)
+target_include_directories(${PROJECT_NAME} PRIVATE ../src src/)
+
+target_link_libraries(${PROJECT_NAME} PUBLIC godot-cpp)
+
+get_directory_property(GODOT_C_FLAGS DIRECTORY godot-cpp DEFINITION GODOT_C_FLAGS)
+get_directory_property(GODOT_CXX_FLAGS DIRECTORY godot-cpp DEFINITION GODOT_CXX_FLAGS)
+target_compile_options(${PROJECT_NAME} PRIVATE
+	${GODOT_C_FLAGS}
+	${GODOT_CXX_FLAGS}
+)
+
+get_directory_property(GODOT_LINK_FLAGS DIRECTORY godot-cpp DEFINITION GODOT_LINK_FLAGS)
+target_link_options(${PROJECT_NAME} PRIVATE ${GODOT_LINK_FLAGS}) # -Wl,--as-needed -nostdlib++)
+
+
+get_directory_property(LIBRARY_SUFFIX DIRECTORY godot-cpp DEFINITION LIBRARY_SUFFIX)
+set_target_properties(${PROJECT_NAME}
+	PROPERTIES
+		ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/../bin"
+		LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/../bin"
+		RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/../bin"
+	
+		OUTPUT_NAME "${PROJECT_NAME}${LIBRARY_SUFFIX}"
+)
+

SConstruct

@@ -11,9 +11,10 @@ scripts = GlobRecursive(SRC_DIR, '*.hpp')
 
 env.Append(CPPPATH=[SRC_DIR, 'src'])
 								# CppScript config
+env['header_name'] = 'cppscript.h'				# Name of header to be included to enable cppscript
+								# (Prefer name unique to your project)
 env['src'] = SRC_DIR						# Path to C++ source files
 env['gen_dir'] = "../.gen"					# Path for generated object files
-env['defs_file'] = os.path.join(SRC_DIR, 'defs.json')		# Path to generated bindings
 env['gen_header'] = os.path.join(SRC_DIR, 'scripts.gen.h')	# Path to generated header
 env['auto_methods'] = True					# Generate bindings to public methods automatically
 								# Or require GMETHOD() before methods

cmake/godot-cppscript.cmake

@@ -0,0 +1,40 @@
+find_package(Python3 3.4 REQUIRED)
+
+#TODO: make it work in parallel
+function(create_cppscript_target HEADER_NAME GODOT_CPPSCRIPT_DIR HEADERS_DIR GEN_DIR GEN_HEADER AUTO_METHODS CPPSCRIPT_SOURCES)
+	if(${AUTO_METHODS})
+		set(AUTO_METHODS_STR "True")
+	else()
+		set(AUTO_METHODS_STR "False")
+	endif()
+
+	file(GLOB_RECURSE HEADERS_LIST RELATIVE ${HEADERS_DIR} ${HEADERS_DIR}/*.hpp)
+	
+	foreach(PATH ${HEADERS_LIST})
+		string(REGEX REPLACE "\.hpp$" ".gen.cpp" relative_path "${PATH}")
+		list(APPEND SOURCES_LIST ${GEN_DIR}/${relative_path})
+	endforeach()
+	set(${CPPSCRIPT_SOURCES} ${SOURCES_LIST} PARENT_SCOPE)
+
+	add_custom_command(OUTPUT ${GEN_HEADER} ${SOURCES_LIST}
+		COMMAND ${Python3_EXECUTABLE} "${GODOT_CPPSCRIPT_DIR}/cppscript_bindings.py"
+		"--header-name" "${HEADER_NAME}"
+		"--src" "${HEADERS_DIR}"
+		"--gen-dir" "${GEN_DIR}"
+		"--gen-header" "${GEN_HEADER}"
+		"--auto-methods" "${AUTO_METHODS_STR}"
+		${CPPSCRIPT_HEADERS}
+
+		DEPENDS ${CPPSCRIPT_HEADERS}
+		WORKING_DIRECTORY ${GODOT_CPPSCRIPT_DIR}
+		VERBATIM
+		COMMENT "Parsing header files..."
+	)
+	
+	#add_custom_target(${TARGET_NAME} DEPENDS ${GEN_HEADER} ${SOURCES_LIST})
+	#foreach(file ${SOURCES_LIST})
+	#	file(WRITE ${file} "")
+#	endforeach()
+	file(REMOVE ${GEN_DIR}/defs.json)
+endfunction()
+

cppscript.py

@@ -17,6 +17,23 @@ def GlobRecursive(path, pattern, **kwargs):
 KEYWORDS = ['GPROPERTY', 'GMETHOD', 'GGROUP', 'GSUBGROUP', 'GBITFIELD', 'GSIGNAL', 'GRPC', 'GVARARG', 'GIGNORE']
 INIT_LEVELS = ['GINIT_LEVEL_CORE', 'GINIT_LEVEL_SERVERS', 'GINIT_LEVEL_SCENE', 'GINIT_LEVEL_EDITOR']
 
+CPPSCRIPT_BODY="""#ifndef {0}
+#define {0}
+#include <cppscript_defs.h>
+#include "properties.gen.h"
+#endif // {0}
+"""
+
+RPC_CONFIG_BODY = """	{{
+	Dictionary opts;
+	opts["rpc_mode"] = MultiplayerAPI::{0};
+	opts["transfer_mode"] = MultiplayerPeer::{1};
+	opts["call_local"] = {2};
+	opts["channel"] = {3};
+	rpc_config("{4}", opts);
+	}}
+"""
+
 # Helpers
 class CppScriptException(Exception):
 	pass
@@ -145,14 +162,15 @@ def generate_header_cmake(target, source, env):
 
 def generate_header(target, source, env, get_file):
 	index = Index.create()
-	prop_file_name = os.path.join(env['src'], 'properties.gen.h')
+	prop_file_name = os.path.join(env['src'], 'properties.gen.h') 
 	try:
 		shutil.move(prop_file_name, prop_file_name + '.tmp')
 	except:
 		pass
 
 	try:
-		cached_defs_all = load_defs_json(env['defs_file'])
+		defs_file_path = os.path.join(env['gen_dir'], 'defs.json')
+		cached_defs_all = load_defs_json(defs_file_path)
 		cached_defs = cached_defs_all.get('files', {})
 		need_regen = False
 
@@ -168,6 +186,12 @@ def generate_header(target, source, env, get_file):
 
 		new_defs_all = {'hash' : cached_defs_all.get('hash', None), 'files' : new_defs_files}
 
+		# Create include header if not exists
+		path = os.path.join(env['src'], env['header_name'])
+		if not os.path.exists(path):
+			with open(path, 'w') as file:
+				file.write(CPPSCRIPT_BODY.format(env['header_name'].replace(' ', '_').replace('.', '_').upper()))
+
 		if write_register_header(new_defs_all, env) or need_regen:
 			write_property_header(new_defs_all, env)
 			try:
@@ -180,7 +204,7 @@ def generate_header(target, source, env, get_file):
 			except:
 				pass
 
-		with open(env['defs_file'], 'w') as file:
+		with open(defs_file_path, 'w') as file:
 			json.dump(new_defs_all, file, indent=2, default=lambda x: x if not isinstance(x, set) else list(x))
 
 	except CppScriptException as e:
@@ -245,17 +269,17 @@ def add_class(cursor, macros):
 
 
 		for macro in macros:
-			classes.append((cursor, get_macro_args(filecontent, macro)[1], macro.spelling[1:]))
+			classes.append((cursor, get_macro_args(filecontent, macro)[1], macro))
 
 
 	collapse_list(found_class, lambda x: x.kind == CursorKind.CLASS_DECL, add_class)
 
 	parsed_classes = {}
-	for cursor, base, type in classes:
+	for cursor, base, gdclass_macro in classes:
 		class_defs = {
 			'class_name' : cursor.spelling,
 			'base' : base,
-			'type' : type,
+			'type' : gdclass_macro.spelling[1:],
 			'init_level' : 'SCENE',
 			'methods' : [],
 			'properties' : [],
@@ -266,6 +290,9 @@ def add_class(cursor, macros):
 			}
 		child_cursors = []
 		parse_class(cursor, child_cursors)
+		# Exclude cursors added by GCLASS() macro
+		child_cursors = [i for i in child_cursors if gdclass_macro.extent.start.offset != i.extent.start.offset]
+
 		group, subgroup = '', ''
 		start, end = cursor.extent.start.offset, cursor.extent.end.offset
 		class_macros = sorted([m for m in keyword_macros if start < m.extent.start.offset < end] + child_cursors, key=lambda x: x.extent.start.offset)
@@ -488,15 +515,13 @@ def write_header(file, defs, env):
 					Hmethod += f'\tMethod<&{class_name}::{method["name"]}>::bind(D_METHOD("{method["bind_name"]}"{args}){defvals});\n'
 
 				if 'rpc_config' in method.keys():
-					header_rpc_config += f"""	{{
-	Dictionary opts;
-	opts["rpc_mode"] = MultiplayerAPI::{method['rpc_config']['rpc_mode']};
-	opts["transfer_mode"] = MultiplayerPeer::{method['rpc_config']['transfer_mode']};
-	opts["call_local"] = {method['rpc_config']['call_local']};
-	opts["channel"] = {method['rpc_config']['channel']};
-	rpc_config("{method["name"]}", opts);
-	}}
-"""
+					header_rpc_config += RPC_CONFIG_BODY.format(
+						method['rpc_config']['rpc_mode'],
+						method['rpc_config']['transfer_mode'],
+						method['rpc_config']['call_local'],
+						method['rpc_config']['channel'],
+						method["name"]
+						)
 			else:
 				args_list = '\n'.join(f'\t\t,MakePropertyInfo<{type}>("{name}")' for type, name in method['varargs'])
 

cppscript_bindings.py

@@ -8,18 +8,19 @@
 		prog='cppscript_bindings',
 		description='Generates C++ bindings code for GDExtension')
 
+parser.add_argument('--header-name', type=str, nargs=1, required=True)
 parser.add_argument('--src', type=str, nargs=1, required=True)
 parser.add_argument('--gen-dir', type=str, nargs=1, required=True)
-parser.add_argument('--defs-file', type=str, nargs=1, required=True)
 parser.add_argument('--gen-header', type=str, nargs=1, required=True)
 parser.add_argument('--auto-methods', type=bool, default=True)
 parser.add_argument('sources', nargs='*')
 
 args = parser.parse_args(sys.argv[1:])
 
-env = {	'src' : args.src[0],
-       	'gen_dir' : args.gen_dir[0],
-	'defs_file' : args.defs_file[0],
+env = {
+	'header_name' : args.header_name[0],
+	'src' : args.src[0],
+	'gen_dir' : args.gen_dir[0],
 	'gen_header' : args.gen_header[0],
 	'auto_methods' : args.auto_methods
 }

src/cppscript.h renamed to src/cppscript_defs.h

@@ -1,6 +1,5 @@
-#ifndef CPPSCRIPT_H
-#define CPPSCRIPT_H
-#include "properties.gen.h"
+#ifndef CPPSCRIPT_HEADER
+#define CPPSCRIPT_HEADER
 #include <godot_cpp/classes/multiplayer_api.hpp>
 #include <godot_cpp/classes/multiplayer_peer.hpp>
 
@@ -49,4 +48,4 @@ void function(decltype(property) value) {	\
 #define GINIT_LEVEL_SCENE(...)
 #define GINIT_LEVEL_EDITOR(...)
 
-#endif // CPPSCRIPT_H
+#endif // CPPSCRIPT_HEADER