cube_sphere.gd

Raw Download Revise
# cube_sphere.gd

@tool

extends MeshInstance3D

@export_group("sphere")

@export_range(2, 256) var resolution: int = 16:

    set(value):

        resolution = value

        if is_inside_tree():

            _generate_surface()

@export_range(1, 12) var subdivisions: int = 1:

    set(value):

        subdivisions = value

        if is_inside_tree():

            _generate_surface()

@export_range (0.1, 100.0) var radius: float = 1.0:

    set(value):

        radius = value

        if is_inside_tree():

            _generate_surface()

@export var debug_mode = false:

    set(value):

        debug_mode = value

        if is_inside_tree():

            _generate_surface()

@export var wireframe_mode = false:

    set(value):

        wireframe_mode = value

        _update_material()

@export var use_terrain_shader = false:

    set(value):

        use_terrain_shader = value

        _update_material()

@export var use_world_shader = true:

    set(value):

        use_world_shader = value

        _update_material()

@export var heightmap: Texture2D:

    set(value):

        heightmap = value

        if is_inside_tree():

            _update_material()

@export var earth_texture: Texture2D:

    set(value):

        earth_texture = value

        if is_inside_tree():

            _update_material()

@export_range(0.0, 0.2) var height_scale: float = 0.02:

    set(value):

        height_scale = value

        if is_inside_tree():

            _update_material()

@export var show_height_debug: bool = false:

    set(value):

        show_height_debug = value

        if is_inside_tree():

            _update_material()

func _ready():

    # generate mesh on game start

    _generate_surface()

    _update_material()

func _generate_surface():

    # if new mesh > create arraymesh for it

    if not mesh:

        mesh = ArrayMesh.new()

    # start with clean slate

    mesh.clear_surfaces()

    # arrays for mesh construction

    var verts = PackedVector3Array()

    var uvs = PackedVector2Array()

    var normals = PackedVector3Array()

    var indices = PackedInt32Array()

    var colors = PackedColorArray()

    # mesh generation code : 6 faces of cube

    var face_normals = [

        Vector3.UP,

        Vector3.DOWN,

        Vector3.LEFT,

        Vector3.RIGHT,

        Vector3.FORWARD,

        Vector3.BACK,

    ]

    var face_colors = [

        Color.CORAL,

        Color.DARK_OLIVE_GREEN,

        Color.AQUAMARINE,

        Color.DODGER_BLUE,

        Color.LIGHT_SALMON,

        Color.LIGHT_GREEN,

    ]

    var face_coverage_per_subface = 1.0 / subdivisions

    # debug

    if debug_mode:

        print("\n--- mesh generation start ---")

        print("resolution : ", resolution)

        print("subdivisions : ", subdivisions)

        print("radius : ", radius)

        print("facecoveragepersubface : ", face_coverage_per_subface)

    # generate 6 faces

    for face_index in range(face_normals.size()):

        var normal_dir = face_normals[face_index]

        var current_face_color = face_colors[face_index]

        if debug_mode:

            print("\n--- face ", face_index,

            " | normal : ", normal_dir,

            " ---")

        for y in range(subdivisions):

            for x in range(subdivisions):

                var start_uv = Vector2(x, y) * face_coverage_per_subface

                var end_uv = start_uv + Vector2.ONE * face_coverage_per_subface

                #breakpoint

                if debug_mode and face_index == 0 and x == 0 and y == 0:

                    print(

                        "  1st subface - startuv : ", start_uv,

                        " | enduv : ", end_uv)

                _create_face(

                    normal_dir,

                    start_uv, 

                    end_uv,

                    verts,

                    normals,

                    uvs,

                    indices,

                    colors, 

                    current_face_color,

                    #face_index == 0 and x == 0 and y == 0 # debug 1st subface only

                    )

    # assemble final mesh data 

    var surface_array = []

    surface_array.resize(Mesh.ARRAY_MAX)

    # assign arrays to surface array

    surface_array[Mesh.ARRAY_VERTEX] = verts

    surface_array[Mesh.ARRAY_TEX_UV] = uvs

    surface_array[Mesh.ARRAY_NORMAL] = normals

    surface_array[Mesh.ARRAY_INDEX] = indices

    surface_array[Mesh.ARRAY_COLOR] = colors

    # add surface to mesh 

    mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, surface_array)

    if debug_mode:

        print("\n--- mesh generation done ---")

        print("totalvertices : ", verts.size())

        print("totalindices : ", indices.size())

    _update_material()

    # save mesh to .tres file to be reused (need be not re-generated, like

    # global resource ? ie world globe map as game ui entry into game levels /

    # individual world countries ...

    ResourceSaver.save(mesh, "res://sphere.tres", ResourceSaver.FLAG_COMPRESS)

func _update_material():

    if not mesh or mesh.get_surface_count() == 0:

        return

    var shader_mat = ShaderMaterial.new()

    if wireframe_mode:

        # wireframe material

        shader_mat.shader = load("res://shaders/wireframe.gdshader")

    elif use_world_shader:

        # world shader with heightmap and earth texture

        shader_mat.shader = load("res://shaders/world.gdshader")

        if heightmap:

            shader_mat.set_shader_parameter("height_map", heightmap)

        if earth_texture:

            shader_mat.set_shader_parameter("earth_texture", earth_texture)

        shader_mat.set_shader_parameter("height_scale", height_scale)

        shader_mat.set_shader_parameter("apply_height", true)

        shader_mat.set_shader_parameter("show_height_debug", show_height_debug)

    elif use_terrain_shader:

        # cartoon shader : color per height

        shader_mat.shader = load("res://shaders/terrain.gdshader")

        if heightmap:

            shader_mat.set_shader_parameter("height_map", heightmap)

        shader_mat.set_shader_parameter("height_scale", height_scale)

        shader_mat.set_shader_parameter("apply_height", true)

        shader_mat.set_shader_parameter("show_height_debug", show_height_debug)

    else:

        # default: color faces

        shader_mat.shader = load("res://shaders/color_faces.gdshader")

    set_surface_override_material(0, shader_mat)

func _create_face(

    p_normal: Vector3,

    p_start_uv: Vector2,

    p_end_uv: Vector2,

    p_verts: PackedVector3Array,

    p_normals: PackedVector3Array,

    p_uvs: PackedVector2Array,

    p_indices: PackedInt32Array,

    p_colors: PackedColorArray,

    p_face_color: Color,

    ):

        # create 2 axes perpendicular to face normal

        var axis_a = Vector3(p_normal.y, p_normal.z, p_normal.x)

        var axis_b = p_normal.cross(axis_a)

        if debug_mode:

            print("\n createface called")

            print("\n normal : ", p_normal)

            print("\n axisa : ", axis_a)

            print("\n axisb : ", axis_b)

            print("\n startuv : ", p_start_uv)

            print("\n enduv : ", p_end_uv)

        # get number of vertices we have

        var base_vertex_index = p_verts.size()

        # calculate step sizes

        var dx = (p_end_uv.x - p_start_uv.x) / (resolution - 1)

        var dy = (p_end_uv.y - p_start_uv.y) / (resolution - 1)

#        breakpoint

        if debug_mode:

            print(" dx : ", dx, " dy : ", dy)

            print(" basevertexindex : ", base_vertex_index)

        # start position

        var ty = p_start_uv.y

        # loop through grid of vertices

        for y in range(resolution):

            var tx = p_start_uv.x

            for x in range(resolution):

                var i = x + y * resolution

                #breakpoint

                # map cube point onto a unit sphere

                var point_on_unit_cube = p_normal \

                    + (tx - 0.5) * 2.0 * axis_a \

                    + (ty - 0.5) * 2.0 * axis_b

                # map to sphere

                var point_on_unit_sphere = _cube_point_to_sphere_point(

                    point_on_unit_cube)

                # final vertex position

                var final_vertex = point_on_unit_sphere * radius

                #breakpoint

                # debug 1st 4 corners & middle, prevent known result warning

                @warning_ignore("integer_division")

                var mid_point := resolution / 2

                if debug_mode and (

                    (x == 0 and y == 0) or # top-left

                    (x == resolution - 1 and y ==0) or # top-right

                    (x == 0 and y == resolution - 1) or # bottom-left

                    (x == resolution - 1 and y == resolution - 1) or # bottom-right

                    (x == mid_point and y == mid_point) # middle

                ):

                    print("\n vertex ", x, "-", y, " i=", i)

                    print("\n tx : ", tx, " ty : ", ty)

                    print("\n pointoncube : ", point_on_unit_cube)

                    print("\n pointonsphere : ", point_on_unit_sphere)

                    print("\n finalvertex : ", final_vertex)

                # add vertex and normal

                p_verts.push_back(final_vertex)

                #p_verts.push_back(point_on_unit_sphere * radius)

                p_normals.push_back(point_on_unit_sphere)

                p_colors.push_back(p_face_color)

                # uv-based on grid position

                #var uv = Vector2(

                    #float(x) / (resolution - 1.0), 

                    #float(y) / (resolution - 1.0)

                #)

                var uv = GeoMaths.point_to_uv(point_on_unit_cube)

                # image origin is top-left : flip vertical & horizontal

                #uv.x = 1.0 - uv.x

                #uv.y = 1.0 - uv.y

                # wrap horizontal to prevent image seam todo not working

                #uv.x = uv.x - floor(uv.x)

                p_uvs.push_back(uv)

                # create 2 tris for quad

                if x != resolution - 1 and y != resolution - 1:

                    # 1st tris

                    p_indices.push_back(base_vertex_index + i)

                    p_indices.push_back(base_vertex_index + i + resolution)

                    p_indices.push_back(base_vertex_index + i + resolution + 1)

                    # 2nd tris

                    p_indices.push_back(base_vertex_index + i)

                    p_indices.push_back(base_vertex_index + i + resolution + 1)

                    p_indices.push_back(base_vertex_index + i + 1)

                tx += dx

            ty += dy

## maps a point on a unit cube to a point on a unit sphere

# http://mathproofs.blogspot.com/2005/ 07/mapping-cube-to-sphere.html

func _cube_point_to_sphere_point(p: Vector3) -> Vector3:

    var x2 = p.x * p.x / 2.0

    var y2 = p.y * p.y / 2.0

    var z2 = p.z * p.z / 2.0

    var x = p.x * sqrt(1.0 - y2 - z2 + (p.y * p.y * p.z * p.z) / 3.0)

    var y = p.y * sqrt(1.0 - z2 - x2 + (p.x * p.x * p.z * p.z) / 3.0)

    var z = p.z * sqrt(1.0 - x2 - y2 + (p.x * p.x * p.y * p.y) / 3.0)

    return Vector3(x, y, z)