From fe4a83b90934a48124598a4171b8e0c5d77d51d2 Mon Sep 17 00:00:00 2001 From: Relintai Date: Tue, 8 Feb 2022 12:36:37 +0100 Subject: [PATCH] Changed the Voxelman prefix of the classes to just Voxel as suggested by filipworksdev. Closes #5. Thanks. --- README.md | 24 +- SCsub | 14 +- config.py | 14 +- defines.h | 8 +- doc_classes/BlockVoxelStructure.xml | 68 +- doc_classes/EnvironmentData.xml | 71 +- doc_classes/MarchingCubesCellData.xml | 35 +- doc_classes/README.md | 1 - doc_classes/VoxelChunk.xml | 806 +++++++++++------- doc_classes/VoxelChunkBlocky.xml | 4 +- doc_classes/VoxelChunkCubic.xml | 6 +- doc_classes/VoxelChunkDefault.xml | 432 +++------- doc_classes/VoxelChunkMarchingCubes.xml | 6 +- doc_classes/VoxelChunkPropData.xml | 53 -- doc_classes/VoxelCubePoints.xml | 228 ++--- doc_classes/VoxelJob.xml | 107 +++ ...lGenerator.xml => VoxelLevelGenerator.xml} | 14 +- ...orFlat.xml => VoxelLevelGeneratorFlat.xml} | 2 +- doc_classes/VoxelLibrary.xml | 264 ++++++ ...braryMerger.xml => VoxelLibraryMerger.xml} | 15 +- ...brarySimple.xml => VoxelLibrarySimple.xml} | 2 +- doc_classes/VoxelLight.xml | 23 +- doc_classes/VoxelLightJob.xml | 13 + doc_classes/VoxelLightNode.xml | 13 + doc_classes/VoxelMesher.xml | 270 +++--- doc_classes/VoxelMesherBlocky.xml | 6 +- doc_classes/VoxelMesherCubic.xml | 4 +- doc_classes/VoxelMesherDefault.xml | 4 +- doc_classes/VoxelMesherLiquidBlocky.xml | 2 +- doc_classes/VoxelMesherMarchingCubes.xml | 78 +- doc_classes/VoxelPropJob.xml | 18 + doc_classes/VoxelStructure.xml | 26 +- doc_classes/VoxelSurface.xml | 47 +- doc_classes/VoxelSurfaceMerger.xml | 32 +- doc_classes/VoxelSurfaceSimple.xml | 32 +- doc_classes/VoxelTerrainJob.xml | 73 ++ doc_classes/VoxelWorld.xml | 645 ++++++-------- doc_classes/VoxelWorldBlocky.xml | 2 +- doc_classes/VoxelWorldCubic.xml | 2 +- doc_classes/VoxelWorldDefault.xml | 25 +- doc_classes/VoxelWorldMarchingCubes.xml | 4 +- doc_classes/VoxelmanLibrary.xml | 235 ----- doc_classes/WorldArea.xml | 2 +- ...enerator.cpp => voxel_level_generator.cpp} | 22 +- ...el_generator.h => voxel_level_generator.h} | 18 +- ...lat.cpp => voxel_level_generator_flat.cpp} | 28 +- ...or_flat.h => voxel_level_generator_flat.h} | 14 +- library/voxel_library.cpp | 336 ++++++++ .../{voxelman_library.h => voxel_library.h} | 12 +- ...ry_merger.cpp => voxel_library_merger.cpp} | 127 +-- ...ibrary_merger.h => voxel_library_merger.h} | 14 +- ...ry_simple.cpp => voxel_library_simple.cpp} | 54 +- ...ibrary_simple.h => voxel_library_simple.h} | 14 +- library/voxel_surface.cpp | 6 +- library/voxel_surface.h | 10 +- library/voxel_surface_merger.cpp | 4 +- library/voxel_surface_simple.cpp | 4 +- library/voxelman_library.cpp | 336 -------- meshers/cubic/voxel_mesher_cubic.cpp | 2 +- meshers/voxel_mesher.cpp | 8 +- meshers/voxel_mesher.h | 12 +- nodes/voxel_light_node.cpp | 9 + .../{voxelman_light.h => voxel_light_node.h} | 12 +- nodes/voxelman_light.cpp | 9 - register_types.cpp | 28 +- register_types.h | 4 +- world/blocky/voxel_world_blocky.cpp | 11 +- world/cubic/voxel_world_cubic.cpp | 10 +- world/default/voxel_chunk_default.cpp | 17 +- world/default/voxel_chunk_default.h | 4 +- world/default/voxel_world_default.cpp | 13 +- world/default/voxel_world_default.h | 4 + world/jobs/voxel_job.cpp | 60 +- world/jobs/voxel_job.h | 12 + world/jobs/voxel_light_job.cpp | 4 +- world/jobs/voxel_prop_job.cpp | 17 +- ...terrarin_job.cpp => voxel_terrain_job.cpp} | 114 +-- ...xel_terrarin_job.h => voxel_terrain_job.h} | 16 +- .../voxel_world_marching_cubes.cpp | 10 +- world/voxel_chunk.cpp | 14 +- world/voxel_chunk.h | 8 +- world/voxel_world.cpp | 19 +- world/voxel_world.h | 16 +- world/voxel_world_editor.cpp | 28 +- world/voxel_world_editor.h | 4 +- 85 files changed, 2604 insertions(+), 2590 deletions(-) delete mode 100644 doc_classes/README.md delete mode 100644 doc_classes/VoxelChunkPropData.xml create mode 100644 doc_classes/VoxelJob.xml rename doc_classes/{VoxelmanLevelGenerator.xml => VoxelLevelGenerator.xml} (57%) rename doc_classes/{VoxelmanLevelGeneratorFlat.xml => VoxelLevelGeneratorFlat.xml} (83%) create mode 100644 doc_classes/VoxelLibrary.xml rename doc_classes/{VoxelmanLibraryMerger.xml => VoxelLibraryMerger.xml} (68%) rename doc_classes/{VoxelmanLibrarySimple.xml => VoxelLibrarySimple.xml} (88%) create mode 100644 doc_classes/VoxelLightJob.xml create mode 100644 doc_classes/VoxelLightNode.xml create mode 100644 doc_classes/VoxelPropJob.xml create mode 100644 doc_classes/VoxelTerrainJob.xml delete mode 100644 doc_classes/VoxelmanLibrary.xml rename level_generator/{voxelman_level_generator.cpp => voxel_level_generator.cpp} (75%) rename level_generator/{voxelman_level_generator.h => voxel_level_generator.h} (78%) rename level_generator/{voxelman_level_generator_flat.cpp => voxel_level_generator_flat.cpp} (74%) rename level_generator/{voxelman_level_generator_flat.h => voxel_level_generator_flat.h} (82%) create mode 100644 library/voxel_library.cpp rename library/{voxelman_library.h => voxel_library.h} (96%) rename library/{voxelman_library_merger.cpp => voxel_library_merger.cpp} (71%) rename library/{voxelman_library_merger.h => voxel_library_merger.h} (92%) rename library/{voxelman_library_simple.cpp => voxel_library_simple.cpp} (64%) rename library/{voxelman_library_simple.h => voxel_library_simple.h} (89%) delete mode 100644 library/voxelman_library.cpp create mode 100644 nodes/voxel_light_node.cpp rename nodes/{voxelman_light.h => voxel_light_node.h} (89%) delete mode 100644 nodes/voxelman_light.cpp rename world/jobs/{voxel_terrarin_job.cpp => voxel_terrain_job.cpp} (81%) rename world/jobs/{voxel_terrarin_job.h => voxel_terrain_job.h} (89%) diff --git a/README.md b/README.md index 42ad621..4ac65b8 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# Voxelman +# Voxel A voxel engine module for godot, focusing more on editor integration, gameplay-related features, and extendability (even from gdscript), without sacrificing too much speed. @@ -11,8 +11,8 @@ check whether it works from time to time. ## Optional Dependencies -`https://github.com/Relintai/thread_pool`: Threaded chunk generation. Without this Voxelman is single threaded! \ -`https://github.com/Relintai/texture_packer`: You get access to [VoxelmanLibraryMerger](#voxelmanlibrarymerger). \ +`https://github.com/Relintai/thread_pool`: Threaded chunk generation. Without this Voxel is single threaded! \ +`https://github.com/Relintai/texture_packer`: You get access to [VoxelLibraryMerger](#voxellibrarymerger). \ `https://github.com/Relintai/mesh_data_resource`: You get access to a bunch of properties, and methods that can manipulate meshes.\ `https://github.com/Relintai/props`: You get access to a bunch of properties, and methods that can manipulate, and use props.\ `https://github.com/Relintai/mesh_utils`: Lets you use lod levels higher than 4 by default. @@ -24,7 +24,7 @@ repo, should you want to. It contains all my modules. ## Usage -First create a scene, and add a VoxelWorldBlocky node into it. Create a VoxelmanLibrary, and assign it to the Library property. +First create a scene, and add a VoxelWorldBlocky node into it. Create a VoxelLibrary, and assign it to the Library property. Also, add a VoxelSurface into your library. (VoxelWorldBlocky is the only one that works properly for now, this will soon be fixed!) @@ -34,19 +34,19 @@ voxel at the inspector's camera's location. Select the add button, and now you can just add voxels with the mouse, by clicking on the newly added voxel. -## VoxelmanLibrary +## VoxelLibrary This class stores the materials, and the VoxelSurfaces. Note: If you want lods, assign equal (or more) materials than your maximum lod level. If you only want one material just assign it multiple times. If you don't then your meshes won't have materials (They will be white). -### VoxelmanLibrarySimple +### VoxelLibrarySimple The simplest library, just assign a material with a texture, and using the atlas_rows and atlas_culomns properties to tell the system how the UVs should be divided. -### VoxelmanLibraryMerger +### VoxelLibraryMerger You will only have this if your godot also contains https://github.com/Relintai/texture_packer @@ -81,7 +81,7 @@ You can write your own algorithm by implementing the ``` void _generate_chunk(ch ## VoxelJobs -Producing just a terrarin mesh for a chunk is not that hard by itself. However when you start adding layers/features +Producing just a terrain mesh for a chunk is not that hard by itself. However when you start adding layers/features like lod generation, collision meshes (especially since manipulating the physics server is not threadsafe), vertex volumetric lights, props, snapping props, props with vertex lights, etc chunk mesh generation can quicly become a serious mess. @@ -105,9 +105,9 @@ If you implement your own jobs, when your job finishes call `next_job()`. This is the job that will generate vertex light based ao, random ao, and will bake your `VoxelLight`s. -### VoxelTerrarinJob +### VoxelTerrainJob -This will generate your terrarin collider and mesh (with lods) for you, using the meshers that you add into it. +This will generate your terrain collider and mesh (with lods) for you, using the meshers that you add into it. ### VoxelPropJob @@ -134,7 +134,7 @@ This is done by `setup_chunk(shunk)` in `VoxelWorld`. # We need to check whether or not we need to initialize jobs if chunk.job_get_count() == 0: # Setup a blocky (minecratf like) mesher job - var tj : VoxelTerrarinJob = VoxelTerrarinJob.new() + var tj : VoxelTerrainJob = VoxelTerrainJob.new() tj.add_mesher(VoxelMesherBlocky.new()) tj.add_liquid_mesher(VoxelMesherLiquidBlocky.new()) @@ -148,7 +148,7 @@ This is done by `setup_chunk(shunk)` in `VoxelWorld`. #### VoxelChunk -Stores terrarin data, prop data. And mesh data (VoxelChunkDefault), and the mesh generation jobs. +Stores terrain data, prop data. And mesh data (VoxelChunkDefault), and the mesh generation jobs. When it starts building meshes it will start submitting jobs to thread_pool (if present) one by one. diff --git a/SCsub b/SCsub index 79d30de..7d56ca6 100644 --- a/SCsub +++ b/SCsub @@ -25,10 +25,10 @@ sources = [ "register_types.cpp", - "library/voxelman_library.cpp", - "library/voxelman_library_simple.cpp", + "library/voxel_library.cpp", + "library/voxel_library_simple.cpp", - "nodes/voxelman_light.cpp", + "nodes/voxel_light_node.cpp", "library/voxel_surface.cpp", "library/voxel_surface_simple.cpp", @@ -63,8 +63,8 @@ sources = [ "meshers/cubic/voxel_mesher_cubic.cpp", "meshers/cubic/voxel_cube_points.cpp", - "level_generator/voxelman_level_generator.cpp", - "level_generator/voxelman_level_generator_flat.cpp", + "level_generator/voxel_level_generator.cpp", + "level_generator/voxel_level_generator_flat.cpp", "world/cubic/voxel_chunk_cubic.cpp", "world/cubic/voxel_world_cubic.cpp", @@ -76,13 +76,13 @@ sources = [ "thirdparty/lz4/lz4.c", "world/jobs/voxel_job.cpp", - "world/jobs/voxel_terrarin_job.cpp", + "world/jobs/voxel_terrain_job.cpp", "world/jobs/voxel_light_job.cpp", "world/jobs/voxel_prop_job.cpp", ] if has_texture_packer: - sources.append("library/voxelman_library_merger.cpp") + sources.append("library/voxel_library_merger.cpp") sources.append("library/voxel_surface_merger.cpp") if ARGUMENTS.get('custom_modules_shared', 'no') == 'yes': diff --git a/config.py b/config.py index 17106ef..be52a38 100644 --- a/config.py +++ b/config.py @@ -13,17 +13,17 @@ def get_doc_classes(): "WorldArea", "VoxelLight", - "VoxelmanLight", + "VoxelLightNode", - "VoxelmanLevelGenerator", - "VoxelmanLevelGeneratorFlat", + "VoxelLevelGenerator", + "VoxelLevelGeneratorFlat", "VoxelSurfaceMerger", "VoxelSurfaceSimple", "VoxelSurface", - "VoxelmanLibraryMerger", - "VoxelmanLibrarySimple", - "VoxelmanLibrary", + "VoxelLibraryMerger", + "VoxelLibrarySimple", + "VoxelLibrary", "VoxelCubePoints", "VoxelMesherCubic", @@ -57,7 +57,7 @@ def get_doc_classes(): "VoxelWorldDefault", "VoxelJob", - "VoxelTerrarinJob", + "VoxelTerrainJob", "VoxelLightJob", "VoxelPropJob", ] diff --git a/defines.h b/defines.h index 9b1fe89..2f81842 100644 --- a/defines.h +++ b/defines.h @@ -1,6 +1,6 @@ -#ifndef VOXELMAN_DEFINES_H -#define VOXELMAN_DEFINES_H +#ifndef VOXEL_DEFINES_H +#define VOXEL_DEFINES_H #include "core/version.h" @@ -114,11 +114,15 @@ typedef class RenderingServer VS; #define CONNECT(sig, obj, target_method_class, method) connect(sig, callable_mp(obj, &target_method_class::method)) #define DISCONNECT(sig, obj, target_method_class, method) disconnect(sig, callable_mp(obj, &target_method_class::method)) #define GET_WORLD get_world_3d +#define INSTANCE instantiate +#define VREMOVE remove_at #else #define INSTANCE_VALIDATE(var) ObjectDB::instance_validate(var) #define CONNECT(sig, obj, target_method_class, method) connect(sig, obj, #method) #define DISCONNECT(sig, obj, target_method_class, method) disconnect(sig, obj, #method) #define GET_WORLD get_world +#define INSTANCE instance +#define VREMOVE remove #endif #endif \ No newline at end of file diff --git a/doc_classes/BlockVoxelStructure.xml b/doc_classes/BlockVoxelStructure.xml index 8c6209a..35711e9 100644 --- a/doc_classes/BlockVoxelStructure.xml +++ b/doc_classes/BlockVoxelStructure.xml @@ -1,5 +1,5 @@ - + @@ -7,65 +7,37 @@ - - - - - - - - - - - + + + + + - - - - - - - - - + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + - + + + diff --git a/doc_classes/EnvironmentData.xml b/doc_classes/EnvironmentData.xml index dfd4c4b..17b859e 100644 --- a/doc_classes/EnvironmentData.xml +++ b/doc_classes/EnvironmentData.xml @@ -1,5 +1,5 @@ - + @@ -8,80 +8,57 @@ - - - - - - - - + + + + - - - - + + - - - - + + - - - - + + - - - - - - + + + - - - - - - + + + - - - - - - + + + - - - - - - - - + + + + diff --git a/doc_classes/MarchingCubesCellData.xml b/doc_classes/MarchingCubesCellData.xml index e21798b..2d663a4 100644 --- a/doc_classes/MarchingCubesCellData.xml +++ b/doc_classes/MarchingCubesCellData.xml @@ -1,5 +1,5 @@ - + @@ -8,48 +8,37 @@ - - + - - + - - - - + + - - - - + + - - - - + + - - - - - - + + + diff --git a/doc_classes/README.md b/doc_classes/README.md deleted file mode 100644 index b1ec905..0000000 --- a/doc_classes/README.md +++ /dev/null @@ -1 +0,0 @@ -Doc classes will appear here when generating \ No newline at end of file diff --git a/doc_classes/VoxelChunk.xml b/doc_classes/VoxelChunk.xml index ae078dd..5d404c6 100644 --- a/doc_classes/VoxelChunk.xml +++ b/doc_classes/VoxelChunk.xml @@ -1,5 +1,5 @@ - + @@ -8,496 +8,685 @@ - - - - + + - - + + + + + + + + + + + - - - - - - - - + - - + - - + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + - - - - - - - - - - - - - - - - - - + + - - - - + + - - - - + + - - - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - + - - - - + + - - + - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + - - - + + + + + + - - - + + + - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + - - + - - - - - - - + + - - - - - + + + - - - - - + + + - - - - - - - - + + + + - - + + + + + + - - - - - - - - - - - - - - - - - - - - - - + + + + - - + - - + - - - - - - - - - - - - - - - - + - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + - - + - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + - - - - + + - - - - - + + + + - - - - - + + + - - - - - - - + + - - - - - - - + + + - - - - - - - + + - - - - + + - - - - - - - - + + + + - - - - + + - - - - - - - - - - - - + + + + + + - - - - - - - - - - - - + + + + + + - - - + + + - - - - - - - - - + + + + + + + + + + + - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + - - - - + + - - + - + @@ -511,7 +700,7 @@ - + @@ -537,13 +726,14 @@ + + - - + diff --git a/doc_classes/VoxelChunkBlocky.xml b/doc_classes/VoxelChunkBlocky.xml index 69331ad..f5d9874 100644 --- a/doc_classes/VoxelChunkBlocky.xml +++ b/doc_classes/VoxelChunkBlocky.xml @@ -1,5 +1,5 @@ - + @@ -9,7 +9,7 @@ - + diff --git a/doc_classes/VoxelChunkCubic.xml b/doc_classes/VoxelChunkCubic.xml index fc69c91..1999a69 100644 --- a/doc_classes/VoxelChunkCubic.xml +++ b/doc_classes/VoxelChunkCubic.xml @@ -1,5 +1,5 @@ - + @@ -9,9 +9,9 @@ - + - + diff --git a/doc_classes/VoxelChunkDefault.xml b/doc_classes/VoxelChunkDefault.xml index ee7d254..d81da0d 100644 --- a/doc_classes/VoxelChunkDefault.xml +++ b/doc_classes/VoxelChunkDefault.xml @@ -1,5 +1,5 @@ - + @@ -7,403 +7,249 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + - - - - - - + + + - - - + + + - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + - - - - - - + + + + + + + + - - + - - - - - - + + + - - + - - + - - - - - - - - - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + - - - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + - - + - - - - - - - + + + + - - - - - - - + + + + - - - + + + + + - - - + + + + + - - - - - - - - - + + + + + + - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + - + - + - + - + - + - + - + - + - - - + diff --git a/doc_classes/VoxelChunkMarchingCubes.xml b/doc_classes/VoxelChunkMarchingCubes.xml index 482542f..43a5735 100644 --- a/doc_classes/VoxelChunkMarchingCubes.xml +++ b/doc_classes/VoxelChunkMarchingCubes.xml @@ -1,5 +1,5 @@ - + @@ -9,9 +9,9 @@ - + - + diff --git a/doc_classes/VoxelChunkPropData.xml b/doc_classes/VoxelChunkPropData.xml deleted file mode 100644 index 03d133f..0000000 --- a/doc_classes/VoxelChunkPropData.xml +++ /dev/null @@ -1,53 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/doc_classes/VoxelCubePoints.xml b/doc_classes/VoxelCubePoints.xml index 44106cd..76ee7ad 100644 --- a/doc_classes/VoxelCubePoints.xml +++ b/doc_classes/VoxelCubePoints.xml @@ -1,5 +1,5 @@ - + @@ -8,259 +8,197 @@ - - - - + + - - - - + + - - - - + + - - - - - - + + + - - - - - - + + + - - - - - - + + + - - - - - - + + + + + + + + + - - - - + + - - - - + + - - - - + + - - - - + + - - - - - - + + + - - - - - - - - + + + + - - - - - - + + + - - - - + + - - - - + + - - - - - - + + + - - - - - - + + + - - - - + + - - - - + + - - - - - - + + + - - + - - - - + + - - - - - - - - + + + + - - + - - - - - - - - - - + + + + + - - - - - - - - - - - - + + + + + + + + + + diff --git a/doc_classes/VoxelJob.xml b/doc_classes/VoxelJob.xml new file mode 100644 index 0000000..e591d69 --- /dev/null +++ b/doc_classes/VoxelJob.xml @@ -0,0 +1,107 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/doc_classes/VoxelmanLevelGenerator.xml b/doc_classes/VoxelLevelGenerator.xml similarity index 57% rename from doc_classes/VoxelmanLevelGenerator.xml rename to doc_classes/VoxelLevelGenerator.xml index f5134f7..74d5efa 100644 --- a/doc_classes/VoxelmanLevelGenerator.xml +++ b/doc_classes/VoxelLevelGenerator.xml @@ -1,5 +1,5 @@ - + @@ -8,18 +8,14 @@ - - - - + + - - - - + + diff --git a/doc_classes/VoxelmanLevelGeneratorFlat.xml b/doc_classes/VoxelLevelGeneratorFlat.xml similarity index 83% rename from doc_classes/VoxelmanLevelGeneratorFlat.xml rename to doc_classes/VoxelLevelGeneratorFlat.xml index 5e9d423..58d3bc3 100644 --- a/doc_classes/VoxelmanLevelGeneratorFlat.xml +++ b/doc_classes/VoxelLevelGeneratorFlat.xml @@ -1,5 +1,5 @@ - + diff --git a/doc_classes/VoxelLibrary.xml b/doc_classes/VoxelLibrary.xml new file mode 100644 index 0000000..f13527a --- /dev/null +++ b/doc_classes/VoxelLibrary.xml @@ -0,0 +1,264 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/doc_classes/VoxelmanLibraryMerger.xml b/doc_classes/VoxelLibraryMerger.xml similarity index 68% rename from doc_classes/VoxelmanLibraryMerger.xml rename to doc_classes/VoxelLibraryMerger.xml index 27a0ef8..15863d0 100644 --- a/doc_classes/VoxelmanLibraryMerger.xml +++ b/doc_classes/VoxelLibraryMerger.xml @@ -1,5 +1,5 @@ - + @@ -7,6 +7,17 @@ + + + + + + + + + + + @@ -17,6 +28,8 @@ + + diff --git a/doc_classes/VoxelmanLibrarySimple.xml b/doc_classes/VoxelLibrarySimple.xml similarity index 88% rename from doc_classes/VoxelmanLibrarySimple.xml rename to doc_classes/VoxelLibrarySimple.xml index 875ad22..a88cd4f 100644 --- a/doc_classes/VoxelmanLibrarySimple.xml +++ b/doc_classes/VoxelLibrarySimple.xml @@ -1,5 +1,5 @@ - + diff --git a/doc_classes/VoxelLight.xml b/doc_classes/VoxelLight.xml index b82335b..b5f82fa 100644 --- a/doc_classes/VoxelLight.xml +++ b/doc_classes/VoxelLight.xml @@ -1,5 +1,5 @@ - + @@ -8,32 +8,25 @@ - - + - - + - - + - - - - - - - - + + + + diff --git a/doc_classes/VoxelLightJob.xml b/doc_classes/VoxelLightJob.xml new file mode 100644 index 0000000..dbd019a --- /dev/null +++ b/doc_classes/VoxelLightJob.xml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/doc_classes/VoxelLightNode.xml b/doc_classes/VoxelLightNode.xml new file mode 100644 index 0000000..09690d8 --- /dev/null +++ b/doc_classes/VoxelLightNode.xml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/doc_classes/VoxelMesher.xml b/doc_classes/VoxelMesher.xml index 1377cb1..41b253e 100644 --- a/doc_classes/VoxelMesher.xml +++ b/doc_classes/VoxelMesher.xml @@ -1,5 +1,5 @@ - + @@ -8,348 +8,274 @@ - - - - + + - - - - + + - - - - + + - - - - + + - - - - + + - - - - + + - - - - + + - - - - - - - - - - - - + + + + + + - - - - - - - - + + + + + + + + + + + + + - - - - + + - - - - + + - - - - + + - - - - + + - - - - + + - - - - + + - - - - + + - - + - - + - - - - + + - - - - + + - - - - + + - - + - - - - + + - - + - - + - - - - + + - - + - - - - + + - - - - + + - - + - - + - - - - + + - - + - - + - - + - - + - - - - + + - - - - + + - - + - - - - + + - - - - + + - - - - + + - - - - + + - - - - + + - - - - + + @@ -359,16 +285,20 @@ + + + + - - - + + + diff --git a/doc_classes/VoxelMesherBlocky.xml b/doc_classes/VoxelMesherBlocky.xml index dfa6fcb..d1e4be5 100644 --- a/doc_classes/VoxelMesherBlocky.xml +++ b/doc_classes/VoxelMesherBlocky.xml @@ -1,5 +1,5 @@ - + @@ -8,6 +8,10 @@ + + + + diff --git a/doc_classes/VoxelMesherCubic.xml b/doc_classes/VoxelMesherCubic.xml index 92dd186..3dc5ef3 100644 --- a/doc_classes/VoxelMesherCubic.xml +++ b/doc_classes/VoxelMesherCubic.xml @@ -1,5 +1,5 @@ - + @@ -9,7 +9,7 @@ - + diff --git a/doc_classes/VoxelMesherDefault.xml b/doc_classes/VoxelMesherDefault.xml index 3992c3a..65aa71b 100644 --- a/doc_classes/VoxelMesherDefault.xml +++ b/doc_classes/VoxelMesherDefault.xml @@ -1,5 +1,5 @@ - + @@ -11,7 +11,7 @@ - + diff --git a/doc_classes/VoxelMesherLiquidBlocky.xml b/doc_classes/VoxelMesherLiquidBlocky.xml index 33704f5..3ad998c 100644 --- a/doc_classes/VoxelMesherLiquidBlocky.xml +++ b/doc_classes/VoxelMesherLiquidBlocky.xml @@ -1,5 +1,5 @@ - + diff --git a/doc_classes/VoxelMesherMarchingCubes.xml b/doc_classes/VoxelMesherMarchingCubes.xml index d9e86b0..78d1417 100644 --- a/doc_classes/VoxelMesherMarchingCubes.xml +++ b/doc_classes/VoxelMesherMarchingCubes.xml @@ -1,5 +1,5 @@ - + @@ -8,94 +8,68 @@ - - - - + + - - - - + + - - - - + + - - - - - - + + + - - - - - - + + + - - - - - - + + + - - - - - - + + + - - - - - - + + + - - - - - - + + + - - - + diff --git a/doc_classes/VoxelPropJob.xml b/doc_classes/VoxelPropJob.xml new file mode 100644 index 0000000..0f82876 --- /dev/null +++ b/doc_classes/VoxelPropJob.xml @@ -0,0 +1,18 @@ + + + + + + + + + + + + + + + + + + diff --git a/doc_classes/VoxelStructure.xml b/doc_classes/VoxelStructure.xml index 37771c0..e01a019 100644 --- a/doc_classes/VoxelStructure.xml +++ b/doc_classes/VoxelStructure.xml @@ -1,5 +1,5 @@ - + @@ -8,30 +8,22 @@ - - - - + + - - - - - - - - + + + + - - - - + + diff --git a/doc_classes/VoxelSurface.xml b/doc_classes/VoxelSurface.xml index 12e4113..bb1f2b1 100644 --- a/doc_classes/VoxelSurface.xml +++ b/doc_classes/VoxelSurface.xml @@ -1,5 +1,5 @@ - + @@ -8,52 +8,37 @@ - - - - + + - - + - - - - - - + + + - - - - - - + + + - - - - - - - - - - - - + + + + + + diff --git a/doc_classes/VoxelSurfaceMerger.xml b/doc_classes/VoxelSurfaceMerger.xml index f506824..80e7d8d 100644 --- a/doc_classes/VoxelSurfaceMerger.xml +++ b/doc_classes/VoxelSurfaceMerger.xml @@ -1,5 +1,5 @@ - + @@ -8,38 +8,28 @@ - - - - + + - - - - + + - - - - - - + + + - - - - - - + + + diff --git a/doc_classes/VoxelSurfaceSimple.xml b/doc_classes/VoxelSurfaceSimple.xml index 5c1ac41..00f6323 100644 --- a/doc_classes/VoxelSurfaceSimple.xml +++ b/doc_classes/VoxelSurfaceSimple.xml @@ -1,5 +1,5 @@ - + @@ -8,38 +8,28 @@ - - - - + + - - - - + + - - - - - - + + + - - - - - - + + + diff --git a/doc_classes/VoxelTerrainJob.xml b/doc_classes/VoxelTerrainJob.xml new file mode 100644 index 0000000..52d4352 --- /dev/null +++ b/doc_classes/VoxelTerrainJob.xml @@ -0,0 +1,73 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/doc_classes/VoxelWorld.xml b/doc_classes/VoxelWorld.xml index 259c119..2e85e8d 100644 --- a/doc_classes/VoxelWorld.xml +++ b/doc_classes/VoxelWorld.xml @@ -1,5 +1,5 @@ - + @@ -7,441 +7,351 @@ - - - - - - - - - - - - + + - - - - - - - - - - + + + + + - - - - + + - - + - - - - + + - - - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + - - + - - - + + + + + + - - - + + + + + - - - + + + + + - - - + + - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + - - - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -455,7 +365,7 @@ - + @@ -465,9 +375,9 @@ - + - + @@ -481,13 +391,12 @@ - + - - + diff --git a/doc_classes/VoxelWorldBlocky.xml b/doc_classes/VoxelWorldBlocky.xml index 0880e0b..68ca753 100644 --- a/doc_classes/VoxelWorldBlocky.xml +++ b/doc_classes/VoxelWorldBlocky.xml @@ -1,5 +1,5 @@ - + diff --git a/doc_classes/VoxelWorldCubic.xml b/doc_classes/VoxelWorldCubic.xml index 9e822bb..53a9afc 100644 --- a/doc_classes/VoxelWorldCubic.xml +++ b/doc_classes/VoxelWorldCubic.xml @@ -1,5 +1,5 @@ - + diff --git a/doc_classes/VoxelWorldDefault.xml b/doc_classes/VoxelWorldDefault.xml index 95b4b15..04e12e9 100644 --- a/doc_classes/VoxelWorldDefault.xml +++ b/doc_classes/VoxelWorldDefault.xml @@ -1,5 +1,5 @@ - + @@ -8,14 +8,21 @@ - - + + + + + + + + + + - - + @@ -23,10 +30,14 @@ - - + + + + + + diff --git a/doc_classes/VoxelWorldMarchingCubes.xml b/doc_classes/VoxelWorldMarchingCubes.xml index 74c39f8..cd3eb6b 100644 --- a/doc_classes/VoxelWorldMarchingCubes.xml +++ b/doc_classes/VoxelWorldMarchingCubes.xml @@ -1,5 +1,5 @@ - + @@ -9,7 +9,7 @@ - + diff --git a/doc_classes/VoxelmanLibrary.xml b/doc_classes/VoxelmanLibrary.xml deleted file mode 100644 index 32ddefa..0000000 --- a/doc_classes/VoxelmanLibrary.xml +++ /dev/null @@ -1,235 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/doc_classes/WorldArea.xml b/doc_classes/WorldArea.xml index 7b4e12a..2dac1af 100644 --- a/doc_classes/WorldArea.xml +++ b/doc_classes/WorldArea.xml @@ -1,5 +1,5 @@ - + diff --git a/level_generator/voxelman_level_generator.cpp b/level_generator/voxel_level_generator.cpp similarity index 75% rename from level_generator/voxelman_level_generator.cpp rename to level_generator/voxel_level_generator.cpp index c676685..21da49c 100644 --- a/level_generator/voxelman_level_generator.cpp +++ b/level_generator/voxel_level_generator.cpp @@ -20,24 +20,34 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#include "voxelman_level_generator.h" +#include "voxel_level_generator.h" + +#include "core/version.h" #include "../world/voxel_chunk.h" -void VoxelmanLevelGenerator::generate_chunk(Ref chunk) { +void VoxelLevelGenerator::generate_chunk(Ref chunk) { +#if VERSION_MAJOR < 4 if (has_method("_generate_chunk")) { call("_generate_chunk", chunk); } +#else + GDVIRTUAL_CALL(_generate_chunk, chunk); +#endif } -VoxelmanLevelGenerator::VoxelmanLevelGenerator() { +VoxelLevelGenerator::VoxelLevelGenerator() { } -VoxelmanLevelGenerator::~VoxelmanLevelGenerator() { +VoxelLevelGenerator::~VoxelLevelGenerator() { } -void VoxelmanLevelGenerator::_bind_methods() { +void VoxelLevelGenerator::_bind_methods() { +#if VERSION_MAJOR < 4 BIND_VMETHOD(MethodInfo("_generate_chunk", PropertyInfo(Variant::OBJECT, "chunk", PROPERTY_HINT_RESOURCE_TYPE, "VoxelChunk"))); +#else + GDVIRTUAL_BIND(_generate_chunk, "chunk"); +#endif - ClassDB::bind_method(D_METHOD("generate_chunk", "chunk"), &VoxelmanLevelGenerator::generate_chunk); + ClassDB::bind_method(D_METHOD("generate_chunk", "chunk"), &VoxelLevelGenerator::generate_chunk); } diff --git a/level_generator/voxelman_level_generator.h b/level_generator/voxel_level_generator.h similarity index 78% rename from level_generator/voxelman_level_generator.h rename to level_generator/voxel_level_generator.h index d696ec1..1613697 100644 --- a/level_generator/voxelman_level_generator.h +++ b/level_generator/voxel_level_generator.h @@ -20,27 +20,33 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#ifndef VOXELMAN_LEVEL_GENERATOR_H -#define VOXELMAN_LEVEL_GENERATOR_H +#ifndef VOXEL_LEVEL_GENERATOR_H +#define VOXEL_LEVEL_GENERATOR_H #include "core/version.h" #if VERSION_MAJOR > 3 #include "core/io/resource.h" +#include "core/object/gdvirtual.gen.inc" +#include "core/object/script_language.h" #else #include "core/resource.h" #endif class VoxelChunk; -class VoxelmanLevelGenerator : public Resource { - GDCLASS(VoxelmanLevelGenerator, Resource); +class VoxelLevelGenerator : public Resource { + GDCLASS(VoxelLevelGenerator, Resource); public: void generate_chunk(Ref chunk); - VoxelmanLevelGenerator(); - ~VoxelmanLevelGenerator(); +#if VERSION_MAJOR >= 4 + GDVIRTUAL1(_generate_chunk, Ref); +#endif + + VoxelLevelGenerator(); + ~VoxelLevelGenerator(); protected: static void _bind_methods(); diff --git a/level_generator/voxelman_level_generator_flat.cpp b/level_generator/voxel_level_generator_flat.cpp similarity index 74% rename from level_generator/voxelman_level_generator_flat.cpp rename to level_generator/voxel_level_generator_flat.cpp index d473220..9abcc6e 100644 --- a/level_generator/voxelman_level_generator_flat.cpp +++ b/level_generator/voxel_level_generator_flat.cpp @@ -20,25 +20,25 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#include "voxelman_level_generator_flat.h" +#include "voxel_level_generator_flat.h" #include "../world/voxel_chunk.h" -int VoxelmanLevelGeneratorFlat::get_floor_position() const { +int VoxelLevelGeneratorFlat::get_floor_position() const { return _floor_position; } -void VoxelmanLevelGeneratorFlat::set_floor_position(const int floor_height) { +void VoxelLevelGeneratorFlat::set_floor_position(const int floor_height) { _floor_position = floor_height; } -Dictionary VoxelmanLevelGeneratorFlat::get_channel_map() { +Dictionary VoxelLevelGeneratorFlat::get_channel_map() { return _channel_map; } -void VoxelmanLevelGeneratorFlat::set_channel_map(const Dictionary &map) { +void VoxelLevelGeneratorFlat::set_channel_map(const Dictionary &map) { _channel_map = map; } -void VoxelmanLevelGeneratorFlat::_generate_chunk(Ref chunk) { +void VoxelLevelGeneratorFlat::_generate_chunk(Ref chunk) { int dymin = chunk->get_position_y() * chunk->get_size_y(); int dymax = dymin + chunk->get_size_y() + chunk->get_margin_end(); @@ -82,22 +82,22 @@ void VoxelmanLevelGeneratorFlat::_generate_chunk(Ref chunk) { } } -VoxelmanLevelGeneratorFlat::VoxelmanLevelGeneratorFlat() { +VoxelLevelGeneratorFlat::VoxelLevelGeneratorFlat() { _floor_position = 0; } -VoxelmanLevelGeneratorFlat::~VoxelmanLevelGeneratorFlat() { +VoxelLevelGeneratorFlat::~VoxelLevelGeneratorFlat() { _channel_map.clear(); } -void VoxelmanLevelGeneratorFlat::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_floor_position"), &VoxelmanLevelGeneratorFlat::get_floor_position); - ClassDB::bind_method(D_METHOD("set_floor_position", "value"), &VoxelmanLevelGeneratorFlat::set_floor_position); +void VoxelLevelGeneratorFlat::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_floor_position"), &VoxelLevelGeneratorFlat::get_floor_position); + ClassDB::bind_method(D_METHOD("set_floor_position", "value"), &VoxelLevelGeneratorFlat::set_floor_position); ADD_PROPERTY(PropertyInfo(Variant::INT, "floor_position"), "set_floor_position", "get_floor_position"); - ClassDB::bind_method(D_METHOD("get_channel_map"), &VoxelmanLevelGeneratorFlat::get_channel_map); - ClassDB::bind_method(D_METHOD("set_channel_map", "value"), &VoxelmanLevelGeneratorFlat::set_channel_map); + ClassDB::bind_method(D_METHOD("get_channel_map"), &VoxelLevelGeneratorFlat::get_channel_map); + ClassDB::bind_method(D_METHOD("set_channel_map", "value"), &VoxelLevelGeneratorFlat::set_channel_map); ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY, "channel_map"), "set_channel_map", "get_channel_map"); - ClassDB::bind_method(D_METHOD("_generate_chunk", "chunk"), &VoxelmanLevelGeneratorFlat::_generate_chunk); + ClassDB::bind_method(D_METHOD("_generate_chunk", "chunk"), &VoxelLevelGeneratorFlat::_generate_chunk); } diff --git a/level_generator/voxelman_level_generator_flat.h b/level_generator/voxel_level_generator_flat.h similarity index 82% rename from level_generator/voxelman_level_generator_flat.h rename to level_generator/voxel_level_generator_flat.h index 90b605c..65e3130 100644 --- a/level_generator/voxelman_level_generator_flat.h +++ b/level_generator/voxel_level_generator_flat.h @@ -20,15 +20,15 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#ifndef VOXELMAN_LEVEL_GENERATOR_FLAT_H -#define VOXELMAN_LEVEL_GENERATOR_FLAT_H +#ifndef VOXEL_LEVEL_GENERATOR_FLAT_H +#define VOXEL_LEVEL_GENERATOR_FLAT_H -#include "voxelman_level_generator.h" +#include "voxel_level_generator.h" class VoxelChunk; -class VoxelmanLevelGeneratorFlat : public VoxelmanLevelGenerator { - GDCLASS(VoxelmanLevelGeneratorFlat, VoxelmanLevelGenerator); +class VoxelLevelGeneratorFlat : public VoxelLevelGenerator { + GDCLASS(VoxelLevelGeneratorFlat, VoxelLevelGenerator); public: int get_floor_position() const; @@ -39,8 +39,8 @@ public: virtual void _generate_chunk(Ref chunk); - VoxelmanLevelGeneratorFlat(); - ~VoxelmanLevelGeneratorFlat(); + VoxelLevelGeneratorFlat(); + ~VoxelLevelGeneratorFlat(); protected: static void _bind_methods(); diff --git a/library/voxel_library.cpp b/library/voxel_library.cpp new file mode 100644 index 0000000..e45e26d --- /dev/null +++ b/library/voxel_library.cpp @@ -0,0 +1,336 @@ +/* +Copyright (c) 2019-2020 Péter Magyar + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include "voxel_library.h" + +#ifdef PROPS_PRESENT +#include "../../props/props/prop_data.h" +#endif + +#include "scene/resources/packed_scene.h" + +#include "../defines.h" + +bool VoxelLibrary::get_initialized() const { + return _initialized; +} +void VoxelLibrary::set_initialized(const bool value) { + _initialized = value; +} + +//Materials +Ref VoxelLibrary::material_get(const int index) { + ERR_FAIL_INDEX_V(index, _materials.size(), Ref(NULL)); + + return _materials[index]; +} + +void VoxelLibrary::material_add(const Ref &value) { + ERR_FAIL_COND(!value.is_valid()); + + _materials.push_back(value); +} + +void VoxelLibrary::material_set(const int index, const Ref &value) { + ERR_FAIL_INDEX(index, _materials.size()); + + _materials.set(index, value); +} + +void VoxelLibrary::material_remove(const int index) { +#if VERSION_MAJOR <= 3 + _materials.remove(index); +#else + _materials.remove_at(index); +#endif +} + +int VoxelLibrary::material_get_num() const { + return _materials.size(); +} + +void VoxelLibrary::materials_clear() { + _materials.clear(); +} + +Vector VoxelLibrary::materials_get() { + VARIANT_ARRAY_GET(_materials); +} + +void VoxelLibrary::materials_set(const Vector &materials) { + _materials.clear(); + + for (int i = 0; i < materials.size(); i++) { + Ref material = Ref(materials[i]); + + _materials.push_back(material); + } +} + +//Liquid Materials +Ref VoxelLibrary::liquid_material_get(const int index) { + ERR_FAIL_INDEX_V(index, _liquid_materials.size(), Ref(NULL)); + + return _liquid_materials[index]; +} + +void VoxelLibrary::liquid_material_add(const Ref &value) { + ERR_FAIL_COND(!value.is_valid()); + + _liquid_materials.push_back(value); +} + +void VoxelLibrary::liquid_material_set(const int index, const Ref &value) { + ERR_FAIL_INDEX(index, _liquid_materials.size()); + + _liquid_materials.set(index, value); +} + +void VoxelLibrary::liquid_material_remove(const int index) { +#if VERSION_MAJOR <= 3 + _liquid_materials.remove(index); +#else + _liquid_materials.remove_at(index); +#endif +} + +int VoxelLibrary::liquid_material_get_num() const { + return _liquid_materials.size(); +} + +void VoxelLibrary::liquid_materials_clear() { + _liquid_materials.clear(); +} + +Vector VoxelLibrary::liquid_materials_get() { + VARIANT_ARRAY_GET(_liquid_materials); +} + +void VoxelLibrary::liquid_materials_set(const Vector &materials) { + _liquid_materials.clear(); + + for (int i = 0; i < materials.size(); i++) { + Ref material = Ref(materials[i]); + + _liquid_materials.push_back(material); + } +} + +//Prop Materials +Ref VoxelLibrary::prop_material_get(const int index) { + ERR_FAIL_INDEX_V(index, _prop_materials.size(), Ref(NULL)); + + return _prop_materials[index]; +} + +void VoxelLibrary::prop_material_add(const Ref &value) { + ERR_FAIL_COND(!value.is_valid()); + + _prop_materials.push_back(value); +} + +void VoxelLibrary::prop_material_set(const int index, const Ref &value) { + ERR_FAIL_INDEX(index, _prop_materials.size()); + + _prop_materials.set(index, value); +} + +void VoxelLibrary::prop_material_remove(const int index) { +#if VERSION_MAJOR <= 3 + _prop_materials.remove(index); +#else + _prop_materials.remove_at(index); +#endif +} + +int VoxelLibrary::prop_material_get_num() const { + return _prop_materials.size(); +} + +void VoxelLibrary::prop_materials_clear() { + _prop_materials.clear(); +} + +Vector VoxelLibrary::prop_materials_get() { + VARIANT_ARRAY_GET(_prop_materials); +} + +void VoxelLibrary::prop_materials_set(const Vector &materials) { + VARIANT_ARRAY_SET(materials, _prop_materials, Material); +} + +//Surfaces +Ref VoxelLibrary::voxel_surface_get(const int index) { + return Ref(); +} +void VoxelLibrary::voxel_surface_add(Ref value) { +} +void VoxelLibrary::voxel_surface_set(int index, Ref value) { +} +void VoxelLibrary::voxel_surface_remove(const int index) { +} +int VoxelLibrary::voxel_surface_get_num() const { + return 0; +} +void VoxelLibrary::voxel_surfaces_clear() { +} + +Ref VoxelLibrary::scene_get(const int id) { + return Ref(); +} +void VoxelLibrary::scene_add(Ref value) { +} +void VoxelLibrary::scene_set(int id, Ref value) { +} +void VoxelLibrary::scene_remove(const int id) { +} +int VoxelLibrary::scene_get_num() const { + return 0; +} +void VoxelLibrary::scenes_clear() { +} + +#ifdef PROPS_PRESENT +Ref VoxelLibrary::prop_get(const int id) { + return Ref(); +} +void VoxelLibrary::prop_add(Ref value) { +} +bool VoxelLibrary::prop_has(const Ref &value) const { + return false; +} +void VoxelLibrary::prop_set(int id, Ref value) { +} +void VoxelLibrary::prop_remove(const int id) { +} +int VoxelLibrary::prop_get_num() const { + return 0; +} +void VoxelLibrary::props_clear() { +} + +Rect2 VoxelLibrary::get_prop_uv_rect(const Ref &texture) { + return Rect2(0, 0, 1, 1); +} +#endif + +//Rects +void VoxelLibrary::refresh_rects() { + _initialized = true; +} + +void VoxelLibrary::setup_material_albedo(int material_index, Ref texture) { +#if VERSION_MAJOR < 4 + if (has_method("_setup_material_albedo")) { + call("_setup_material_albedo", material_index, texture); + } +#else + GDVIRTUAL_CALL(_setup_material_albedo, material_index, texture); +#endif +} + +VoxelLibrary::VoxelLibrary() { + _initialized = false; +} + +VoxelLibrary::~VoxelLibrary() { + _materials.clear(); + _liquid_materials.clear(); + _prop_materials.clear(); +} + +void VoxelLibrary::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_initialized"), &VoxelLibrary::get_initialized); + ClassDB::bind_method(D_METHOD("set_initialized", "value"), &VoxelLibrary::set_initialized); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "initialized", PROPERTY_HINT_NONE, "", 0), "set_initialized", "get_initialized"); + +#if VERSION_MAJOR < 4 + BIND_VMETHOD(MethodInfo("_setup_material_albedo", PropertyInfo(Variant::INT, "material_index"), PropertyInfo(Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"))); +#else + GDVIRTUAL_BIND(_setup_material_albedo, "material_index", "texture"); +#endif + + ClassDB::bind_method(D_METHOD("material_get", "index"), &VoxelLibrary::material_get); + ClassDB::bind_method(D_METHOD("material_add", "value"), &VoxelLibrary::material_add); + ClassDB::bind_method(D_METHOD("material_set", "index", "value"), &VoxelLibrary::material_set); + ClassDB::bind_method(D_METHOD("material_remove", "index"), &VoxelLibrary::material_remove); + ClassDB::bind_method(D_METHOD("material_get_num"), &VoxelLibrary::material_get_num); + ClassDB::bind_method(D_METHOD("materials_clear"), &VoxelLibrary::materials_clear); + + ClassDB::bind_method(D_METHOD("materials_get"), &VoxelLibrary::materials_get); + ClassDB::bind_method(D_METHOD("materials_set"), &VoxelLibrary::materials_set); + ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "materials", PROPERTY_HINT_NONE, "17/17:Material", PROPERTY_USAGE_DEFAULT, "Material"), "materials_set", "materials_get"); + + ClassDB::bind_method(D_METHOD("liquid_material_get", "index"), &VoxelLibrary::liquid_material_get); + ClassDB::bind_method(D_METHOD("liquid_material_add", "value"), &VoxelLibrary::liquid_material_add); + ClassDB::bind_method(D_METHOD("liquid_material_set", "index", "value"), &VoxelLibrary::liquid_material_set); + ClassDB::bind_method(D_METHOD("liquid_material_remove", "index"), &VoxelLibrary::liquid_material_remove); + ClassDB::bind_method(D_METHOD("liquid_material_get_num"), &VoxelLibrary::liquid_material_get_num); + ClassDB::bind_method(D_METHOD("liquid_materials_clear"), &VoxelLibrary::liquid_materials_clear); + + ClassDB::bind_method(D_METHOD("liquid_materials_get"), &VoxelLibrary::liquid_materials_get); + ClassDB::bind_method(D_METHOD("liquid_materials_set"), &VoxelLibrary::liquid_materials_set); + ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "liquid_materials", PROPERTY_HINT_NONE, "17/17:Material", PROPERTY_USAGE_DEFAULT, "Material"), "liquid_materials_set", "liquid_materials_get"); + + ClassDB::bind_method(D_METHOD("prop_material_get", "index"), &VoxelLibrary::prop_material_get); + ClassDB::bind_method(D_METHOD("prop_material_add", "value"), &VoxelLibrary::prop_material_add); + ClassDB::bind_method(D_METHOD("prop_material_set", "index", "value"), &VoxelLibrary::prop_material_set); + ClassDB::bind_method(D_METHOD("prop_material_remove", "index"), &VoxelLibrary::prop_material_remove); + ClassDB::bind_method(D_METHOD("prop_material_get_num"), &VoxelLibrary::prop_material_get_num); + ClassDB::bind_method(D_METHOD("prop_materials_clear"), &VoxelLibrary::prop_materials_clear); + + ClassDB::bind_method(D_METHOD("prop_materials_get"), &VoxelLibrary::prop_materials_get); + ClassDB::bind_method(D_METHOD("prop_materials_set"), &VoxelLibrary::prop_materials_set); + ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "prop_materials", PROPERTY_HINT_NONE, "17/17:Material", PROPERTY_USAGE_DEFAULT, "Material"), "prop_materials_set", "prop_materials_get"); + + ClassDB::bind_method(D_METHOD("voxel_surface_get", "index"), &VoxelLibrary::voxel_surface_get); + ClassDB::bind_method(D_METHOD("voxel_surface_add", "value"), &VoxelLibrary::voxel_surface_add); + ClassDB::bind_method(D_METHOD("voxel_surface_set", "index", "surface"), &VoxelLibrary::voxel_surface_set); + ClassDB::bind_method(D_METHOD("voxel_surface_remove", "index"), &VoxelLibrary::voxel_surface_remove); + ClassDB::bind_method(D_METHOD("voxel_surface_get_num"), &VoxelLibrary::voxel_surface_get_num); + ClassDB::bind_method(D_METHOD("voxel_surfaces_clear"), &VoxelLibrary::voxel_surfaces_clear); + + ClassDB::bind_method(D_METHOD("scene_get", "index"), &VoxelLibrary::scene_get); + ClassDB::bind_method(D_METHOD("scene_add", "value"), &VoxelLibrary::scene_add); + ClassDB::bind_method(D_METHOD("scene_set", "index", "value"), &VoxelLibrary::scene_set); + ClassDB::bind_method(D_METHOD("scene_remove", "index"), &VoxelLibrary::scene_remove); + ClassDB::bind_method(D_METHOD("scene_get_num"), &VoxelLibrary::scene_get_num); + ClassDB::bind_method(D_METHOD("scenes_clear"), &VoxelLibrary::scenes_clear); + +#ifdef PROPS_PRESENT + ClassDB::bind_method(D_METHOD("prop_get", "id"), &VoxelLibrary::prop_get); + ClassDB::bind_method(D_METHOD("prop_add", "value"), &VoxelLibrary::prop_add); + ClassDB::bind_method(D_METHOD("prop_has", "prop"), &VoxelLibrary::prop_has); + ClassDB::bind_method(D_METHOD("prop_set", "id", "surface"), &VoxelLibrary::prop_set); + ClassDB::bind_method(D_METHOD("prop_remove", "id"), &VoxelLibrary::prop_remove); + ClassDB::bind_method(D_METHOD("prop_get_num"), &VoxelLibrary::prop_get_num); + ClassDB::bind_method(D_METHOD("props_clear"), &VoxelLibrary::props_clear); +#endif + + ClassDB::bind_method(D_METHOD("refresh_rects"), &VoxelLibrary::refresh_rects); + + ClassDB::bind_method(D_METHOD("setup_material_albedo", "material_index", "texture"), &VoxelLibrary::setup_material_albedo); + + BIND_CONSTANT(MATERIAL_INDEX_VOXELS); + BIND_CONSTANT(MATERIAL_INDEX_LIQUID); + BIND_CONSTANT(MATERIAL_INDEX_PROP); +} diff --git a/library/voxelman_library.h b/library/voxel_library.h similarity index 96% rename from library/voxelman_library.h rename to library/voxel_library.h index 49cdf91..b2af09d 100644 --- a/library/voxelman_library.h +++ b/library/voxel_library.h @@ -20,8 +20,8 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#ifndef VOXELMAN_LIBRARY_H -#define VOXELMAN_LIBRARY_H +#ifndef VOXEL_LIBRARY_H +#define VOXEL_LIBRARY_H #include "core/version.h" @@ -50,8 +50,8 @@ class PackedScene; class PropData; #endif -class VoxelmanLibrary : public Resource { - GDCLASS(VoxelmanLibrary, Resource) +class VoxelLibrary : public Resource { + GDCLASS(VoxelLibrary, Resource) public: enum { @@ -129,8 +129,8 @@ public: GDVIRTUAL2(_setup_material_albedo, int, Ref); #endif - VoxelmanLibrary(); - ~VoxelmanLibrary(); + VoxelLibrary(); + ~VoxelLibrary(); protected: static void _bind_methods(); diff --git a/library/voxelman_library_merger.cpp b/library/voxel_library_merger.cpp similarity index 71% rename from library/voxelman_library_merger.cpp rename to library/voxel_library_merger.cpp index 7cfa18e..401fce4 100644 --- a/library/voxelman_library_merger.cpp +++ b/library/voxel_library_merger.cpp @@ -20,7 +20,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#include "voxelman_library_merger.h" +#include "voxel_library_merger.h" #include "scene/resources/packed_scene.h" #include "scene/resources/texture.h" @@ -37,63 +37,63 @@ SOFTWARE. #include "../defines.h" -int VoxelmanLibraryMerger::get_texture_flags() const { +int VoxelLibraryMerger::get_texture_flags() const { return _packer->get_texture_flags(); } -void VoxelmanLibraryMerger::set_texture_flags(const int flags) { +void VoxelLibraryMerger::set_texture_flags(const int flags) { _packer->set_texture_flags(flags); _prop_packer->set_texture_flags(flags); } -int VoxelmanLibraryMerger::get_max_atlas_size() const { +int VoxelLibraryMerger::get_max_atlas_size() const { return _packer->get_max_atlas_size(); } -void VoxelmanLibraryMerger::set_max_atlas_size(const int size) { +void VoxelLibraryMerger::set_max_atlas_size(const int size) { _packer->set_max_atlas_size(size); _prop_packer->set_max_atlas_size(size); } -bool VoxelmanLibraryMerger::get_keep_original_atlases() const { +bool VoxelLibraryMerger::get_keep_original_atlases() const { return _packer->get_keep_original_atlases(); } -void VoxelmanLibraryMerger::set_keep_original_atlases(const bool value) { +void VoxelLibraryMerger::set_keep_original_atlases(const bool value) { _packer->set_keep_original_atlases(value); _prop_packer->set_keep_original_atlases(value); } -Color VoxelmanLibraryMerger::get_background_color() const { +Color VoxelLibraryMerger::get_background_color() const { return _packer->get_background_color(); } -void VoxelmanLibraryMerger::set_background_color(const Color &color) { +void VoxelLibraryMerger::set_background_color(const Color &color) { _packer->set_background_color(color); _prop_packer->set_background_color(color); } -int VoxelmanLibraryMerger::get_margin() const { +int VoxelLibraryMerger::get_margin() const { return _packer->get_margin(); } -void VoxelmanLibraryMerger::set_margin(const int margin) { +void VoxelLibraryMerger::set_margin(const int margin) { _packer->set_margin(margin); _prop_packer->set_margin(margin); } //Surfaces -Ref VoxelmanLibraryMerger::voxel_surface_get(const int index) { +Ref VoxelLibraryMerger::voxel_surface_get(const int index) { ERR_FAIL_INDEX_V(index, _voxel_surfaces.size(), Ref(NULL)); return _voxel_surfaces[index]; } -void VoxelmanLibraryMerger::voxel_surface_add(Ref value) { +void VoxelLibraryMerger::voxel_surface_add(Ref value) { ERR_FAIL_COND(!value.is_valid()); - value->set_library(Ref(this)); + value->set_library(Ref(this)); value->set_id(_voxel_surfaces.size()); _voxel_surfaces.push_back(value); } -void VoxelmanLibraryMerger::voxel_surface_set(const int index, Ref value) { +void VoxelLibraryMerger::voxel_surface_set(const int index, Ref value) { ERR_FAIL_COND(index < 0); if (_voxel_surfaces.size() < index) { @@ -101,25 +101,25 @@ void VoxelmanLibraryMerger::voxel_surface_set(const int index, Ref } if (_voxel_surfaces[index].is_valid()) { - _voxel_surfaces.get(index)->set_library(Ref(NULL)); + _voxel_surfaces.get(index)->set_library(Ref(NULL)); } if (value.is_valid()) { - value->set_library(Ref(this)); + value->set_library(Ref(this)); _voxel_surfaces.set(index, value); } } -void VoxelmanLibraryMerger::voxel_surface_remove(const int index) { - _voxel_surfaces.remove(index); +void VoxelLibraryMerger::voxel_surface_remove(const int index) { + _voxel_surfaces.VREMOVE(index); } -int VoxelmanLibraryMerger::voxel_surface_get_num() const { +int VoxelLibraryMerger::voxel_surface_get_num() const { return _voxel_surfaces.size(); } -void VoxelmanLibraryMerger::voxel_surfaces_clear() { +void VoxelLibraryMerger::voxel_surfaces_clear() { _packer->clear(); for (int i = 0; i < _voxel_surfaces.size(); i++) { @@ -133,11 +133,11 @@ void VoxelmanLibraryMerger::voxel_surfaces_clear() { _voxel_surfaces.clear(); } -Vector VoxelmanLibraryMerger::get_voxel_surfaces() { +Vector VoxelLibraryMerger::get_voxel_surfaces() { VARIANT_ARRAY_GET(_voxel_surfaces); } -void VoxelmanLibraryMerger::set_voxel_surfaces(const Vector &surfaces) { +void VoxelLibraryMerger::set_voxel_surfaces(const Vector &surfaces) { _voxel_surfaces.clear(); for (int i = 0; i < surfaces.size(); i++) { @@ -152,43 +152,43 @@ void VoxelmanLibraryMerger::set_voxel_surfaces(const Vector &surfaces) } #ifdef PROPS_PRESENT -Ref VoxelmanLibraryMerger::get_prop(const int index) { +Ref VoxelLibraryMerger::get_prop(const int index) { ERR_FAIL_INDEX_V(index, _props.size(), Ref()); return _props[index]; } -void VoxelmanLibraryMerger::add_prop(Ref value) { +void VoxelLibraryMerger::add_prop(Ref value) { _props.push_back(value); } -bool VoxelmanLibraryMerger::has_prop(const Ref &value) const { +bool VoxelLibraryMerger::has_prop(const Ref &value) const { return _props.find(value) != -1; } -void VoxelmanLibraryMerger::set_prop(const int index, const Ref &value) { +void VoxelLibraryMerger::set_prop(const int index, const Ref &value) { ERR_FAIL_INDEX(index, _props.size()); _props.write[index] = value; } -void VoxelmanLibraryMerger::remove_prop(const int index) { +void VoxelLibraryMerger::remove_prop(const int index) { ERR_FAIL_INDEX(index, _props.size()); - _props.remove(index); + _props.VREMOVE(index); } -int VoxelmanLibraryMerger::get_num_props() const { +int VoxelLibraryMerger::get_num_props() const { return _props.size(); } -void VoxelmanLibraryMerger::clear_props() { +void VoxelLibraryMerger::clear_props() { _props.clear(); } -Vector VoxelmanLibraryMerger::get_props() { +Vector VoxelLibraryMerger::get_props() { VARIANT_ARRAY_GET(_props); } -void VoxelmanLibraryMerger::set_props(const Vector &props) { +void VoxelLibraryMerger::set_props(const Vector &props) { VARIANT_ARRAY_SET(props, _props, PropData); } -Rect2 VoxelmanLibraryMerger::get_prop_uv_rect(const Ref &texture) { +Rect2 VoxelLibraryMerger::get_prop_uv_rect(const Ref &texture) { if (!texture.is_valid()) { return Rect2(0, 0, 1, 1); } @@ -207,7 +207,11 @@ Rect2 VoxelmanLibraryMerger::get_prop_uv_rect(const Ref &texture) { return Rect2(0, 0, 1, 1); } +#if VERSION_MAJOR < 4 Ref image = tex->get_data(); +#else + Ref image = tex->get_image(); +#endif if (!image.is_valid()) { return Rect2(0, 0, 1, 1); @@ -222,12 +226,12 @@ Rect2 VoxelmanLibraryMerger::get_prop_uv_rect(const Ref &texture) { return region; } -Ref VoxelmanLibraryMerger::get_prop_packer() { +Ref VoxelLibraryMerger::get_prop_packer() { return _prop_packer; } #endif -void VoxelmanLibraryMerger::refresh_rects() { +void VoxelLibraryMerger::refresh_rects() { bool texture_added = false; for (int i = 0; i < _voxel_surfaces.size(); i++) { Ref surface = Ref(_voxel_surfaces[i]); @@ -295,7 +299,7 @@ void VoxelmanLibraryMerger::refresh_rects() { set_initialized(true); } -void VoxelmanLibraryMerger::_setup_material_albedo(const int material_index, const Ref &texture) { +void VoxelLibraryMerger::_setup_material_albedo(const int material_index, const Ref &texture) { Ref mat; int count = 0; @@ -313,7 +317,6 @@ void VoxelmanLibraryMerger::_setup_material_albedo(const int material_index, con } for (int i = 0; i < count; ++i) { - switch (material_index) { case MATERIAL_INDEX_VOXELS: mat = material_get(i); @@ -353,8 +356,8 @@ void VoxelmanLibraryMerger::_setup_material_albedo(const int material_index, con } } -VoxelmanLibraryMerger::VoxelmanLibraryMerger() { - _packer.instance(); +VoxelLibraryMerger::VoxelLibraryMerger() { + _packer.INSTANCE(); #if GODOT4 #warning implement @@ -366,7 +369,7 @@ VoxelmanLibraryMerger::VoxelmanLibraryMerger() { _packer->set_keep_original_atlases(false); _packer->set_margin(0); - _prop_packer.instance(); + _prop_packer.INSTANCE(); #if GODOT4 #warning implement @@ -379,12 +382,12 @@ VoxelmanLibraryMerger::VoxelmanLibraryMerger() { _prop_packer->set_margin(0); } -VoxelmanLibraryMerger::~VoxelmanLibraryMerger() { +VoxelLibraryMerger::~VoxelLibraryMerger() { for (int i = 0; i < _voxel_surfaces.size(); ++i) { Ref surface = _voxel_surfaces[i]; if (surface.is_valid()) { - surface->set_library(Ref()); + surface->set_library(Ref()); } } @@ -398,7 +401,7 @@ VoxelmanLibraryMerger::~VoxelmanLibraryMerger() { } #ifdef PROPS_PRESENT -bool VoxelmanLibraryMerger::process_prop_textures(Ref prop) { +bool VoxelLibraryMerger::process_prop_textures(Ref prop) { if (!prop.is_valid()) { return false; } @@ -432,40 +435,40 @@ bool VoxelmanLibraryMerger::process_prop_textures(Ref prop) { } #endif -void VoxelmanLibraryMerger::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_texture_flags"), &VoxelmanLibraryMerger::get_texture_flags); - ClassDB::bind_method(D_METHOD("set_texture_flags", "flags"), &VoxelmanLibraryMerger::set_texture_flags); +void VoxelLibraryMerger::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_texture_flags"), &VoxelLibraryMerger::get_texture_flags); + ClassDB::bind_method(D_METHOD("set_texture_flags", "flags"), &VoxelLibraryMerger::set_texture_flags); ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_flags", PROPERTY_HINT_FLAGS, "Mipmaps,Repeat,Filter,Anisotropic Linear,Convert to Linear,Mirrored Repeat,Video Surface"), "set_texture_flags", "get_texture_flags"); - ClassDB::bind_method(D_METHOD("get_max_atlas_size"), &VoxelmanLibraryMerger::get_max_atlas_size); - ClassDB::bind_method(D_METHOD("set_max_atlas_size", "size"), &VoxelmanLibraryMerger::set_max_atlas_size); + ClassDB::bind_method(D_METHOD("get_max_atlas_size"), &VoxelLibraryMerger::get_max_atlas_size); + ClassDB::bind_method(D_METHOD("set_max_atlas_size", "size"), &VoxelLibraryMerger::set_max_atlas_size); ADD_PROPERTY(PropertyInfo(Variant::INT, "max_atlas_size"), "set_max_atlas_size", "get_max_atlas_size"); - ClassDB::bind_method(D_METHOD("get_keep_original_atlases"), &VoxelmanLibraryMerger::get_keep_original_atlases); - ClassDB::bind_method(D_METHOD("set_keep_original_atlases", "value"), &VoxelmanLibraryMerger::set_keep_original_atlases); + ClassDB::bind_method(D_METHOD("get_keep_original_atlases"), &VoxelLibraryMerger::get_keep_original_atlases); + ClassDB::bind_method(D_METHOD("set_keep_original_atlases", "value"), &VoxelLibraryMerger::set_keep_original_atlases); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "keep_original_atlases"), "set_keep_original_atlases", "get_keep_original_atlases"); - ClassDB::bind_method(D_METHOD("get_background_color"), &VoxelmanLibraryMerger::get_background_color); - ClassDB::bind_method(D_METHOD("set_background_color", "color"), &VoxelmanLibraryMerger::set_background_color); + ClassDB::bind_method(D_METHOD("get_background_color"), &VoxelLibraryMerger::get_background_color); + ClassDB::bind_method(D_METHOD("set_background_color", "color"), &VoxelLibraryMerger::set_background_color); ADD_PROPERTY(PropertyInfo(Variant::COLOR, "background_color"), "set_background_color", "get_background_color"); - ClassDB::bind_method(D_METHOD("get_margin"), &VoxelmanLibraryMerger::get_margin); - ClassDB::bind_method(D_METHOD("set_margin", "size"), &VoxelmanLibraryMerger::set_margin); + ClassDB::bind_method(D_METHOD("get_margin"), &VoxelLibraryMerger::get_margin); + ClassDB::bind_method(D_METHOD("set_margin", "size"), &VoxelLibraryMerger::set_margin); ADD_PROPERTY(PropertyInfo(Variant::INT, "margin"), "set_margin", "get_margin"); - ClassDB::bind_method(D_METHOD("get_voxel_surfaces"), &VoxelmanLibraryMerger::get_voxel_surfaces); - ClassDB::bind_method(D_METHOD("set_voxel_surfaces"), &VoxelmanLibraryMerger::set_voxel_surfaces); + ClassDB::bind_method(D_METHOD("get_voxel_surfaces"), &VoxelLibraryMerger::get_voxel_surfaces); + ClassDB::bind_method(D_METHOD("set_voxel_surfaces"), &VoxelLibraryMerger::set_voxel_surfaces); ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "voxel_surfaces", PROPERTY_HINT_NONE, "17/17:VoxelSurfaceMerger", PROPERTY_USAGE_DEFAULT, "VoxelSurfaceMerger"), "set_voxel_surfaces", "get_voxel_surfaces"); #ifdef PROPS_PRESENT - ClassDB::bind_method(D_METHOD("get_props"), &VoxelmanLibraryMerger::get_props); - ClassDB::bind_method(D_METHOD("set_props"), &VoxelmanLibraryMerger::set_props); + ClassDB::bind_method(D_METHOD("get_props"), &VoxelLibraryMerger::get_props); + ClassDB::bind_method(D_METHOD("set_props"), &VoxelLibraryMerger::set_props); ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "props", PROPERTY_HINT_NONE, "17/17:PropData", PROPERTY_USAGE_DEFAULT, "PropData"), "set_props", "get_props"); - ClassDB::bind_method(D_METHOD("get_prop_uv_rect", "texture"), &VoxelmanLibraryMerger::get_prop_uv_rect); + ClassDB::bind_method(D_METHOD("get_prop_uv_rect", "texture"), &VoxelLibraryMerger::get_prop_uv_rect); - ClassDB::bind_method(D_METHOD("get_prop_packer"), &VoxelmanLibraryMerger::get_prop_packer); + ClassDB::bind_method(D_METHOD("get_prop_packer"), &VoxelLibraryMerger::get_prop_packer); #endif - ClassDB::bind_method(D_METHOD("_setup_material_albedo", "material_index", "texture"), &VoxelmanLibraryMerger::_setup_material_albedo); + ClassDB::bind_method(D_METHOD("_setup_material_albedo", "material_index", "texture"), &VoxelLibraryMerger::_setup_material_albedo); } diff --git a/library/voxelman_library_merger.h b/library/voxel_library_merger.h similarity index 92% rename from library/voxelman_library_merger.h rename to library/voxel_library_merger.h index ca5f3c4..c668ec6 100644 --- a/library/voxelman_library_merger.h +++ b/library/voxel_library_merger.h @@ -20,8 +20,8 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#ifndef VOXELMAN_LIBRARY_MERGER_H -#define VOXELMAN_LIBRARY_MERGER_H +#ifndef VOXEL_LIBRARY_MERGER_H +#define VOXEL_LIBRARY_MERGER_H #include "core/version.h" @@ -33,7 +33,7 @@ SOFTWARE. #include "core/map.h" #endif -#include "voxelman_library.h" +#include "voxel_library.h" #include "scene/resources/material.h" @@ -44,8 +44,8 @@ class VoxelSurfaceSimple; class VoxelMesher; class PackedScene; -class VoxelmanLibraryMerger : public VoxelmanLibrary { - GDCLASS(VoxelmanLibraryMerger, VoxelmanLibrary) +class VoxelLibraryMerger : public VoxelLibrary { + GDCLASS(VoxelLibraryMerger, VoxelLibrary) public: int get_texture_flags() const; @@ -94,8 +94,8 @@ public: void _setup_material_albedo(const int material_index, const Ref &texture); - VoxelmanLibraryMerger(); - ~VoxelmanLibraryMerger(); + VoxelLibraryMerger(); + ~VoxelLibraryMerger(); protected: #ifdef PROPS_PRESENT diff --git a/library/voxelman_library_simple.cpp b/library/voxel_library_simple.cpp similarity index 64% rename from library/voxelman_library_simple.cpp rename to library/voxel_library_simple.cpp index 633709f..20f2666 100644 --- a/library/voxelman_library_simple.cpp +++ b/library/voxel_library_simple.cpp @@ -20,45 +20,45 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#include "voxelman_library_simple.h" +#include "voxel_library_simple.h" #include "../defines.h" -int VoxelmanLibrarySimple::get_atlas_columns() const { +int VoxelLibrarySimple::get_atlas_columns() const { return _atlas_columns; } -void VoxelmanLibrarySimple::set_atlas_columns(int s) { +void VoxelLibrarySimple::set_atlas_columns(int s) { ERR_FAIL_COND(s < 0); _atlas_columns = s; } -int VoxelmanLibrarySimple::get_atlas_rows() const { +int VoxelLibrarySimple::get_atlas_rows() const { return _atlas_rows; } -void VoxelmanLibrarySimple::set_atlas_rows(int s) { +void VoxelLibrarySimple::set_atlas_rows(int s) { ERR_FAIL_COND(s < 0); _atlas_rows = s; } //Surfaces -Ref VoxelmanLibrarySimple::voxel_surface_get(const int index) { +Ref VoxelLibrarySimple::voxel_surface_get(const int index) { ERR_FAIL_INDEX_V(index, _voxel_surfaces.size(), Ref(NULL)); return _voxel_surfaces[index]; } -void VoxelmanLibrarySimple::voxel_surface_add(Ref value) { +void VoxelLibrarySimple::voxel_surface_add(Ref value) { ERR_FAIL_COND(!value.is_valid()); - value->set_library(Ref(this)); + value->set_library(Ref(this)); value->set_id(_voxel_surfaces.size()); _voxel_surfaces.push_back(value); } -void VoxelmanLibrarySimple::voxel_surface_set(const int index, Ref value) { +void VoxelLibrarySimple::voxel_surface_set(const int index, Ref value) { ERR_FAIL_COND(index < 0); if (_voxel_surfaces.size() < index) { @@ -66,17 +66,17 @@ void VoxelmanLibrarySimple::voxel_surface_set(const int index, Ref } if (_voxel_surfaces[index].is_valid()) { - _voxel_surfaces.get(index)->set_library(Ref(NULL)); + _voxel_surfaces.get(index)->set_library(Ref(NULL)); } if (value.is_valid()) { - value->set_library(Ref(this)); + value->set_library(Ref(this)); _voxel_surfaces.set(index, value); } } -void VoxelmanLibrarySimple::voxel_surface_remove(const int index) { +void VoxelLibrarySimple::voxel_surface_remove(const int index) { #if VERSION_MAJOR <= 3 _voxel_surfaces.remove(index); #else @@ -84,19 +84,19 @@ void VoxelmanLibrarySimple::voxel_surface_remove(const int index) { #endif } -int VoxelmanLibrarySimple::voxel_surface_get_num() const { +int VoxelLibrarySimple::voxel_surface_get_num() const { return _voxel_surfaces.size(); } -void VoxelmanLibrarySimple::voxel_surfaces_clear() { +void VoxelLibrarySimple::voxel_surfaces_clear() { _voxel_surfaces.clear(); } -Vector VoxelmanLibrarySimple::get_voxel_surfaces() { +Vector VoxelLibrarySimple::get_voxel_surfaces() { VARIANT_ARRAY_GET(_voxel_surfaces); } -void VoxelmanLibrarySimple::set_voxel_surfaces(const Vector &surfaces) { +void VoxelLibrarySimple::set_voxel_surfaces(const Vector &surfaces) { _voxel_surfaces.clear(); for (int i = 0; i < surfaces.size(); i++) { @@ -113,7 +113,7 @@ void VoxelmanLibrarySimple::set_voxel_surfaces(const Vector &surfaces) set_initialized(true); } -void VoxelmanLibrarySimple::refresh_rects() { +void VoxelLibrarySimple::refresh_rects() { for (int i = 0; i < _voxel_surfaces.size(); i++) { Ref surface = Ref(_voxel_surfaces[i]); @@ -123,33 +123,33 @@ void VoxelmanLibrarySimple::refresh_rects() { } } -VoxelmanLibrarySimple::VoxelmanLibrarySimple() { +VoxelLibrarySimple::VoxelLibrarySimple() { _atlas_rows = 8; _atlas_columns = 8; } -VoxelmanLibrarySimple::~VoxelmanLibrarySimple() { +VoxelLibrarySimple::~VoxelLibrarySimple() { for (int i = 0; i < _voxel_surfaces.size(); ++i) { Ref surface = _voxel_surfaces[i]; if (surface.is_valid()) { - surface->set_library(Ref()); + surface->set_library(Ref()); } } _voxel_surfaces.clear(); } -void VoxelmanLibrarySimple::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_atlas_columns"), &VoxelmanLibrarySimple::get_atlas_columns); - ClassDB::bind_method(D_METHOD("set_atlas_columns", "value"), &VoxelmanLibrarySimple::set_atlas_columns); +void VoxelLibrarySimple::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_atlas_columns"), &VoxelLibrarySimple::get_atlas_columns); + ClassDB::bind_method(D_METHOD("set_atlas_columns", "value"), &VoxelLibrarySimple::set_atlas_columns); ADD_PROPERTY(PropertyInfo(Variant::INT, "atlas_columns"), "set_atlas_columns", "get_atlas_columns"); - ClassDB::bind_method(D_METHOD("get_atlas_rows"), &VoxelmanLibrarySimple::get_atlas_rows); - ClassDB::bind_method(D_METHOD("set_atlas_rows", "value"), &VoxelmanLibrarySimple::set_atlas_rows); + ClassDB::bind_method(D_METHOD("get_atlas_rows"), &VoxelLibrarySimple::get_atlas_rows); + ClassDB::bind_method(D_METHOD("set_atlas_rows", "value"), &VoxelLibrarySimple::set_atlas_rows); ADD_PROPERTY(PropertyInfo(Variant::INT, "atlas_rows"), "set_atlas_rows", "get_atlas_rows"); - ClassDB::bind_method(D_METHOD("get_voxel_surfaces"), &VoxelmanLibrarySimple::get_voxel_surfaces); - ClassDB::bind_method(D_METHOD("set_voxel_surfaces"), &VoxelmanLibrarySimple::set_voxel_surfaces); + ClassDB::bind_method(D_METHOD("get_voxel_surfaces"), &VoxelLibrarySimple::get_voxel_surfaces); + ClassDB::bind_method(D_METHOD("set_voxel_surfaces"), &VoxelLibrarySimple::set_voxel_surfaces); ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "voxel_surfaces", PROPERTY_HINT_NONE, "17/17:VoxelSurfaceSimple", PROPERTY_USAGE_DEFAULT, "VoxelSurfaceSimple"), "set_voxel_surfaces", "get_voxel_surfaces"); } diff --git a/library/voxelman_library_simple.h b/library/voxel_library_simple.h similarity index 89% rename from library/voxelman_library_simple.h rename to library/voxel_library_simple.h index f161b86..164215d 100644 --- a/library/voxelman_library_simple.h +++ b/library/voxel_library_simple.h @@ -20,8 +20,8 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#ifndef VOXELMAN_LIBRARY_SIMPLE_H -#define VOXELMAN_LIBRARY_SIMPLE_H +#ifndef VOXEL_LIBRARY_SIMPLE_H +#define VOXEL_LIBRARY_SIMPLE_H #include "core/version.h" @@ -34,7 +34,7 @@ SOFTWARE. #include "core/resource.h" #endif -#include "voxelman_library.h" +#include "voxel_library.h" #include "scene/resources/material.h" @@ -44,8 +44,8 @@ SOFTWARE. class VoxelSurfaceSimple; class VoxelMesher; -class VoxelmanLibrarySimple : public VoxelmanLibrary { - GDCLASS(VoxelmanLibrarySimple, VoxelmanLibrary) +class VoxelLibrarySimple : public VoxelLibrary { + GDCLASS(VoxelLibrarySimple, VoxelLibrary) public: int get_atlas_columns() const; @@ -66,8 +66,8 @@ public: void refresh_rects(); - VoxelmanLibrarySimple(); - ~VoxelmanLibrarySimple(); + VoxelLibrarySimple(); + ~VoxelLibrarySimple(); protected: static void _bind_methods(); diff --git a/library/voxel_surface.cpp b/library/voxel_surface.cpp index 520f528..3181dc4 100644 --- a/library/voxel_surface.cpp +++ b/library/voxel_surface.cpp @@ -57,11 +57,11 @@ void VoxelSurface::set_rect(const VoxelSurfaceSides side, const Rect2 &rect) { _rects[side] = rect; } -Ref VoxelSurface::get_library() const { - return Ref(_library); +Ref VoxelSurface::get_library() const { + return Ref(_library); } -void VoxelSurface::set_library(Ref library) { +void VoxelSurface::set_library(Ref library) { _library = (*library); } diff --git a/library/voxel_surface.h b/library/voxel_surface.h index fdeb635..324d28e 100644 --- a/library/voxel_surface.h +++ b/library/voxel_surface.h @@ -39,9 +39,9 @@ SOFTWARE. #include "core/math/rect2.h" #include "scene/resources/material.h" -#include "voxelman_library.h" +#include "voxel_library.h" -class VoxelmanLibrary; +class VoxelLibrary; class VoxelSurface : public Resource { GDCLASS(VoxelSurface, Resource) @@ -88,8 +88,8 @@ public: Rect2 get_rect(const VoxelSurfaceSides side) const; void set_rect(const VoxelSurfaceSides side, const Rect2 &rect); - Ref get_library() const; - void set_library(Ref library); + Ref get_library() const; + void set_library(Ref library); Vector2 transform_uv(const VoxelSurfaceSides p_side, const Vector2 &p_uv) const; Vector2 transform_uv_scaled(const VoxelSurfaceSides p_side, const Vector2 &p_uv, const int p_current_x, const int p_current_y, const int p_max) const; @@ -102,7 +102,7 @@ public: protected: static void _bind_methods(); - VoxelmanLibrary *_library; + VoxelLibrary *_library; int _id; int _mesher_index; diff --git a/library/voxel_surface_merger.cpp b/library/voxel_surface_merger.cpp index 048c786..e6d1ed6 100644 --- a/library/voxel_surface_merger.cpp +++ b/library/voxel_surface_merger.cpp @@ -22,7 +22,7 @@ SOFTWARE. #include "voxel_surface_merger.h" -#include "voxelman_library_merger.h" +#include "voxel_library_merger.h" #include "../defines.h" @@ -45,7 +45,7 @@ void VoxelSurfaceMerger::set_texture(const VoxelSurfaceSides side, const Ref(_library); + VoxelLibraryMerger *lib = Object::cast_to(_library); ERR_FAIL_COND(lib == NULL); diff --git a/library/voxel_surface_simple.cpp b/library/voxel_surface_simple.cpp index aeb9a5a..31280ef 100644 --- a/library/voxel_surface_simple.cpp +++ b/library/voxel_surface_simple.cpp @@ -22,7 +22,7 @@ SOFTWARE. #include "voxel_surface_simple.h" -#include "voxelman_library_simple.h" +#include "voxel_library_simple.h" int VoxelSurfaceSimple::get_atlas_x(const VoxelSurfaceSides side) const { int indx = (side * 2); @@ -47,7 +47,7 @@ void VoxelSurfaceSimple::set_atlas_y(const VoxelSurfaceSides side, int value) { } void VoxelSurfaceSimple::refresh_rects() { - VoxelmanLibrarySimple *lib = Object::cast_to(_library); + VoxelLibrarySimple *lib = Object::cast_to(_library); ERR_FAIL_COND(lib == NULL); diff --git a/library/voxelman_library.cpp b/library/voxelman_library.cpp deleted file mode 100644 index ef9b8d4..0000000 --- a/library/voxelman_library.cpp +++ /dev/null @@ -1,336 +0,0 @@ -/* -Copyright (c) 2019-2020 Péter Magyar - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -*/ - -#include "voxelman_library.h" - -#ifdef PROPS_PRESENT -#include "../../props/props/prop_data.h" -#endif - -#include "scene/resources/packed_scene.h" - -#include "../defines.h" - -bool VoxelmanLibrary::get_initialized() const { - return _initialized; -} -void VoxelmanLibrary::set_initialized(const bool value) { - _initialized = value; -} - -//Materials -Ref VoxelmanLibrary::material_get(const int index) { - ERR_FAIL_INDEX_V(index, _materials.size(), Ref(NULL)); - - return _materials[index]; -} - -void VoxelmanLibrary::material_add(const Ref &value) { - ERR_FAIL_COND(!value.is_valid()); - - _materials.push_back(value); -} - -void VoxelmanLibrary::material_set(const int index, const Ref &value) { - ERR_FAIL_INDEX(index, _materials.size()); - - _materials.set(index, value); -} - -void VoxelmanLibrary::material_remove(const int index) { -#if VERSION_MAJOR <= 3 - _materials.remove(index); -#else - _materials.remove_at(index); -#endif -} - -int VoxelmanLibrary::material_get_num() const { - return _materials.size(); -} - -void VoxelmanLibrary::materials_clear() { - _materials.clear(); -} - -Vector VoxelmanLibrary::materials_get() { - VARIANT_ARRAY_GET(_materials); -} - -void VoxelmanLibrary::materials_set(const Vector &materials) { - _materials.clear(); - - for (int i = 0; i < materials.size(); i++) { - Ref material = Ref(materials[i]); - - _materials.push_back(material); - } -} - -//Liquid Materials -Ref VoxelmanLibrary::liquid_material_get(const int index) { - ERR_FAIL_INDEX_V(index, _liquid_materials.size(), Ref(NULL)); - - return _liquid_materials[index]; -} - -void VoxelmanLibrary::liquid_material_add(const Ref &value) { - ERR_FAIL_COND(!value.is_valid()); - - _liquid_materials.push_back(value); -} - -void VoxelmanLibrary::liquid_material_set(const int index, const Ref &value) { - ERR_FAIL_INDEX(index, _liquid_materials.size()); - - _liquid_materials.set(index, value); -} - -void VoxelmanLibrary::liquid_material_remove(const int index) { -#if VERSION_MAJOR <= 3 - _liquid_materials.remove(index); -#else - _liquid_materials.remove_at(index); -#endif -} - -int VoxelmanLibrary::liquid_material_get_num() const { - return _liquid_materials.size(); -} - -void VoxelmanLibrary::liquid_materials_clear() { - _liquid_materials.clear(); -} - -Vector VoxelmanLibrary::liquid_materials_get() { - VARIANT_ARRAY_GET(_liquid_materials); -} - -void VoxelmanLibrary::liquid_materials_set(const Vector &materials) { - _liquid_materials.clear(); - - for (int i = 0; i < materials.size(); i++) { - Ref material = Ref(materials[i]); - - _liquid_materials.push_back(material); - } -} - -//Prop Materials -Ref VoxelmanLibrary::prop_material_get(const int index) { - ERR_FAIL_INDEX_V(index, _prop_materials.size(), Ref(NULL)); - - return _prop_materials[index]; -} - -void VoxelmanLibrary::prop_material_add(const Ref &value) { - ERR_FAIL_COND(!value.is_valid()); - - _prop_materials.push_back(value); -} - -void VoxelmanLibrary::prop_material_set(const int index, const Ref &value) { - ERR_FAIL_INDEX(index, _prop_materials.size()); - - _prop_materials.set(index, value); -} - -void VoxelmanLibrary::prop_material_remove(const int index) { -#if VERSION_MAJOR <= 3 - _prop_materials.remove(index); -#else - _prop_materials.remove_at(index); -#endif -} - -int VoxelmanLibrary::prop_material_get_num() const { - return _prop_materials.size(); -} - -void VoxelmanLibrary::prop_materials_clear() { - _prop_materials.clear(); -} - -Vector VoxelmanLibrary::prop_materials_get() { - VARIANT_ARRAY_GET(_prop_materials); -} - -void VoxelmanLibrary::prop_materials_set(const Vector &materials) { - VARIANT_ARRAY_SET(materials, _prop_materials, Material); -} - -//Surfaces -Ref VoxelmanLibrary::voxel_surface_get(const int index) { - return Ref(); -} -void VoxelmanLibrary::voxel_surface_add(Ref value) { -} -void VoxelmanLibrary::voxel_surface_set(int index, Ref value) { -} -void VoxelmanLibrary::voxel_surface_remove(const int index) { -} -int VoxelmanLibrary::voxel_surface_get_num() const { - return 0; -} -void VoxelmanLibrary::voxel_surfaces_clear() { -} - -Ref VoxelmanLibrary::scene_get(const int id) { - return Ref(); -} -void VoxelmanLibrary::scene_add(Ref value) { -} -void VoxelmanLibrary::scene_set(int id, Ref value) { -} -void VoxelmanLibrary::scene_remove(const int id) { -} -int VoxelmanLibrary::scene_get_num() const { - return 0; -} -void VoxelmanLibrary::scenes_clear() { -} - -#ifdef PROPS_PRESENT -Ref VoxelmanLibrary::prop_get(const int id) { - return Ref(); -} -void VoxelmanLibrary::prop_add(Ref value) { -} -bool VoxelmanLibrary::prop_has(const Ref &value) const { - return false; -} -void VoxelmanLibrary::prop_set(int id, Ref value) { -} -void VoxelmanLibrary::prop_remove(const int id) { -} -int VoxelmanLibrary::prop_get_num() const { - return 0; -} -void VoxelmanLibrary::props_clear() { -} - -Rect2 VoxelmanLibrary::get_prop_uv_rect(const Ref &texture) { - return Rect2(0, 0, 1, 1); -} -#endif - -//Rects -void VoxelmanLibrary::refresh_rects() { - _initialized = true; -} - -void VoxelmanLibrary::setup_material_albedo(int material_index, Ref texture) { - if (has_method("_setup_material_albedo")) { -#if VERSION_MAJOR < 4 - call("_setup_material_albedo", material_index, texture); -#else - GDVIRTUAL_CALL(_setup_material_albedo, material_index, texture); -#endif - } -} - -VoxelmanLibrary::VoxelmanLibrary() { - _initialized = false; -} - -VoxelmanLibrary::~VoxelmanLibrary() { - _materials.clear(); - _liquid_materials.clear(); - _prop_materials.clear(); -} - -void VoxelmanLibrary::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_initialized"), &VoxelmanLibrary::get_initialized); - ClassDB::bind_method(D_METHOD("set_initialized", "value"), &VoxelmanLibrary::set_initialized); - ADD_PROPERTY(PropertyInfo(Variant::BOOL, "initialized", PROPERTY_HINT_NONE, "", 0), "set_initialized", "get_initialized"); - -#if VERSION_MAJOR < 4 - BIND_VMETHOD(MethodInfo("_setup_material_albedo", PropertyInfo(Variant::INT, "material_index"), PropertyInfo(Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"))); -#else - GDVIRTUAL_BIND(_setup_material_albedo, "material_index", "texture"); -#endif - - ClassDB::bind_method(D_METHOD("material_get", "index"), &VoxelmanLibrary::material_get); - ClassDB::bind_method(D_METHOD("material_add", "value"), &VoxelmanLibrary::material_add); - ClassDB::bind_method(D_METHOD("material_set", "index", "value"), &VoxelmanLibrary::material_set); - ClassDB::bind_method(D_METHOD("material_remove", "index"), &VoxelmanLibrary::material_remove); - ClassDB::bind_method(D_METHOD("material_get_num"), &VoxelmanLibrary::material_get_num); - ClassDB::bind_method(D_METHOD("materials_clear"), &VoxelmanLibrary::materials_clear); - - ClassDB::bind_method(D_METHOD("materials_get"), &VoxelmanLibrary::materials_get); - ClassDB::bind_method(D_METHOD("materials_set"), &VoxelmanLibrary::materials_set); - ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "materials", PROPERTY_HINT_NONE, "17/17:Material", PROPERTY_USAGE_DEFAULT, "Material"), "materials_set", "materials_get"); - - ClassDB::bind_method(D_METHOD("liquid_material_get", "index"), &VoxelmanLibrary::liquid_material_get); - ClassDB::bind_method(D_METHOD("liquid_material_add", "value"), &VoxelmanLibrary::liquid_material_add); - ClassDB::bind_method(D_METHOD("liquid_material_set", "index", "value"), &VoxelmanLibrary::liquid_material_set); - ClassDB::bind_method(D_METHOD("liquid_material_remove", "index"), &VoxelmanLibrary::liquid_material_remove); - ClassDB::bind_method(D_METHOD("liquid_material_get_num"), &VoxelmanLibrary::liquid_material_get_num); - ClassDB::bind_method(D_METHOD("liquid_materials_clear"), &VoxelmanLibrary::liquid_materials_clear); - - ClassDB::bind_method(D_METHOD("liquid_materials_get"), &VoxelmanLibrary::liquid_materials_get); - ClassDB::bind_method(D_METHOD("liquid_materials_set"), &VoxelmanLibrary::liquid_materials_set); - ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "liquid_materials", PROPERTY_HINT_NONE, "17/17:Material", PROPERTY_USAGE_DEFAULT, "Material"), "liquid_materials_set", "liquid_materials_get"); - - ClassDB::bind_method(D_METHOD("prop_material_get", "index"), &VoxelmanLibrary::prop_material_get); - ClassDB::bind_method(D_METHOD("prop_material_add", "value"), &VoxelmanLibrary::prop_material_add); - ClassDB::bind_method(D_METHOD("prop_material_set", "index", "value"), &VoxelmanLibrary::prop_material_set); - ClassDB::bind_method(D_METHOD("prop_material_remove", "index"), &VoxelmanLibrary::prop_material_remove); - ClassDB::bind_method(D_METHOD("prop_material_get_num"), &VoxelmanLibrary::prop_material_get_num); - ClassDB::bind_method(D_METHOD("prop_materials_clear"), &VoxelmanLibrary::prop_materials_clear); - - ClassDB::bind_method(D_METHOD("prop_materials_get"), &VoxelmanLibrary::prop_materials_get); - ClassDB::bind_method(D_METHOD("prop_materials_set"), &VoxelmanLibrary::prop_materials_set); - ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "prop_materials", PROPERTY_HINT_NONE, "17/17:Material", PROPERTY_USAGE_DEFAULT, "Material"), "prop_materials_set", "prop_materials_get"); - - ClassDB::bind_method(D_METHOD("voxel_surface_get", "index"), &VoxelmanLibrary::voxel_surface_get); - ClassDB::bind_method(D_METHOD("voxel_surface_add", "value"), &VoxelmanLibrary::voxel_surface_add); - ClassDB::bind_method(D_METHOD("voxel_surface_set", "index", "surface"), &VoxelmanLibrary::voxel_surface_set); - ClassDB::bind_method(D_METHOD("voxel_surface_remove", "index"), &VoxelmanLibrary::voxel_surface_remove); - ClassDB::bind_method(D_METHOD("voxel_surface_get_num"), &VoxelmanLibrary::voxel_surface_get_num); - ClassDB::bind_method(D_METHOD("voxel_surfaces_clear"), &VoxelmanLibrary::voxel_surfaces_clear); - - ClassDB::bind_method(D_METHOD("scene_get", "index"), &VoxelmanLibrary::scene_get); - ClassDB::bind_method(D_METHOD("scene_add", "value"), &VoxelmanLibrary::scene_add); - ClassDB::bind_method(D_METHOD("scene_set", "index", "value"), &VoxelmanLibrary::scene_set); - ClassDB::bind_method(D_METHOD("scene_remove", "index"), &VoxelmanLibrary::scene_remove); - ClassDB::bind_method(D_METHOD("scene_get_num"), &VoxelmanLibrary::scene_get_num); - ClassDB::bind_method(D_METHOD("scenes_clear"), &VoxelmanLibrary::scenes_clear); - -#ifdef PROPS_PRESENT - ClassDB::bind_method(D_METHOD("prop_get", "id"), &VoxelmanLibrary::prop_get); - ClassDB::bind_method(D_METHOD("prop_add", "value"), &VoxelmanLibrary::prop_add); - ClassDB::bind_method(D_METHOD("prop_has", "prop"), &VoxelmanLibrary::prop_has); - ClassDB::bind_method(D_METHOD("prop_set", "id", "surface"), &VoxelmanLibrary::prop_set); - ClassDB::bind_method(D_METHOD("prop_remove", "id"), &VoxelmanLibrary::prop_remove); - ClassDB::bind_method(D_METHOD("prop_get_num"), &VoxelmanLibrary::prop_get_num); - ClassDB::bind_method(D_METHOD("props_clear"), &VoxelmanLibrary::props_clear); -#endif - - ClassDB::bind_method(D_METHOD("refresh_rects"), &VoxelmanLibrary::refresh_rects); - - ClassDB::bind_method(D_METHOD("setup_material_albedo", "material_index", "texture"), &VoxelmanLibrary::setup_material_albedo); - - BIND_CONSTANT(MATERIAL_INDEX_VOXELS); - BIND_CONSTANT(MATERIAL_INDEX_LIQUID); - BIND_CONSTANT(MATERIAL_INDEX_PROP); -} diff --git a/meshers/cubic/voxel_mesher_cubic.cpp b/meshers/cubic/voxel_mesher_cubic.cpp index 09fe058..92d9436 100644 --- a/meshers/cubic/voxel_mesher_cubic.cpp +++ b/meshers/cubic/voxel_mesher_cubic.cpp @@ -49,7 +49,7 @@ void VoxelMesherCubic::_add_chunk(Ref p_chunk) { float voxel_scale = get_voxel_scale(); Ref cube_points; - cube_points.instance(); + cube_points.INSTANCE(); cube_points->set_channel_index_type(_channel_index_type); cube_points->set_channel_index_isolevel(_channel_index_isolevel); diff --git a/meshers/voxel_mesher.cpp b/meshers/voxel_mesher.cpp index 8c3678a..78c2a03 100644 --- a/meshers/voxel_mesher.cpp +++ b/meshers/voxel_mesher.cpp @@ -112,10 +112,10 @@ void VoxelMesher::set_texture_scale(const int value) { _texture_scale = value; } -Ref VoxelMesher::get_library() { +Ref VoxelMesher::get_library() { return _library; } -void VoxelMesher::set_library(const Ref &library) { +void VoxelMesher::set_library(const Ref &library) { _library = library; } @@ -905,7 +905,7 @@ void VoxelMesher::remove_index(const int idx) { #endif } -VoxelMesher::VoxelMesher(const Ref &library) { +VoxelMesher::VoxelMesher(const Ref &library) { _library = library; _mesher_index = 0; @@ -971,7 +971,7 @@ void VoxelMesher::_bind_methods() { ClassDB::bind_method(D_METHOD("get_library"), &VoxelMesher::get_library); ClassDB::bind_method(D_METHOD("set_library", "value"), &VoxelMesher::set_library); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "library", PROPERTY_HINT_RESOURCE_TYPE, "VoxelmanLibrary"), "set_library", "get_library"); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "library", PROPERTY_HINT_RESOURCE_TYPE, "VoxelLibrary"), "set_library", "get_library"); ClassDB::bind_method(D_METHOD("get_material"), &VoxelMesher::get_material); ClassDB::bind_method(D_METHOD("set_material", "value"), &VoxelMesher::set_material); diff --git a/meshers/voxel_mesher.h b/meshers/voxel_mesher.h index 4403e0d..4bd3b39 100644 --- a/meshers/voxel_mesher.h +++ b/meshers/voxel_mesher.h @@ -56,12 +56,12 @@ include_pool_vector #include "../../mesh_data_resource/mesh_data_resource.h" #endif -#include "../library/voxelman_library.h" +#include "../library/voxel_library.h" const double PI_2 = 3.141592653589793238463 / 2; const double PI = 3.141592653589793238463; -class VoxelmanLibrary; +class VoxelLibrary; class VoxelChunk; class VoxelMesher : public Reference { @@ -113,8 +113,8 @@ public: int get_texture_scale() const; void set_texture_scale(const int value); - Ref get_library(); - void set_library(const Ref &library); + Ref get_library(); + void set_library(const Ref &library); Ref get_material(); void set_material(const Ref &material); @@ -199,7 +199,7 @@ public: GDVIRTUAL1(_add_mesher, Ref); #endif - VoxelMesher(const Ref &library); + VoxelMesher(const Ref &library); VoxelMesher(); ~VoxelMesher(); @@ -226,7 +226,7 @@ protected: Vector _last_weights; Plane _last_tangent; - Ref _library; + Ref _library; Ref _material; float _voxel_scale; diff --git a/nodes/voxel_light_node.cpp b/nodes/voxel_light_node.cpp new file mode 100644 index 0000000..9549c0e --- /dev/null +++ b/nodes/voxel_light_node.cpp @@ -0,0 +1,9 @@ +#include "voxel_light_node.h" + +VoxelLightNode::VoxelLightNode() { +} +VoxelLightNode::~VoxelLightNode() { +} + +void VoxelLightNode::_bind_methods() { +} diff --git a/nodes/voxelman_light.h b/nodes/voxel_light_node.h similarity index 89% rename from nodes/voxelman_light.h rename to nodes/voxel_light_node.h index 2ea0d74..ba00a77 100644 --- a/nodes/voxelman_light.h +++ b/nodes/voxel_light_node.h @@ -20,8 +20,8 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#ifndef VOXELMAN_LIGHT_H -#define VOXELMAN_LIGHT_H +#ifndef VOXEL_LIGHT_NODE_H +#define VOXEL_LIGHT_NODE_H #include "core/version.h" @@ -35,15 +35,15 @@ SOFTWARE. #include "core/math/vector3.h" -class VoxelmanLight : public Spatial { - GDCLASS(VoxelmanLight, Spatial); +class VoxelLightNode : public Spatial { + GDCLASS(VoxelLightNode, Spatial); OBJ_CATEGORY("Props"); public: //make it turn into a normal light if voxelman isn't present? - VoxelmanLight(); - ~VoxelmanLight(); + VoxelLightNode(); + ~VoxelLightNode(); protected: static void _bind_methods(); diff --git a/nodes/voxelman_light.cpp b/nodes/voxelman_light.cpp deleted file mode 100644 index a0748ee..0000000 --- a/nodes/voxelman_light.cpp +++ /dev/null @@ -1,9 +0,0 @@ -#include "voxelman_light.h" - -VoxelmanLight::VoxelmanLight() { -} -VoxelmanLight::~VoxelmanLight() { -} - -void VoxelmanLight::_bind_methods() { -} diff --git a/register_types.cpp b/register_types.cpp index cf02703..7e0fbb6 100644 --- a/register_types.cpp +++ b/register_types.cpp @@ -25,12 +25,12 @@ SOFTWARE. #include "library/voxel_surface.h" #include "library/voxel_surface_simple.h" -#include "library/voxelman_library.h" -#include "library/voxelman_library_simple.h" +#include "library/voxel_library.h" +#include "library/voxel_library_simple.h" #ifdef TEXTURE_PACKER_PRESENT #include "library/voxel_surface_merger.h" -#include "library/voxelman_library_merger.h" +#include "library/voxel_library_merger.h" #endif #include "data/voxel_light.h" @@ -51,8 +51,8 @@ SOFTWARE. #include "meshers/cubic/voxel_cube_points.h" #include "meshers/cubic/voxel_mesher_cubic.h" -#include "level_generator/voxelman_level_generator.h" -#include "level_generator/voxelman_level_generator_flat.h" +#include "level_generator/voxel_level_generator.h" +#include "level_generator/voxel_level_generator_flat.h" #include "areas/world_area.h" @@ -70,12 +70,12 @@ SOFTWARE. #include "world/marching_cubes/voxel_chunk_marching_cubes.h" #include "world/marching_cubes/voxel_world_marching_cubes.h" -#include "nodes/voxelman_light.h" +#include "nodes/voxel_light_node.h" #include "world/jobs/voxel_job.h" #include "world/jobs/voxel_light_job.h" #include "world/jobs/voxel_prop_job.h" -#include "world/jobs/voxel_terrarin_job.h" +#include "world/jobs/voxel_terrain_job.h" void register_voxelman_types() { ClassDB::register_class(); @@ -87,16 +87,16 @@ void register_voxelman_types() { ClassDB::register_class(); ClassDB::register_class(); - ClassDB::register_class(); - ClassDB::register_class(); + ClassDB::register_class(); + ClassDB::register_class(); #ifdef TEXTURE_PACKER_PRESENT ClassDB::register_class(); - ClassDB::register_class(); + ClassDB::register_class(); #endif ClassDB::register_class(); - ClassDB::register_class(); + ClassDB::register_class(); ClassDB::register_class(); ClassDB::register_class(); @@ -121,13 +121,13 @@ void register_voxelman_types() { ClassDB::register_class(); ClassDB::register_class(); - ClassDB::register_class(); - ClassDB::register_class(); + ClassDB::register_class(); + ClassDB::register_class(); ClassDB::register_class(); ClassDB::register_class(); - ClassDB::register_class(); + ClassDB::register_class(); ClassDB::register_class(); ClassDB::register_class(); diff --git a/register_types.h b/register_types.h index 726e7ba..9bb7429 100644 --- a/register_types.h +++ b/register_types.h @@ -20,8 +20,8 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#ifndef VOXELMAN_REGISTER_TYPES_H -#define VOXELMAN_REGISTER_TYPES_H +#ifndef VOXEL_REGISTER_TYPES_H +#define VOXEL_REGISTER_TYPES_H void register_voxelman_types(); void unregister_voxelman_types(); diff --git a/world/blocky/voxel_world_blocky.cpp b/world/blocky/voxel_world_blocky.cpp index 66112a3..3bd57fd 100644 --- a/world/blocky/voxel_world_blocky.cpp +++ b/world/blocky/voxel_world_blocky.cpp @@ -28,7 +28,8 @@ SOFTWARE. #include "../../meshers/blocky/voxel_mesher_liquid_blocky.h" #include "../jobs/voxel_light_job.h" #include "../jobs/voxel_prop_job.h" -#include "../jobs/voxel_terrarin_job.h" +#include "../jobs/voxel_terrain_job.h" +#include "../../defines.h" Ref VoxelWorldBlocky::_create_chunk(int x, int y, int z, Ref chunk) { @@ -37,14 +38,14 @@ Ref VoxelWorldBlocky::_create_chunk(int x, int y, int z, Refjob_get_count() == 0) { - Ref tj; - tj.instance(); + Ref tj; + tj.INSTANCE(); Ref lj; - lj.instance(); + lj.INSTANCE(); Ref pj; - pj.instance(); + pj.INSTANCE(); pj->set_prop_mesher(Ref(memnew(VoxelMesherBlocky))); tj->add_mesher(Ref(memnew(VoxelMesherBlocky()))); diff --git a/world/cubic/voxel_world_cubic.cpp b/world/cubic/voxel_world_cubic.cpp index 6f67ac3..1acfb7a 100644 --- a/world/cubic/voxel_world_cubic.cpp +++ b/world/cubic/voxel_world_cubic.cpp @@ -27,7 +27,7 @@ SOFTWARE. #include "../../meshers/cubic/voxel_mesher_cubic.h" #include "../jobs/voxel_light_job.h" #include "../jobs/voxel_prop_job.h" -#include "../jobs/voxel_terrarin_job.h" +#include "../jobs/voxel_terrain_job.h" Ref VoxelWorldCubic::_create_chunk(int x, int y, int z, Ref chunk) { @@ -36,14 +36,14 @@ Ref VoxelWorldCubic::_create_chunk(int x, int y, int z, Refjob_get_count() == 0) { - Ref tj; - tj.instance(); + Ref tj; + tj.INSTANCE(); Ref lj; - lj.instance(); + lj.INSTANCE(); Ref pj; - pj.instance(); + pj.INSTANCE(); pj->set_prop_mesher(Ref(memnew(VoxelMesherCubic))); Ref m = Ref(memnew(VoxelMesherCubic())); diff --git a/world/default/voxel_chunk_default.cpp b/world/default/voxel_chunk_default.cpp index 369be46..d5d8f8c 100644 --- a/world/default/voxel_chunk_default.cpp +++ b/world/default/voxel_chunk_default.cpp @@ -37,7 +37,7 @@ SOFTWARE. #include "../jobs/voxel_light_job.h" #include "../jobs/voxel_prop_job.h" -#include "../jobs/voxel_terrarin_job.h" +#include "../jobs/voxel_terrain_job.h" const String VoxelChunkDefault::BINDING_STRING_BUILD_FLAGS = "Use Isolevel,Use Lighting,Use AO,Use RAO,Generate AO,Generate RAO,Bake Lights,Create Collider,Create Lods"; @@ -83,7 +83,7 @@ void VoxelChunkDefault::set_current_lod_level(const int value) { if (i == _current_lod_level) vis = true; - RID rid = mesh_rid_get_index(MESH_INDEX_TERRARIN, MESH_TYPE_INDEX_MESH_INSTANCE, i); + RID rid = mesh_rid_get_index(MESH_INDEX_TERRAIN, MESH_TYPE_INDEX_MESH_INSTANCE, i); if (rid != RID()) VisualServer::get_singleton()->instance_set_visible(rid, vis); @@ -378,7 +378,12 @@ void VoxelChunkDefault::colliders_create(const int mesh_index, const int layer_m ERR_FAIL_COND(m.has(MESH_TYPE_INDEX_SHAPE)); RID shape_rid = PhysicsServer::get_singleton()->shape_create(PhysicsServer::SHAPE_CONCAVE_POLYGON); +#if VERSION_MAJOR < 4 RID body_rid = PhysicsServer::get_singleton()->body_create(PhysicsServer::BODY_MODE_STATIC); +#else + RID body_rid = PhysicsServer::get_singleton()->body_create(); + PhysicsServer::get_singleton()->body_set_mode(body_rid, PhysicsServer::BODY_MODE_STATIC); +#endif PhysicsServer::get_singleton()->body_set_collision_layer(body_rid, layer_mask); PhysicsServer::get_singleton()->body_set_collision_mask(body_rid, layer_mask); @@ -712,7 +717,7 @@ void VoxelChunkDefault::_visibility_changed(bool visible) { } for (int i = 0; i < _lod_num + 1; ++i) { - RID rid = mesh_rid_get_index(MESH_INDEX_TERRARIN, MESH_TYPE_INDEX_MESH_INSTANCE, i); + RID rid = mesh_rid_get_index(MESH_INDEX_TERRAIN, MESH_TYPE_INDEX_MESH_INSTANCE, i); if (rid != RID()) VisualServer::get_singleton()->instance_set_visible(rid, false); @@ -833,7 +838,11 @@ void VoxelChunkDefault::_world_light_removed(const Ref &light) { int index = _lights.find(light); if (index != -1) { +#if VERSION_MAJOR < 4 _lights.remove(index); +#else + _lights.remove_at(index); +#endif set_lights_dirty(true); } @@ -975,7 +984,7 @@ void VoxelChunkDefault::_bind_methods() { BIND_ENUM_CONSTANT(DEFAULT_CHANNEL_LIQUID_FLOW); BIND_ENUM_CONSTANT(MAX_DEFAULT_CHANNELS); - BIND_CONSTANT(MESH_INDEX_TERRARIN); + BIND_CONSTANT(MESH_INDEX_TERRAIN); BIND_CONSTANT(MESH_INDEX_PROP); BIND_CONSTANT(MESH_INDEX_LIQUID); BIND_CONSTANT(MESH_INDEX_CLUTTER); diff --git a/world/default/voxel_chunk_default.h b/world/default/voxel_chunk_default.h index d8c8e6f..8fbf5b9 100644 --- a/world/default/voxel_chunk_default.h +++ b/world/default/voxel_chunk_default.h @@ -49,7 +49,7 @@ SOFTWARE. #include "../../data/voxel_light.h" #include "../../meshers/voxel_mesher.h" #include "../../library/voxel_surface.h" -#include "../../library/voxelman_library.h" +#include "../../library/voxel_library.h" class VoxelWorld; class VoxelJob; @@ -77,7 +77,7 @@ public: }; enum { - MESH_INDEX_TERRARIN = 0, + MESH_INDEX_TERRAIN = 0, MESH_INDEX_PROP, MESH_INDEX_LIQUID, MESH_INDEX_CLUTTER, diff --git a/world/default/voxel_world_default.cpp b/world/default/voxel_world_default.cpp index 14e1ff6..dbd867c 100644 --- a/world/default/voxel_world_default.cpp +++ b/world/default/voxel_world_default.cpp @@ -29,7 +29,7 @@ SOFTWARE. #include "../../meshers/default/voxel_mesher_default.h" #include "../jobs/voxel_light_job.h" #include "../jobs/voxel_prop_job.h" -#include "../jobs/voxel_terrarin_job.h" +#include "../jobs/voxel_terrain_job.h" _FORCE_INLINE_ int VoxelWorldDefault::get_build_flags() const { return _build_flags; @@ -62,7 +62,11 @@ void VoxelWorldDefault::set_num_lods(const int value) { } void VoxelWorldDefault::update_lods() { +#if VERSION_MAJOR < 4 call("_update_lods"); +#else + GDVIRTUAL_CALL(_update_lods); +#endif } int VoxelWorldDefault::get_chunk_lod_falloff() const { @@ -178,7 +182,7 @@ Ref VoxelWorldDefault::_create_chunk(int x, int y, int z, Refjob_get_count() == 0) { - Ref tj; + Ref tj; #if VERSION_MAJOR < 4 tj.instance(); #else @@ -298,7 +302,12 @@ void VoxelWorldDefault::_bind_methods() { ClassDB::bind_method(D_METHOD("set_num_lods", "value"), &VoxelWorldDefault::set_num_lods); ADD_PROPERTY(PropertyInfo(Variant::INT, "num_lods"), "set_num_lods", "get_num_lods"); +#if VERSION_MAJOR < 4 BIND_VMETHOD(MethodInfo("_update_lods")); +#else + GDVIRTUAL_BIND(_update_lods); +#endif + ClassDB::bind_method(D_METHOD("update_lods"), &VoxelWorldDefault::update_lods); ClassDB::bind_method(D_METHOD("_update_lods"), &VoxelWorldDefault::_update_lods); diff --git a/world/default/voxel_world_default.h b/world/default/voxel_world_default.h index 5b67736..4ebbffb 100644 --- a/world/default/voxel_world_default.h +++ b/world/default/voxel_world_default.h @@ -45,6 +45,10 @@ public: PoolColorArray get_vertex_colors(const Transform &transform, const PoolVector3Array &vertices, const float base_light_value = 0.45, const float ao_strength = 0.2); +#if VERSION_MAJOR >= 4 + GDVIRTUAL0(_update_lods); +#endif + VoxelWorldDefault(); ~VoxelWorldDefault(); diff --git a/world/jobs/voxel_job.cpp b/world/jobs/voxel_job.cpp index 73f3983..3e6b694 100644 --- a/world/jobs/voxel_job.cpp +++ b/world/jobs/voxel_job.cpp @@ -64,7 +64,11 @@ void VoxelJob::next_job() { } void VoxelJob::reset() { +#if VERSION_MAJOR < 4 call("_reset"); +#else + GDVIRTUAL_CALL(_reset); +#endif } void VoxelJob::_reset() { _build_done = false; @@ -72,7 +76,6 @@ void VoxelJob::_reset() { } void VoxelJob::_execute() { - ActiveBuildPhaseType origpt = _build_phase_type; while (!get_cancelled() && _in_tree && !_build_done && origpt == _build_phase_type && !should_return()) { @@ -85,7 +88,11 @@ void VoxelJob::_execute() { } void VoxelJob::execute_phase() { +#if VERSION_MAJOR < 4 call("_execute_phase"); +#else + GDVIRTUAL_CALL(_execute_phase); +#endif } void VoxelJob::_execute_phase() { @@ -93,12 +100,22 @@ void VoxelJob::_execute_phase() { } void VoxelJob::process(const float delta) { - if (has_method("_process")) +#if VERSION_MAJOR < 4 + if (has_method("_process")) { call("_process", delta); + } +#else + GDVIRTUAL_CALL(_process, delta); +#endif } void VoxelJob::physics_process(const float delta) { - if (has_method("_physics_process")) +#if VERSION_MAJOR < 4 + if (has_method("_physics_process")) { call("_physics_process", delta); + } +#else + GDVIRTUAL_CALL(_physics_process, delta); +#endif } //Data Management functions @@ -162,7 +179,7 @@ void VoxelJob::generate_random_ao(int seed, int octaves, int period, float persi int position_z = _chunk->get_position_z(); Ref noise; - noise.instance(); + noise.INSTANCE(); noise->set_seed(seed); noise->set_octaves(octaves); @@ -217,14 +234,14 @@ Array VoxelJob::merge_mesh_array(Array arr) const { int rem = equals[k]; int remk = rem - k; - verts.remove(remk); + verts.VREMOVE(remk); if (has_normals) - normals.remove(remk); + normals.VREMOVE(remk); if (has_uvs) - uvs.remove(remk); + uvs.VREMOVE(remk); if (has_colors) - colors.remove(remk); + colors.VREMOVE(remk); for (int j = 0; j < indices.size(); ++j) { int indx = indices[j]; @@ -256,7 +273,11 @@ Array VoxelJob::bake_mesh_array_uv(Array arr, Ref tex, const float mul_ ERR_FAIL_COND_V(arr.size() != VisualServer::ARRAY_MAX, arr); ERR_FAIL_COND_V(!tex.is_valid(), arr); +#if VERSION_MAJOR < 4 Ref img = tex->get_data(); +#else + Ref img = tex->get_image(); +#endif ERR_FAIL_COND_V(!img.is_valid(), arr); @@ -294,7 +315,6 @@ Array VoxelJob::bake_mesh_array_uv(Array arr, Ref tex, const float mul_ } void VoxelJob::chunk_exit_tree() { - _in_tree = false; if (get_complete()) { @@ -328,8 +348,13 @@ VoxelJob::~VoxelJob() { } void VoxelJob::_bind_methods() { +#if VERSION_MAJOR < 4 BIND_VMETHOD(MethodInfo("_process", PropertyInfo(Variant::REAL, "delta"))); BIND_VMETHOD(MethodInfo("_physics_process", PropertyInfo(Variant::REAL, "delta"))); +#else + GDVIRTUAL_BIND(_process, "delta"); + GDVIRTUAL_BIND(_physics_process, "delta"); +#endif ClassDB::bind_method(D_METHOD("get_build_phase_type"), &VoxelJob::get_build_phase_type); ClassDB::bind_method(D_METHOD("set_build_phase_type", "value"), &VoxelJob::set_build_phase_type); @@ -346,14 +371,22 @@ void VoxelJob::_bind_methods() { ClassDB::bind_method(D_METHOD("next_job"), &VoxelJob::next_job); +#if VERSION_MAJOR < 4 BIND_VMETHOD(MethodInfo("_reset")); +#else + GDVIRTUAL_BIND(_reset); +#endif ClassDB::bind_method(D_METHOD("reset"), &VoxelJob::reset); ClassDB::bind_method(D_METHOD("_reset"), &VoxelJob::_reset); ClassDB::bind_method(D_METHOD("_execute"), &VoxelJob::_execute); +#if VERSION_MAJOR < 4 BIND_VMETHOD(MethodInfo("_execute_phase")); +#else + GDVIRTUAL_BIND(_execute_phase); +#endif ClassDB::bind_method(D_METHOD("execute_phase"), &VoxelJob::execute_phase); ClassDB::bind_method(D_METHOD("_execute_phase"), &VoxelJob::_execute_phase); @@ -385,7 +418,12 @@ void VoxelJob::_bind_methods() { ClassDB::bind_method(D_METHOD("should_do", "just_check"), &VoxelJob::should_do, DEFVAL(false)); ClassDB::bind_method(D_METHOD("should_return"), &VoxelJob::should_return); +#if VERSION_MAJOR < 4 BIND_VMETHOD(MethodInfo("_execute")); +#else + GDVIRTUAL_BIND(_execute); +#endif + ClassDB::bind_method(D_METHOD("execute"), &VoxelJob::execute); ADD_SIGNAL(MethodInfo("completed")); @@ -457,7 +495,11 @@ bool VoxelJob::should_return() { void VoxelJob::execute() { ERR_FAIL_COND(!has_method("_execute")); +#if VERSION_MAJOR < 4 call("_execute"); +#else + GDVIRTUAL_CALL(_execute); +#endif } #endif \ No newline at end of file diff --git a/world/jobs/voxel_job.h b/world/jobs/voxel_job.h index 608712b..aa99274 100644 --- a/world/jobs/voxel_job.h +++ b/world/jobs/voxel_job.h @@ -100,6 +100,14 @@ public: void chunk_exit_tree(); +#if VERSION_MAJOR >= 4 + GDVIRTUAL1(_process, float); + GDVIRTUAL1(_physics_process, float); + + GDVIRTUAL0(_reset); + GDVIRTUAL0(_execute_phase); +#endif + VoxelJob(); ~VoxelJob(); @@ -141,6 +149,10 @@ public: void execute(); +#if VERSION_MAJOR >= 4 + GDVIRTUAL0(_execute); +#endif + private: bool _complete; bool _cancelled; diff --git a/world/jobs/voxel_light_job.cpp b/world/jobs/voxel_light_job.cpp index a0a7f01..3a48998 100644 --- a/world/jobs/voxel_light_job.cpp +++ b/world/jobs/voxel_light_job.cpp @@ -25,7 +25,7 @@ SOFTWARE. #include "../../defines.h" #include "../../library/voxel_surface.h" -#include "../../library/voxelman_library.h" +#include "../../library/voxel_library.h" #include "../../meshers/voxel_mesher.h" #include "../default/voxel_chunk_default.h" @@ -74,7 +74,7 @@ void VoxelLightJob::phase_light() { void VoxelLightJob::_execute_phase() { ERR_FAIL_COND(!_chunk.is_valid()); - Ref library = _chunk->get_library(); + Ref library = _chunk->get_library(); ERR_FAIL_COND(!library.is_valid()); diff --git a/world/jobs/voxel_prop_job.cpp b/world/jobs/voxel_prop_job.cpp index 1cefcc7..96bcaa5 100644 --- a/world/jobs/voxel_prop_job.cpp +++ b/world/jobs/voxel_prop_job.cpp @@ -25,7 +25,7 @@ SOFTWARE. #include "../../defines.h" #include "../../library/voxel_surface.h" -#include "../../library/voxelman_library.h" +#include "../../library/voxel_library.h" #include "../../meshers/voxel_mesher.h" #include "../default/voxel_chunk_default.h" @@ -69,7 +69,12 @@ void VoxelPropJob::phase_physics_process() { continue; } +#if VERSION_MAJOR < 4 RID body = PhysicsServer::get_singleton()->body_create(PhysicsServer::BODY_MODE_STATIC); +#else + RID body = PhysicsServer::get_singleton()->body_create(); + PhysicsServer::get_singleton()->body_set_mode(body, PhysicsServer::BODY_MODE_STATIC); +#endif Transform transform = chunk->mesh_data_resource_get_transform(i); transform *= offset; @@ -223,7 +228,6 @@ void VoxelPropJob::phase_prop() { } if (should_do()) { - VS::get_singleton()->mesh_add_surface_from_arrays(mesh_rid, VisualServer::PRIMITIVE_TRIANGLES, temp_mesh_arr); if (chunk->get_library()->prop_material_get(0).is_valid()) @@ -236,7 +240,6 @@ void VoxelPropJob::phase_prop() { if ((chunk->get_build_flags() & VoxelChunkDefault::BUILD_FLAG_CREATE_LODS) != 0) { if (should_do()) { - if (chunk->get_lod_num() >= 1) { //for lod 1 just remove uv2 temp_mesh_arr[VisualServer::ARRAY_TEX_UV2] = Variant(); @@ -294,7 +297,7 @@ void VoxelPropJob::phase_prop() { if (should_do()) { if (chunk->get_lod_num() > 4) { Ref fqms; - fqms.instance(); + fqms.INSTANCE(); fqms->set_preserve_border_edges(true); fqms->initialize(temp_mesh_arr); @@ -303,12 +306,12 @@ void VoxelPropJob::phase_prop() { temp_mesh_arr = fqms->get_arrays(); VisualServer::get_singleton()->mesh_add_surface_from_arrays( - chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRARIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, i), + chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRAIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, i), VisualServer::PRIMITIVE_TRIANGLES, temp_mesh_arr); if (chunk->get_library()->prop_material_get(i).is_valid()) VisualServer::get_singleton()->mesh_surface_set_material( - chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRARIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, i), 0, + chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRAIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, i), 0, chunk->get_library()->prop_material_get(i)->get_rid()); } } @@ -335,7 +338,7 @@ void VoxelPropJob::_physics_process(float delta) { void VoxelPropJob::_execute_phase() { ERR_FAIL_COND(!_chunk.is_valid()); - Ref library = _chunk->get_library(); + Ref library = _chunk->get_library(); ERR_FAIL_COND(!library.is_valid()); diff --git a/world/jobs/voxel_terrarin_job.cpp b/world/jobs/voxel_terrain_job.cpp similarity index 81% rename from world/jobs/voxel_terrarin_job.cpp rename to world/jobs/voxel_terrain_job.cpp index 3b760dd..4636188 100644 --- a/world/jobs/voxel_terrarin_job.cpp +++ b/world/jobs/voxel_terrain_job.cpp @@ -20,10 +20,10 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#include "voxel_terrarin_job.h" +#include "voxel_terrain_job.h" #include "../../library/voxel_surface.h" -#include "../../library/voxelman_library.h" +#include "../../library/voxel_library.h" #include "../../meshers/default/voxel_mesher_default.h" #include "../../meshers/voxel_mesher.h" @@ -34,51 +34,51 @@ SOFTWARE. #include "../../../mesh_utils/fast_quadratic_mesh_simplifier.h" #endif -Ref VoxelTerrarinJob::get_mesher(int index) const { +Ref VoxelTerrainJob::get_mesher(int index) const { ERR_FAIL_INDEX_V(index, _meshers.size(), Ref()); return _meshers.get(index); } -void VoxelTerrarinJob::set_mesher(int index, const Ref &mesher) { +void VoxelTerrainJob::set_mesher(int index, const Ref &mesher) { ERR_FAIL_INDEX(index, _meshers.size()); _meshers.set(index, mesher); } -void VoxelTerrarinJob::remove_mesher(const int index) { +void VoxelTerrainJob::remove_mesher(const int index) { ERR_FAIL_INDEX(index, _meshers.size()); - _meshers.remove(index); + _meshers.VREMOVE(index); } -void VoxelTerrarinJob::add_mesher(const Ref &mesher) { +void VoxelTerrainJob::add_mesher(const Ref &mesher) { _meshers.push_back(mesher); } -int VoxelTerrarinJob::get_mesher_count() const { +int VoxelTerrainJob::get_mesher_count() const { return _meshers.size(); } -Ref VoxelTerrarinJob::get_liquid_mesher(int index) const { +Ref VoxelTerrainJob::get_liquid_mesher(int index) const { ERR_FAIL_INDEX_V(index, _liquid_meshers.size(), Ref()); return _liquid_meshers.get(index); } -void VoxelTerrarinJob::set_liquid_mesher(int index, const Ref &mesher) { +void VoxelTerrainJob::set_liquid_mesher(int index, const Ref &mesher) { ERR_FAIL_INDEX(index, _liquid_meshers.size()); _liquid_meshers.set(index, mesher); } -void VoxelTerrarinJob::remove_liquid_mesher(const int index) { +void VoxelTerrainJob::remove_liquid_mesher(const int index) { ERR_FAIL_INDEX(index, _liquid_meshers.size()); - _liquid_meshers.remove(index); + _liquid_meshers.VREMOVE(index); } -void VoxelTerrarinJob::add_liquid_mesher(const Ref &mesher) { +void VoxelTerrainJob::add_liquid_mesher(const Ref &mesher) { _liquid_meshers.push_back(mesher); } -int VoxelTerrarinJob::get_liquid_mesher_count() const { +int VoxelTerrainJob::get_liquid_mesher_count() const { return _liquid_meshers.size(); } -void VoxelTerrarinJob::phase_setup() { +void VoxelTerrainJob::phase_setup() { for (int i = 0; i < _meshers.size(); ++i) { Ref mesher = _meshers.get(i); @@ -100,7 +100,7 @@ void VoxelTerrarinJob::phase_setup() { next_phase(); } -void VoxelTerrarinJob::phase_terrarin_mesh_setup() { +void VoxelTerrainJob::phase_terrain_mesh_setup() { int starti = 0; if (has_meta("tms_m")) { @@ -150,7 +150,7 @@ void VoxelTerrarinJob::phase_terrarin_mesh_setup() { next_phase(); } -void VoxelTerrarinJob::phase_collider() { +void VoxelTerrainJob::phase_collider() { Ref chunk = _chunk; if ((chunk->get_build_flags() & VoxelChunkDefault::BUILD_FLAG_CREATE_COLLIDER) == 0) { @@ -216,15 +216,15 @@ void VoxelTerrarinJob::phase_collider() { next_phase(); } -void VoxelTerrarinJob::phase_physics_process() { +void VoxelTerrainJob::phase_physics_process() { Ref chunk = _chunk; if (temp_arr_collider.size() != 0) { - if (!chunk->meshes_has(VoxelChunkDefault::MESH_INDEX_TERRARIN, VoxelChunkDefault::MESH_TYPE_INDEX_BODY)) { - chunk->colliders_create(VoxelChunkDefault::MESH_INDEX_TERRARIN); + if (!chunk->meshes_has(VoxelChunkDefault::MESH_INDEX_TERRAIN, VoxelChunkDefault::MESH_TYPE_INDEX_BODY)) { + chunk->colliders_create(VoxelChunkDefault::MESH_INDEX_TERRAIN); } - PhysicsServer::get_singleton()->shape_set_data(chunk->mesh_rid_get(VoxelChunkDefault::MESH_INDEX_TERRARIN, VoxelChunkDefault::MESH_TYPE_INDEX_SHAPE), temp_arr_collider); + PhysicsServer::get_singleton()->shape_set_data(chunk->mesh_rid_get(VoxelChunkDefault::MESH_INDEX_TERRAIN, VoxelChunkDefault::MESH_TYPE_INDEX_SHAPE), temp_arr_collider); temp_arr_collider.resize(0); } @@ -251,7 +251,7 @@ void VoxelTerrarinJob::phase_physics_process() { next_phase(); } -void VoxelTerrarinJob::phase_terrarin_mesh() { +void VoxelTerrainJob::phase_terrain_mesh() { Ref chunk = _chunk; if ((chunk->get_build_flags() & VoxelChunkDefault::BUILD_FLAG_USE_LIGHTING) != 0) { @@ -378,16 +378,16 @@ void VoxelTerrarinJob::phase_terrarin_mesh() { } } - RID mesh_rid = chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRARIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, 0); + RID mesh_rid = chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRAIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, 0); if (should_do()) { if (mesh_rid == RID()) { if ((chunk->get_build_flags() & VoxelChunkDefault::BUILD_FLAG_CREATE_LODS) != 0) - chunk->meshes_create(VoxelChunkDefault::MESH_INDEX_TERRARIN, chunk->get_lod_num() + 1); + chunk->meshes_create(VoxelChunkDefault::MESH_INDEX_TERRAIN, chunk->get_lod_num() + 1); else - chunk->meshes_create(VoxelChunkDefault::MESH_INDEX_TERRARIN, 1); + chunk->meshes_create(VoxelChunkDefault::MESH_INDEX_TERRAIN, 1); - mesh_rid = chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRARIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, 0); + mesh_rid = chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRAIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, 0); } if (VS::get_singleton()->mesh_get_surface_count(mesh_rid) > 0) @@ -419,10 +419,10 @@ void VoxelTerrarinJob::phase_terrarin_mesh() { //for lod 1 just remove uv2 temp_mesh_arr[VisualServer::ARRAY_TEX_UV2] = Variant(); - VisualServer::get_singleton()->mesh_add_surface_from_arrays(chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRARIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, 1), VisualServer::PRIMITIVE_TRIANGLES, temp_mesh_arr); + VisualServer::get_singleton()->mesh_add_surface_from_arrays(chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRAIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, 1), VisualServer::PRIMITIVE_TRIANGLES, temp_mesh_arr); if (chunk->get_library()->material_get(1).is_valid()) - VisualServer::get_singleton()->mesh_surface_set_material(chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRARIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, 1), 0, chunk->get_library()->material_get(1)->get_rid()); + VisualServer::get_singleton()->mesh_surface_set_material(chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRAIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, 1), 0, chunk->get_library()->material_get(1)->get_rid()); } if (should_return()) { return; @@ -434,10 +434,10 @@ void VoxelTerrarinJob::phase_terrarin_mesh() { Array temp_mesh_arr2 = merge_mesh_array(temp_mesh_arr); temp_mesh_arr = temp_mesh_arr2; - VisualServer::get_singleton()->mesh_add_surface_from_arrays(chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRARIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, 2), VisualServer::PRIMITIVE_TRIANGLES, temp_mesh_arr2); + VisualServer::get_singleton()->mesh_add_surface_from_arrays(chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRAIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, 2), VisualServer::PRIMITIVE_TRIANGLES, temp_mesh_arr2); if (chunk->get_library()->material_get(2).is_valid()) - VisualServer::get_singleton()->mesh_surface_set_material(chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRARIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, 2), 0, chunk->get_library()->material_get(2)->get_rid()); + VisualServer::get_singleton()->mesh_surface_set_material(chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRAIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, 2), 0, chunk->get_library()->material_get(2)->get_rid()); } if (should_return()) { @@ -462,12 +462,12 @@ void VoxelTerrarinJob::phase_terrarin_mesh() { temp_mesh_arr[VisualServer::ARRAY_TEX_UV] = Variant(); VisualServer::get_singleton()->mesh_add_surface_from_arrays( - chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRARIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, 3), + chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRAIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, 3), VisualServer::PRIMITIVE_TRIANGLES, temp_mesh_arr); if (chunk->get_library()->material_get(3).is_valid()) VisualServer::get_singleton()->mesh_surface_set_material( - chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRARIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, 3), 0, + chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRAIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, 3), 0, chunk->get_library()->material_get(3)->get_rid()); } } @@ -481,7 +481,7 @@ void VoxelTerrarinJob::phase_terrarin_mesh() { if (should_do()) { if (chunk->get_lod_num() > 4) { Ref fqms; - fqms.instance(); + fqms.INSTANCE(); fqms->set_preserve_border_edges(true); fqms->initialize(temp_mesh_arr); @@ -490,12 +490,12 @@ void VoxelTerrarinJob::phase_terrarin_mesh() { temp_mesh_arr = fqms->get_arrays(); VisualServer::get_singleton()->mesh_add_surface_from_arrays( - chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRARIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, i), + chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRAIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, i), VisualServer::PRIMITIVE_TRIANGLES, temp_mesh_arr); if (chunk->get_library()->material_get(i).is_valid()) VisualServer::get_singleton()->mesh_surface_set_material( - chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRARIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, i), 0, + chunk->mesh_rid_get_index(VoxelChunkDefault::MESH_INDEX_TERRAIN, VoxelChunkDefault::MESH_TYPE_INDEX_MESH, i), 0, chunk->get_library()->material_get(i)->get_rid()); } } @@ -570,37 +570,37 @@ void VoxelTerrarinJob::phase_terrarin_mesh() { next_phase(); } -void VoxelTerrarinJob::phase_finalize() { +void VoxelTerrainJob::phase_finalize() { set_complete(true); //So threadpool knows it's done next_job(); } -void VoxelTerrarinJob::_execute_phase() { +void VoxelTerrainJob::_execute_phase() { ERR_FAIL_COND(!_chunk.is_valid()); - Ref library = _chunk->get_library(); + Ref library = _chunk->get_library(); ERR_FAIL_COND(!library.is_valid()); if (_phase == 0) { phase_setup(); } else if (_phase == 1) { - phase_terrarin_mesh_setup(); + phase_terrain_mesh_setup(); } else if (_phase == 2) { phase_collider(); } else if (_phase == 4) { - phase_terrarin_mesh(); + phase_terrain_mesh(); } else if (_phase == 5) { phase_finalize(); } else if (_phase > 5) { set_complete(true); //So threadpool knows it's done next_job(); - ERR_FAIL_MSG("VoxelTerrarinJob: _phase is too high!"); + ERR_FAIL_MSG("VoxelTerrainJob: _phase is too high!"); } } -void VoxelTerrarinJob::_reset() { +void VoxelTerrainJob::_reset() { VoxelJob::_reset(); _build_done = false; @@ -637,31 +637,31 @@ void VoxelTerrarinJob::_reset() { } } -void VoxelTerrarinJob::_physics_process(float delta) { +void VoxelTerrainJob::_physics_process(float delta) { if (_phase == 3) phase_physics_process(); } -VoxelTerrarinJob::VoxelTerrarinJob() { +VoxelTerrainJob::VoxelTerrainJob() { } -VoxelTerrarinJob::~VoxelTerrarinJob() { +VoxelTerrainJob::~VoxelTerrainJob() { _meshers.clear(); _liquid_meshers.clear(); } -void VoxelTerrarinJob::_bind_methods() { - ClassDB::bind_method(D_METHOD("get_mesher", "index"), &VoxelTerrarinJob::get_mesher); - ClassDB::bind_method(D_METHOD("set_mesher", "index", "mesher"), &VoxelTerrarinJob::set_mesher); - ClassDB::bind_method(D_METHOD("remove_mesher", "index"), &VoxelTerrarinJob::remove_mesher); - ClassDB::bind_method(D_METHOD("add_mesher", "mesher"), &VoxelTerrarinJob::add_mesher); - ClassDB::bind_method(D_METHOD("get_mesher_count"), &VoxelTerrarinJob::get_mesher_count); +void VoxelTerrainJob::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_mesher", "index"), &VoxelTerrainJob::get_mesher); + ClassDB::bind_method(D_METHOD("set_mesher", "index", "mesher"), &VoxelTerrainJob::set_mesher); + ClassDB::bind_method(D_METHOD("remove_mesher", "index"), &VoxelTerrainJob::remove_mesher); + ClassDB::bind_method(D_METHOD("add_mesher", "mesher"), &VoxelTerrainJob::add_mesher); + ClassDB::bind_method(D_METHOD("get_mesher_count"), &VoxelTerrainJob::get_mesher_count); - ClassDB::bind_method(D_METHOD("get_liquid_mesher", "index"), &VoxelTerrarinJob::get_liquid_mesher); - ClassDB::bind_method(D_METHOD("set_liquid_mesher", "index", "mesher"), &VoxelTerrarinJob::set_liquid_mesher); - ClassDB::bind_method(D_METHOD("remove_liquid_mesher", "index"), &VoxelTerrarinJob::remove_liquid_mesher); - ClassDB::bind_method(D_METHOD("add_liquid_mesher", "mesher"), &VoxelTerrarinJob::add_liquid_mesher); - ClassDB::bind_method(D_METHOD("get_liquid_mesher_count"), &VoxelTerrarinJob::get_liquid_mesher_count); + ClassDB::bind_method(D_METHOD("get_liquid_mesher", "index"), &VoxelTerrainJob::get_liquid_mesher); + ClassDB::bind_method(D_METHOD("set_liquid_mesher", "index", "mesher"), &VoxelTerrainJob::set_liquid_mesher); + ClassDB::bind_method(D_METHOD("remove_liquid_mesher", "index"), &VoxelTerrainJob::remove_liquid_mesher); + ClassDB::bind_method(D_METHOD("add_liquid_mesher", "mesher"), &VoxelTerrainJob::add_liquid_mesher); + ClassDB::bind_method(D_METHOD("get_liquid_mesher_count"), &VoxelTerrainJob::get_liquid_mesher_count); - ClassDB::bind_method(D_METHOD("_physics_process", "delta"), &VoxelTerrarinJob::_physics_process); + ClassDB::bind_method(D_METHOD("_physics_process", "delta"), &VoxelTerrainJob::_physics_process); } diff --git a/world/jobs/voxel_terrarin_job.h b/world/jobs/voxel_terrain_job.h similarity index 89% rename from world/jobs/voxel_terrarin_job.h rename to world/jobs/voxel_terrain_job.h index a8d7b8a..e759a3d 100644 --- a/world/jobs/voxel_terrarin_job.h +++ b/world/jobs/voxel_terrain_job.h @@ -20,8 +20,8 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -#ifndef VOXEL_TERRARIN_JOB_H -#define VOXEL_TERRARIN_JOB_H +#ifndef VOXEL_TERRAIN_JOB_H +#define VOXEL_TERRAIN_JOB_H #include "voxel_job.h" @@ -33,8 +33,8 @@ include_pool_vector class VoxelMesher; -class VoxelTerrarinJob : public VoxelJob { - GDCLASS(VoxelTerrarinJob, VoxelJob); +class VoxelTerrainJob : public VoxelJob { + GDCLASS(VoxelTerrainJob, VoxelJob); public: //Meshers @@ -52,10 +52,10 @@ public: int get_liquid_mesher_count() const; void phase_setup(); - void phase_terrarin_mesh_setup(); + void phase_terrain_mesh_setup(); void phase_collider(); void phase_physics_proces(); - void phase_terrarin_mesh(); + void phase_terrain_mesh(); void phase_finalize(); void phase_physics_process(); @@ -63,8 +63,8 @@ public: void _reset(); void _physics_process(float delta); - VoxelTerrarinJob(); - ~VoxelTerrarinJob(); + VoxelTerrainJob(); + ~VoxelTerrainJob(); protected: static void _bind_methods(); diff --git a/world/marching_cubes/voxel_world_marching_cubes.cpp b/world/marching_cubes/voxel_world_marching_cubes.cpp index 8c80c1b..0c6fa25 100644 --- a/world/marching_cubes/voxel_world_marching_cubes.cpp +++ b/world/marching_cubes/voxel_world_marching_cubes.cpp @@ -27,7 +27,7 @@ SOFTWARE. #include "../../meshers/marching_cubes/voxel_mesher_marching_cubes.h" #include "../jobs/voxel_light_job.h" #include "../jobs/voxel_prop_job.h" -#include "../jobs/voxel_terrarin_job.h" +#include "../jobs/voxel_terrain_job.h" Ref VoxelWorldMarchingCubes::_create_chunk(int x, int y, int z, Ref chunk) { if (!chunk.is_valid()) { @@ -35,14 +35,14 @@ Ref VoxelWorldMarchingCubes::_create_chunk(int x, int y, int z, Ref< } if (chunk->job_get_count() == 0) { - Ref tj; - tj.instance(); + Ref tj; + tj.INSTANCE(); Ref lj; - lj.instance(); + lj.INSTANCE(); Ref pj; - pj.instance(); + pj.INSTANCE(); pj->set_prop_mesher(Ref(memnew(VoxelMesherMarchingCubes))); Ref m = Ref(memnew(VoxelMesherMarchingCubes())); diff --git a/world/voxel_chunk.cpp b/world/voxel_chunk.cpp index 22fbfdb..e5351a6 100644 --- a/world/voxel_chunk.cpp +++ b/world/voxel_chunk.cpp @@ -188,10 +188,10 @@ _FORCE_INLINE_ void VoxelChunk::set_margin_end(const int value) { _margin_end = value; } -Ref VoxelChunk::get_library() { +Ref VoxelChunk::get_library() { return _library; } -void VoxelChunk::set_library(const Ref &value) { +void VoxelChunk::set_library(const Ref &value) { _library = value; } @@ -905,7 +905,11 @@ int VoxelChunk::mesh_data_resource_get_count() const { void VoxelChunk::mesh_data_resource_remove(const int index) { ERR_FAIL_INDEX(index, _mesh_data_resources.size()); +#if VERSION_MAJOR < 4 _mesh_data_resources.remove(index); +#else + _mesh_data_resources.remove_at(index); +#endif } void VoxelChunk::mesh_data_resource_clear() { _mesh_data_resources.clear(); @@ -1379,7 +1383,11 @@ void VoxelChunk::_bind_methods() { ClassDB::bind_method(D_METHOD("get_transform"), &VoxelChunk::get_transform); ClassDB::bind_method(D_METHOD("set_transform", "value"), &VoxelChunk::set_transform); +#if VERSION_MAJOR < 4 ADD_PROPERTY(PropertyInfo(Variant::TRANSFORM, "transform"), "set_transform", "get_transform"); +#else + ADD_PROPERTY(PropertyInfo(Variant::TRANSFORM3D, "transform"), "set_transform", "get_transform"); +#endif ClassDB::bind_method(D_METHOD("get_visible"), &VoxelChunk::get_visible); ClassDB::bind_method(D_METHOD("set_visible", "value"), &VoxelChunk::set_visible); @@ -1450,7 +1458,7 @@ void VoxelChunk::_bind_methods() { ClassDB::bind_method(D_METHOD("get_library"), &VoxelChunk::get_library); ClassDB::bind_method(D_METHOD("set_library", "value"), &VoxelChunk::set_library); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "library", PROPERTY_HINT_RESOURCE_TYPE, "VoxelmanLibrary"), "set_library", "get_library"); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "library", PROPERTY_HINT_RESOURCE_TYPE, "VoxelLibrary"), "set_library", "get_library"); ClassDB::bind_method(D_METHOD("get_voxel_scale"), &VoxelChunk::get_voxel_scale); ClassDB::bind_method(D_METHOD("set_voxel_scale", "value"), &VoxelChunk::set_voxel_scale); diff --git a/world/voxel_chunk.h b/world/voxel_chunk.h index 10a05e7..bfd7e9d 100644 --- a/world/voxel_chunk.h +++ b/world/voxel_chunk.h @@ -68,7 +68,7 @@ include_pool_vector #endif #include "../library/voxel_surface.h" -#include "../library/voxelman_library.h" +#include "../library/voxel_library.h" ; //hackfix for a clang format issue class VoxelJob; @@ -144,8 +144,8 @@ public: void set_margin_start(const int value); void set_margin_end(const int value); - Ref get_library(); - void set_library(const Ref &value); + Ref get_library(); + void set_library(const Ref &value); float get_voxel_scale() const; void set_voxel_scale(const float value); @@ -402,7 +402,7 @@ protected: int _current_job; Vector> _jobs; - Ref _library; + Ref _library; Vector> _voxel_structures; diff --git a/world/voxel_world.cpp b/world/voxel_world.cpp index 8668709..e55979f 100644 --- a/world/voxel_world.cpp +++ b/world/voxel_world.cpp @@ -122,10 +122,10 @@ void VoxelWorld::set_max_frame_chunk_build_steps(const int value) { _max_frame_chunk_build_steps = value; } -Ref VoxelWorld::get_library() { +Ref VoxelWorld::get_library() { return _library; } -void VoxelWorld::set_library(const Ref &library) { +void VoxelWorld::set_library(const Ref &library) { _library = library; for (int i = 0; i < chunk_get_count(); ++i) { @@ -138,10 +138,10 @@ void VoxelWorld::set_library(const Ref &library) { } } -Ref VoxelWorld::get_level_generator() const { +Ref VoxelWorld::get_level_generator() const { return _level_generator; } -void VoxelWorld::set_level_generator(const Ref &level_generator) { +void VoxelWorld::set_level_generator(const Ref &level_generator) { _level_generator = level_generator; } @@ -667,7 +667,11 @@ void VoxelWorld::prop_add(Transform tarnsform, const Ref &prop, const if (light_data.is_valid()) { Ref light; +#if VERSION_MAJOR < 4 light.instance(); +#else + light.instantiate(); +#endif light->set_world_position(wp.x / get_voxel_scale(), wp.y / get_voxel_scale(), wp.z / get_voxel_scale()); light->set_color(light_data->get_light_color()); @@ -684,8 +688,9 @@ void VoxelWorld::prop_add(Transform tarnsform, const Ref &prop, const if (mesh_data.is_valid()) { Ref mdr = mesh_data->get_mesh(); - if (!mdr.is_valid()) + if (!mdr.is_valid()) { continue; + } chunk->mesh_data_resource_add(t, mdr, mesh_data->get_texture()); @@ -1159,11 +1164,11 @@ void VoxelWorld::_bind_methods() { ClassDB::bind_method(D_METHOD("get_library"), &VoxelWorld::get_library); ClassDB::bind_method(D_METHOD("set_library", "library"), &VoxelWorld::set_library); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "library", PROPERTY_HINT_RESOURCE_TYPE, "VoxelmanLibrary"), "set_library", "get_library"); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "library", PROPERTY_HINT_RESOURCE_TYPE, "VoxelLibrary"), "set_library", "get_library"); ClassDB::bind_method(D_METHOD("get_level_generator"), &VoxelWorld::get_level_generator); ClassDB::bind_method(D_METHOD("set_level_generator", "level_generator"), &VoxelWorld::set_level_generator); - ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "level_generator", PROPERTY_HINT_RESOURCE_TYPE, "VoxelmanLevelGenerator"), "set_level_generator", "get_level_generator"); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "level_generator", PROPERTY_HINT_RESOURCE_TYPE, "VoxelLevelGenerator"), "set_level_generator", "get_level_generator"); ClassDB::bind_method(D_METHOD("get_voxel_scale"), &VoxelWorld::get_voxel_scale); ClassDB::bind_method(D_METHOD("set_voxel_scale", "value"), &VoxelWorld::set_voxel_scale); diff --git a/world/voxel_world.h b/world/voxel_world.h index 4018a34..e18ac2d 100644 --- a/world/voxel_world.h +++ b/world/voxel_world.h @@ -38,8 +38,8 @@ SOFTWARE. #include navigation_h #include "../areas/world_area.h" -#include "../level_generator/voxelman_level_generator.h" -#include "../library/voxelman_library.h" +#include "../level_generator/voxel_level_generator.h" +#include "../library/voxel_library.h" #include "core/os/os.h" @@ -94,11 +94,11 @@ public: int get_max_frame_chunk_build_steps() const; void set_max_frame_chunk_build_steps(const int value); - Ref get_library(); - void set_library(const Ref &library); + Ref get_library(); + void set_library(const Ref &library); - Ref get_level_generator() const; - void set_level_generator(const Ref &level_generator); + Ref get_level_generator() const; + void set_level_generator(const Ref &level_generator); float get_voxel_scale() const; void set_voxel_scale(const float value); @@ -262,8 +262,8 @@ private: int _data_margin_start; int _data_margin_end; - Ref _library; - Ref _level_generator; + Ref _library; + Ref _level_generator; float _voxel_scale; int _chunk_spawn_range; diff --git a/world/voxel_world_editor.cpp b/world/voxel_world_editor.cpp index 12de830..7a95065 100644 --- a/world/voxel_world_editor.cpp +++ b/world/voxel_world_editor.cpp @@ -34,7 +34,7 @@ SOFTWARE. #include "voxel_chunk.h" #include "../library/voxel_surface.h" -#include "../library/voxelman_library.h" +#include "../library/voxel_library.h" #include "../defines.h" @@ -52,7 +52,7 @@ bool VoxelWorldEditor::forward_spatial_input_event(Camera *p_camera, const Refis_pressed()) { - Ref lib = _world->get_library(); + Ref lib = _world->get_library(); if (!lib.is_valid()) return false; @@ -79,7 +79,7 @@ EditorPlugin::AfterGUIInput VoxelWorldEditor::forward_spatial_input_event(Camera if (mb.is_valid()) { if (mb->is_pressed()) { - Ref lib = _world->get_library(); + Ref lib = _world->get_library(); if (!lib.is_valid()) return EditorPlugin::AFTER_GUI_INPUT_PASS; @@ -184,7 +184,7 @@ void VoxelWorldEditor::edit(VoxelWorld *p_world) { } } - Ref library = _world->get_library(); + Ref library = _world->get_library(); if (!library.is_valid()) return; @@ -268,9 +268,9 @@ VoxelWorldEditor::VoxelWorldEditor(EditorNode *p_editor) { add_button->CONNECT("button_up", this, VoxelWorldEditor, _on_tool_button_pressed); #if VERSION_MAJOR < 4 - add_button->set_shortcut(ED_SHORTCUT("voxelman_world_editor/add_mode", "Add Mode", KEY_A)); + add_button->set_shortcut(ED_SHORTCUT("voxel_world_editor/add_mode", "Add Mode", KEY_A)); #else - add_button->set_shortcut(ED_SHORTCUT("voxelman_world_editor/add_mode", "Add Mode", Key::A)); + add_button->set_shortcut(ED_SHORTCUT("voxel_world_editor/add_mode", "Add Mode", Key::A)); #endif spatial_editor_hb->add_child(add_button); @@ -284,9 +284,9 @@ VoxelWorldEditor::VoxelWorldEditor(EditorNode *p_editor) { remove_button->CONNECT("button_up", this, VoxelWorldEditor, _on_tool_button_pressed); #if VERSION_MAJOR < 4 - remove_button->set_shortcut(ED_SHORTCUT("voxelman_world_editor/remove_mode", "Remove Mode", KEY_S)); + remove_button->set_shortcut(ED_SHORTCUT("voxel_world_editor/remove_mode", "Remove Mode", KEY_S)); #else - remove_button->set_shortcut(ED_SHORTCUT("voxelman_world_editor/remove_mode", "Remove Mode", Key::S)); + remove_button->set_shortcut(ED_SHORTCUT("voxel_world_editor/remove_mode", "Remove Mode", Key::S)); #endif spatial_editor_hb->add_child(remove_button); @@ -297,9 +297,9 @@ VoxelWorldEditor::VoxelWorldEditor(EditorNode *p_editor) { insert_buton->CONNECT("button_up", this, VoxelWorldEditor, _on_insert_block_at_camera_button_pressed); #if VERSION_MAJOR < 4 - insert_buton->set_shortcut(ED_SHORTCUT("voxelman_world_editor/instert_block_at_camera", "Insert at camera", KEY_B)); + insert_buton->set_shortcut(ED_SHORTCUT("voxel_world_editor/instert_block_at_camera", "Insert at camera", KEY_B)); #else - insert_buton->set_shortcut(ED_SHORTCUT("voxelman_world_editor/instert_block_at_camera", "Insert at camera", Key::B)); + insert_buton->set_shortcut(ED_SHORTCUT("voxel_world_editor/instert_block_at_camera", "Insert at camera", Key::B)); #endif spatial_editor_hb->add_child(insert_buton); @@ -410,7 +410,7 @@ void VoxelWorldEditor::_bind_methods() { void VoxelWorldEditorPlugin::_notification(int p_what) { if (p_what == EditorSettings::NOTIFICATION_EDITOR_SETTINGS_CHANGED) { - switch ((int)EditorSettings::get_singleton()->get("editors/voxelman/editor_side")) { + switch ((int)EditorSettings::get_singleton()->get("editors/voxel/editor_side")) { #if VERSION_MAJOR <= 3 && VERSION_MINOR < 5 case 0: { // Left. SpatialEditor::get_singleton()->get_palette_split()->move_child(voxel_world_editor, 0); @@ -459,11 +459,11 @@ void VoxelWorldEditorPlugin::make_visible(bool p_visible) { VoxelWorldEditorPlugin::VoxelWorldEditorPlugin(EditorNode *p_node) { editor = p_node; - EDITOR_DEF("editors/voxelman/editor_side", 1); - EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::INT, "editors/voxelman/editor_side", PROPERTY_HINT_ENUM, "Left,Right")); + EDITOR_DEF("editors/voxel/editor_side", 1); + EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::INT, "editors/voxel/editor_side", PROPERTY_HINT_ENUM, "Left,Right")); voxel_world_editor = memnew(VoxelWorldEditor(editor)); - switch ((int)EditorSettings::get_singleton()->get("editors/voxelman/editor_side")) { + switch ((int)EditorSettings::get_singleton()->get("editors/voxel/editor_side")) { case 0: { // Left. add_control_to_container(CONTAINER_SPATIAL_EDITOR_SIDE_LEFT, voxel_world_editor); } break; diff --git a/world/voxel_world_editor.h b/world/voxel_world_editor.h index 0329405..9763069 100644 --- a/world/voxel_world_editor.h +++ b/world/voxel_world_editor.h @@ -101,10 +101,10 @@ protected: public: #if VERSION_MAJOR < 4 - bool forward_spatial_input_event(Camera *p_camera, const Ref &p_event); + bool forward_spatial_input_event(Camera *p_camera, const Ref &p_event) { return voxel_world_editor->forward_spatial_input_event(p_camera, p_event); } virtual bool forward_spatial_gui_input(int p_index, Camera *p_camera, const Ref &p_event) { return voxel_world_editor->forward_spatial_input_event(p_camera, p_event); } #else - EditorPlugin::AfterGUIInput forward_spatial_input_event(Camera *p_camera, const Ref &p_event); + EditorPlugin::AfterGUIInput forward_spatial_input_event(Camera *p_camera, const Ref &p_event) { return voxel_world_editor->forward_spatial_input_event(p_camera, p_event); } virtual EditorPlugin::AfterGUIInput forward_spatial_gui_input(int p_index, Camera *p_camera, const Ref &p_event) { return voxel_world_editor->forward_spatial_input_event(p_camera, p_event); } #endif virtual String get_name() const { return "VoxelWorldEditor"; }