Godot 3D Real Time Rope Mesh Generator V.0

#contains unused code
#also split between 2 scripts: first one is character controller and second one rope generation
#PLAYER MOVEMENT SCRIPT------------------
extends CharacterBody3D

enum WalkState{
    NORMAL,
    SPRINT,
    CROUCH,
    PRONE,
    SLIDE,
    JETPACK
}

#movement attribute values
const TARGET_LERP = .8
const JETPACK_TARGER_LERP = .6

const SPRINT_SPEED = 10.0
const SPRINT_LERP_ACC = 2.0
const SPRINT_LERP_DEC = 8.0

const WALK_SPEED = 6.0
const WALK_LERP_ACC = 3.5
const WALK_LERP_DEC = 10.0

const CROUCH_SPEED = 3.0
const CROUCH_LERP_ACC = 8.0
const CROUCH_LERP_DEC = 14.0

const PRONE_SPEED = 1.5
const PRONE_LERP_ACC = 12.0
const PRONE_LERP_DEC = 22.0

const JETPACK_SPEED = 6.0
const JETPACK_LERP_ACC = 6.0
const JETPACK_LERP_DEC = 12.0
const JETPACK_VERTICAL_FORCE = 5.0
const JETPACK_VERTICAL_VELOCITY_MAX = 2.5
const JETPACK_VERTICAL_DIFFERENCE_MAX = 5.0
var current_jetpack_vertical = 0.0
const JETPACK_VELOCITY_THRESHOLD = .5
const ENERGY_MAX = 100.0
const ENERGY_DRAIN_JETPACK_START = 10
const ENERGY_DRAIN_JETPACK_MULT = 10.0
const ENERGY_DRAIN_SPRINT_MULT = 5.0
const ENERGY_REGEN_MULT = 30.0
const ENERGY_REGEN_COOLDOWN = 2.5
var current_energy_regen_cooldown = 0.0
var current_energy = ENERGY_MAX
const JETPACK_START_TIMER = 0.65
var current_jetpack_start_timer = 0

const SLIDE_SPEED = 30
const SLIDE_TIME_MAX = .7
const SLIDE_DAMPEN_RATE = .05
const SLIDE_FLAT_DAMPEN_RATE = .001
const SLOPE_SLIDE_THRESHOLD = .1
var current_slide_time = 0
var current_slide_vector : Vector3 = Vector3.ZERO

var SPRINT_CD_MAX = .2
var current_sprint_cd = 0

const FALL_SPEED_MAX = 15
const JUMP_VELOCITY = 6
const JUMP_HANG_TIME_THRESHOLD = .3
const JUMP_HANG_TIME_SPEED_MULT = 1.05
const JUMP_HANG_TIME_ACC_MULT = 3

const COYOTE_TIME_MAX = .1
var current_coyote_time = 0
const JUMP_CD_MAX = .25
var current_jump_cd = 0



# Get the gravity from the project settings to be synced with RigidBody nodes.
var gravity_default = ProjectSettings.get_setting("physics/3d/default_gravity")
var gravity_falling = 2 * gravity_default
var gravity_hang_time = .5 * gravity_default
var current_gravity = gravity_default

@export var camera_sensitivity = .25

var input_dir = Vector2.ZERO
var direction = Vector3.ZERO

@onready var collider = $Collider
const COLLIDER_HEIGHT_NORMAL = 2
const COLLIDER_HEIGHT_CROUCH = 1.1
const COLLIDER_HEIGHT_PRONE = .5

const CAMERA_HEIGHT_NORMAL = 1.8
const CAMERA_HEIGHT_CROUCH = .9
const CAMERA_HEIGHT_PRONE = .3

const HEAD_BOB_INTENSITY_SPRINT = .15
const HEAD_BOB_INTENSITY_NORMAL = .12
const HEAD_BOB_INTENSITY_CROUCH = .08
const HEAD_BOB_INTENSITY_PRONE = .04

const HEAD_BOB_FREQUENCY_SPRINT = 18
const HEAD_BOB_FREQUENCY_NORMAL = 14
const HEAD_BOB_FREQUENCY_CROUCH = 10
const HEAD_BOB_FREQUENCY_PRONE = 8

const HEAD_BOB_LERP_RATE = 50

var head_bob_var = 0
var is_head_bob_active = true
var current_head_bob_intensity = 0
var current_head_bob_frequency = 0

const CAMERA_LERP = 10
const CAMERA_FOV_NORMAL = 70.0
const CAMERA_FOV_MAX_SPEED = 100.0

@onready var camera_pivot = $CameraPivot
@onready var debug_label = $DebugLabel
@onready var energy_bar = $EnergyBar
@onready var energy_bar_bar = $EnergyBar/Bar
@onready var energy_bar_label = $EnergyBar/Bar/Label
@onready var height_raycast = $HeightRaycast
@onready var camera_3d = $CameraPivot/HeadBobPivot/Camera3D
@onready var head_bob_pivot = $CameraPivot/HeadBobPivot
@onready var jetpack_stream = $jetpackStream
@onready var camera_cast = $CameraPivot/HeadBobPivot/Camera3D/CameraCast

var current_max_speed : float = 0
var current_lerp_acc : float = 0
var current_lerp_dec : float = 0
var current_camera_height : float = 0


const JETPACK_VOLUME_LERP_MULT = 5
const JETPACK_STREAM_STOP_THRESHOLD = .01

var current_walk_state : WalkState = WalkState.NORMAL


var grapple_hook_position : Vector3 = Vector3.ZERO
var grapple_raycast_hit = null
const GRAPPLE_RAY_MAX = 50.0
const GRAPPLE_FORCE_MAX = 75.0
var is_grappling = false
@onready var grapple_mesh = $RopePivot/mesh
@onready var grapple_pivot = $RopePivot

@onready var rope_generator = $RopeGenerator



var floor_angle

var debug = null
var debug1 = null
var debug2 = null
var debug3 = null

func _ready():
    Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
    _UpdateCollider()
    debug =  get_tree().root.get_node("ROOT/raycasts")
    debug1 = debug.get_node("DebugRaycast")
    debug2 = debug.get_node("DebugRaycast2")
    debug3 = debug.get_node("DebugRaycast3")
    floor_angle = 0

    camera_cast.set_target_position(Vector3(0, 0, -1 * GRAPPLE_RAY_MAX))

    energy_bar_bar.min_value = 0
    energy_bar_bar.max_value = ENERGY_MAX
    _UpdateEnergyLabel()

func _input(event):
    if event is InputEventMouseMotion:
        rotate_y(deg_to_rad(camera_sensitivity * -event.relative.x))
        camera_pivot.rotate_x(deg_to_rad(camera_sensitivity * -event.relative.y))
        camera_pivot.rotation.x = clamp(camera_pivot.rotation.x, deg_to_rad(-89), deg_to_rad(89))


func _process(delta):
    input_dir = Input.get_vector("left", "right", "forward", "back")

    direction = transform.basis * Vector3(input_dir.x, 0, input_dir.y).normalized()

    if WalkState.SLIDE != current_walk_state && WalkState.JETPACK != current_walk_state:
        if Input.is_action_pressed("prone") && is_on_floor():
            if current_walk_state != WalkState.PRONE:
                current_walk_state = WalkState.PRONE
                _UpdateCollider()
        elif Input.is_action_pressed("crouch") and !height_raycast.is_colliding() && is_on_floor():
            if current_walk_state != WalkState.CROUCH:
                if current_sprint_cd > 0:
                    current_walk_state = WalkState.SLIDE
                    current_slide_time = SLIDE_TIME_MAX
                    current_slide_vector = abs(velocity) * direction
                    current_slide_vector.y = 0
                    _UpdateCollider()
                else:
                    current_walk_state = WalkState.CROUCH
                    _UpdateCollider()
        elif !height_raycast.is_colliding():
            if current_walk_state == WalkState.PRONE:
                current_walk_state = WalkState.CROUCH
                _UpdateCollider()
            elif Input.is_action_pressed("sprint"):
                current_sprint_cd = SPRINT_CD_MAX
                if current_walk_state != WalkState.SPRINT:
                    current_walk_state = WalkState.SPRINT
                    _UpdateCollider()
            elif current_walk_state != WalkState.NORMAL:
                current_walk_state = WalkState.NORMAL
                _UpdateCollider()

    floor_angle = get_floor_angle()


    _UpdateEnergyLabel()


func _physics_process(delta):
    grapple_raycast_hit = camera_cast.get_collider()
    if grapple_raycast_hit:
        $ColorRect.color = "#DDDDDD99"
    else:
        $ColorRect.color = "#22222255"
    if Input.is_action_just_pressed("grapple"):
        if grapple_raycast_hit:
            grapple_hook_position = camera_cast.get_collision_point()
            is_grappling = true
            grapple_mesh.visible = true
            rope_generator.SetPlayerPosition(position)
            rope_generator.SetGrappleHookPosition(grapple_hook_position)
            rope_generator.StartDrawing()
            rope_generator.visible = true
        else:
            is_grappling = false
    elif Input.is_action_just_released("grapple"):
        grapple_mesh.visible = false
        rope_generator.StopDrawing()
        rope_generator.visible = false


    if is_grappling && Input.is_action_pressed("grapple"):
        rope_generator.SetPlayerPosition(position)
        $ColorRect.color = "#FF555599"
        grapple_pivot.look_at(grapple_hook_position)

        var grapple_direction = (grapple_hook_position - position).normalized()
        var grapple_target_speed = grapple_direction * GRAPPLE_FORCE_MAX

        var grapple_dif = (grapple_target_speed - velocity)
#       grapple_dif = lerp(velocity, grapple_dif, .8)

        velocity += grapple_dif * delta
#       current_gravity = 0

#       if position.y < grapple_hook_position.y:
#           current_gravity = -gravity_hang_time
#       else:
#           current_gravity = gravity_default

    if WalkState.SLIDE == current_walk_state:
        if current_slide_time > 0:
            if floor_angle < SLOPE_SLIDE_THRESHOLD || velocity.y > 0:
                current_slide_time -= delta
                current_slide_time = clamp(current_slide_time, 0, SLIDE_TIME_MAX)

        else:
            current_walk_state = WalkState.CROUCH
            _UpdateCollider()

    if current_sprint_cd > 0:
        current_sprint_cd -= delta

    #calc target speed based on current input
    var target_speed : Vector3 = direction * current_max_speed

    var current_acc_rate : Vector3 = Vector3.ZERO
    if input_dir:
        current_acc_rate = Vector3(current_lerp_acc,
                0,
                current_lerp_acc)
    else:
        current_acc_rate = Vector3(current_lerp_dec,
            0,
            current_lerp_dec)


    #lerp the target speed for smoother change
    #if the movement is in the same direction make the target closer to the current velocity
    #otherwise, since direction shift is required make the target closer to actual target
    #if player is faster than top speed don't slow down on X and Z axis
    if (target_speed.x != 0 &&
        abs(velocity.x) >= abs(target_speed.x) &&
        sign(velocity.x) == sign(target_speed.x)):

        target_speed.x = lerp(velocity.x, target_speed.x, 1-TARGET_LERP)
    else:
        target_speed.x = lerp(velocity.x, target_speed.x, TARGET_LERP)

    if (target_speed.z != 0 &&
        abs(velocity.z) >= abs(target_speed.z) &&
        sign(velocity.z) == sign(target_speed.z)):

        target_speed.z = lerp(velocity.z, target_speed.z, 1-TARGET_LERP)
    else:
        target_speed.z = lerp(velocity.z, target_speed.z, TARGET_LERP)

    #Handle jetpack
    if Input.is_action_pressed("jump"):
        current_jetpack_start_timer += delta
        current_jetpack_start_timer = min(current_jetpack_start_timer, JETPACK_START_TIMER)
    elif Input.is_action_just_released("jump"):
        current_jetpack_start_timer = 0

    if current_walk_state != WalkState.JETPACK:
        if current_energy_regen_cooldown >= ENERGY_REGEN_COOLDOWN:
            current_energy += delta * ENERGY_REGEN_MULT
            current_energy = min(current_energy, ENERGY_MAX)
        else:
            current_energy_regen_cooldown += delta

        if current_energy > ENERGY_DRAIN_JETPACK_START && (
            current_jetpack_start_timer >= JETPACK_START_TIMER ||
            (Input.is_action_just_pressed("jump") &&
            abs(velocity.y) > JETPACK_VELOCITY_THRESHOLD)):
            current_walk_state = WalkState.JETPACK
            _UpdateCollider()
            jetpack_stream.volume_db = linear_to_db(0.00)
            jetpack_stream.play()
            current_energy -= ENERGY_DRAIN_JETPACK_START

    if current_walk_state != WalkState.JETPACK:
        if jetpack_stream.playing:
            jetpack_stream.volume_db = linear_to_db(lerp(
                db_to_linear(jetpack_stream.volume_db),
                0.0,
                JETPACK_VOLUME_LERP_MULT * delta
            ))
            if linear_to_db(JETPACK_STREAM_STOP_THRESHOLD) >= jetpack_stream.volume_db:
                jetpack_stream.volume_db = linear_to_db(0)
                jetpack_stream.stop()

        # Handle Jump.
        if Input.is_action_just_released("jump") and velocity.y > 0:
            current_jump_cd = 0
            velocity.y = velocity.y / 2.0
#           current_gravity = gravity_falling
        elif current_coyote_time > 0 && (
            Input.is_action_just_pressed("jump") || current_jump_cd > 0):
            current_jump_cd = JUMP_CD_MAX
            current_coyote_time = 0
            velocity.y = JUMP_VELOCITY
            if Input.is_action_pressed("sprint"): current_walk_state = WalkState.SPRINT
            else: current_walk_state = WalkState.NORMAL
            _UpdateCollider()

        if abs(velocity.y) < JUMP_HANG_TIME_THRESHOLD && !is_on_floor():
            #make the gravity weaker around apex of jump
            current_gravity = gravity_hang_time

            #increase responsiveness
            target_speed *= JUMP_HANG_TIME_SPEED_MULT
            current_acc_rate *= JUMP_HANG_TIME_ACC_MULT
        else:
            #if falling make gravity stronger
            if velocity.y < 0:
                current_gravity = gravity_falling
            else:
                current_gravity = gravity_default
    else:
        if jetpack_stream.volume_db < linear_to_db(1):
            jetpack_stream.volume_db = linear_to_db(lerp(
                db_to_linear(jetpack_stream.volume_db),
                1.0,
                JETPACK_VOLUME_LERP_MULT * delta
            ))
            jetpack_stream.volume_db = min(linear_to_db(1),
            jetpack_stream.volume_db)

        current_gravity = 0
        current_energy -= delta * ENERGY_DRAIN_JETPACK_MULT
        current_energy_regen_cooldown = 0

        var vertical_target = JETPACK_VERTICAL_VELOCITY_MAX
        vertical_target = lerp(velocity.y, vertical_target, JETPACK_TARGER_LERP)
        var vertical_difference : float = vertical_target - velocity.y

        #final force that will be applied to character
        var jetpack_movement = vertical_difference * JETPACK_VERTICAL_FORCE

        if position.y <= current_jetpack_vertical + JETPACK_VERTICAL_DIFFERENCE_MAX:
            velocity.y += jetpack_movement * delta
            velocity.y = min(velocity.y, JETPACK_VERTICAL_VELOCITY_MAX)
        else:
            velocity.y = lerp(velocity.y, 0.0, 15 * delta)


        if Input.is_action_just_released("jump") || current_energy <= 0:
            current_jetpack_start_timer = 0
            if Input.is_action_pressed("sprint"): current_walk_state = WalkState.SPRINT
            else: current_walk_state = WalkState.NORMAL
            _UpdateCollider()

    # Add the gravity.
    if not is_on_floor():
        current_coyote_time -= delta
        if current_coyote_time < 0: current_coyote_time = 0
        velocity.y -= current_gravity * delta
        current_jetpack_vertical = min(position.y, current_jetpack_vertical)
    else:
        current_jetpack_vertical = position.y
        current_coyote_time = COYOTE_TIME_MAX


    #calculate dif between max and current speed
    #ignore y axis
    var speed_difference : Vector3 = target_speed - velocity
    speed_difference.y = 0

    #final force that will be applied to character
    var movement = speed_difference * current_acc_rate

    if is_on_floor() && floor_angle > SLOPE_SLIDE_THRESHOLD:
        var plane = Plane(get_floor_normal())
        movement = plane.project(movement)
        current_slide_vector = plane.project(current_slide_vector)

    if WalkState.SLIDE == current_walk_state:
        velocity = velocity + (movement) * delta * SLIDE_DAMPEN_RATE
        velocity = velocity + current_slide_vector * delta * (current_slide_time) * (-(current_slide_vector.y) + .01)
    else:
        velocity = velocity + (movement) * delta

    if velocity.y < -FALL_SPEED_MAX:
        velocity.y = -FALL_SPEED_MAX

    current_jump_cd -= delta
    if current_jump_cd < 0: current_jump_cd = 0

    debug_label.text = "State: " + WalkState.keys()[current_walk_state] + "\n" + str(velocity.length()) + "\n" + (
        "Vertical:" + str(velocity.y)) + "\nJetpack: " + str(current_energy) + (
        "\nGravity: " + str(current_gravity)) + "\nVolume: " + str(jetpack_stream.volume_db)

    _UpdateCameraPosition(delta, inverse_lerp(0, abs(SPRINT_SPEED), velocity.length()))
    move_and_slide()

func _UpdateCameraPosition(delta, speed_t):
    var t = CAMERA_LERP * delta

    if WalkState.SLIDE == current_walk_state:
        camera_3d.rotation.z = lerp(camera_3d.rotation.z, deg_to_rad(15.0), t)
    else:
        camera_3d.rotation.z = lerp(camera_3d.rotation.z, 0.0, t)

    if is_head_bob_active && WalkState.SLIDE != current_walk_state && is_on_floor() && direction != Vector3.ZERO:
        head_bob_var += current_head_bob_frequency * delta
        head_bob_pivot.position.y = lerp(
            head_bob_pivot.position.y,
            sin(head_bob_var) * current_head_bob_intensity / 2.0,
            t)
        head_bob_pivot.position.x = lerp(
            head_bob_pivot.position.x,
            cos(head_bob_var / 2.0) * current_head_bob_intensity,
            t)
    else:
        head_bob_pivot.position.y = lerp(
            head_bob_pivot.position.y,
            0.0,
            t)
        head_bob_pivot.position.x = lerp(
            head_bob_pivot.position.x,
            0.0,
            t)

    var tmp = lerp(CAMERA_FOV_NORMAL, CAMERA_FOV_MAX_SPEED, speed_t)
    camera_3d.fov = lerp(camera_3d.fov, min(tmp, CAMERA_FOV_MAX_SPEED), t)
    camera_pivot.position.y = lerp(camera_pivot.position.y, current_camera_height, t)

func _UpdateCollider():
    match current_walk_state:
        WalkState.NORMAL:
            collider.shape.height = COLLIDER_HEIGHT_NORMAL
            collider.position.y = COLLIDER_HEIGHT_NORMAL / 2.0
            height_raycast.target_position.y = COLLIDER_HEIGHT_NORMAL
            current_camera_height = CAMERA_HEIGHT_NORMAL
            current_max_speed = WALK_SPEED
            current_head_bob_frequency = HEAD_BOB_FREQUENCY_NORMAL
            current_head_bob_intensity = HEAD_BOB_INTENSITY_NORMAL
            current_lerp_acc = WALK_LERP_ACC
            current_lerp_dec = WALK_LERP_DEC
        WalkState.CROUCH:
            collider.shape.height = COLLIDER_HEIGHT_CROUCH
            collider.position.y = COLLIDER_HEIGHT_CROUCH / 2.0
            height_raycast.target_position.y = COLLIDER_HEIGHT_NORMAL
            current_camera_height = CAMERA_HEIGHT_CROUCH
            current_max_speed = CROUCH_SPEED
            current_head_bob_frequency = HEAD_BOB_FREQUENCY_CROUCH
            current_head_bob_intensity = HEAD_BOB_INTENSITY_CROUCH
            current_lerp_acc = CROUCH_LERP_ACC
            current_lerp_dec = CROUCH_LERP_DEC
        WalkState.SLIDE:
            collider.shape.height = COLLIDER_HEIGHT_CROUCH
            collider.position.y = COLLIDER_HEIGHT_CROUCH / 2.0
            height_raycast.target_position.y = COLLIDER_HEIGHT_NORMAL
            current_camera_height = CAMERA_HEIGHT_CROUCH
            current_max_speed = WALK_SPEED
            current_head_bob_frequency = HEAD_BOB_FREQUENCY_CROUCH
            current_head_bob_intensity = HEAD_BOB_INTENSITY_CROUCH
            current_lerp_acc = CROUCH_LERP_ACC
            current_lerp_dec = CROUCH_LERP_DEC
        WalkState.PRONE:
            collider.shape.height = COLLIDER_HEIGHT_PRONE
            collider.position.y = COLLIDER_HEIGHT_PRONE / 2.0
            height_raycast.target_position.y = COLLIDER_HEIGHT_CROUCH
            current_camera_height = CAMERA_HEIGHT_PRONE
            current_max_speed = PRONE_SPEED
            current_head_bob_frequency = HEAD_BOB_FREQUENCY_PRONE
            current_head_bob_intensity = HEAD_BOB_INTENSITY_PRONE
            current_lerp_acc = PRONE_LERP_ACC
            current_lerp_dec = PRONE_LERP_DEC
        WalkState.SPRINT:
            collider.shape.height = COLLIDER_HEIGHT_NORMAL
            collider.position.y = COLLIDER_HEIGHT_NORMAL / 2.0
            height_raycast.target_position.y = COLLIDER_HEIGHT_NORMAL
            current_camera_height = CAMERA_HEIGHT_NORMAL
            current_max_speed = SPRINT_SPEED
            current_head_bob_frequency = HEAD_BOB_FREQUENCY_SPRINT
            current_head_bob_intensity = HEAD_BOB_INTENSITY_SPRINT
            current_lerp_acc = SPRINT_LERP_ACC
            current_lerp_dec = SPRINT_LERP_DEC
        WalkState.JETPACK:
            collider.shape.height = COLLIDER_HEIGHT_NORMAL
            collider.position.y = COLLIDER_HEIGHT_NORMAL / 2.0
            height_raycast.target_position.y = COLLIDER_HEIGHT_NORMAL
            current_camera_height = CAMERA_HEIGHT_NORMAL
            current_max_speed = JETPACK_SPEED
            current_head_bob_frequency = HEAD_BOB_FREQUENCY_PRONE
            current_head_bob_intensity = HEAD_BOB_INTENSITY_PRONE
            current_lerp_acc = JETPACK_LERP_ACC
            current_lerp_dec = JETPACK_LERP_DEC

func _UpdateEnergyLabel():
    energy_bar_label.text = str(floor(current_energy))
    energy_bar_bar.value = current_energy

#2nd PART
#ROPE GENERATION SCRIPT------------------
@tool
extends MeshInstance3D

@export var iterations = 5
@export var dirty = false
@export var resolution = 10

var grapple_hook_position : Vector3 = Vector3.ZERO
var player_position : Vector3 = Vector3.ZERO

var vertex_array : PackedVector3Array = []
var index_array : PackedInt32Array = []
var normal_array : PackedVector3Array = []

var tangent_array : PackedVector3Array = []
var uv_array : PackedVector2Array = []

var points : PackedVector3Array = []
var points_old : PackedVector3Array = []

@export var point_count = 20

var rope_length : float = 0.0
var point_spacing : float = 0.0
@export var rope_width = .02

@export var isDrawing = false
@export var firstTime = true

@onready var temp_player = $tempPlayer
@onready var temp_hook = $tempHook

var gravity_default = ProjectSettings.get_setting("physics/3d/default_gravity")

# Called when the node enters the scene tree for the first time.
func _ready():
    SetGrappleHookPosition(temp_hook.position)
    SetPlayerPosition(temp_player.position)
    PreparePoints()
    pass # Replace with function body.


# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta):
#   SetPlayerPosition(temp_player.position)
#   SetGrappleHookPosition(temp_hook.position)

    if isDrawing || dirty:
        if firstTime:
            PreparePoints()
            firstTime = false
        UpdatePoints(delta)

        GenerateMesh()

        dirty = false

func SetGrappleHookPosition(val : Vector3):
    grapple_hook_position = val
    firstTime = true

func SetPlayerPosition(val : Vector3):
    player_position = val

func StartDrawing():
    isDrawing = true

func StopDrawing():
    isDrawing = false

func PreparePoints():
    points.clear()
    points_old.clear()

    for i in range(point_count):
        var t = i / (point_count - 1.0)

        points.append(lerp(player_position, grapple_hook_position, t))
        points_old.append(points[i])

    _UpdatePointSpacing()

func _UpdatePointSpacing():
    rope_length = (grapple_hook_position - player_position).length()
    point_spacing = rope_length / (point_count - 1.0)

func UpdatePoints(delta):
    points[0] = player_position
    points[point_count-1] = grapple_hook_position

    _UpdatePointSpacing()

    for i in range(1, point_count - 1):
        var curr : Vector3 = points[i]
        points[i] = points[i] + (points[i] - points_old[i]) + (
            Vector3.DOWN * gravity_default * delta * delta)
        points_old[i] = curr

    for i in range(iterations):
        ConstraintConnections()

func ConstraintConnections():
    for i in range(point_count - 1):
        var centre : Vector3 = (points[i+1] + points[i]) / 2.0
        var offset : Vector3 = (points[i+1] - points[i])
        var length : float = offset.length()
        var dir : Vector3 = offset.normalized()

        var d = length - point_spacing

        if i != 0:
#           points[i] = centre + dir * d / 2.0
            points[i] += dir * d * 0.5

        if i + 1 != point_count - 1:
#           points[i+1] = centre - dir * d / 2.0
            points[i+1] -= dir * d * 0.5

func GenerateMesh():

    vertex_array.clear()

    CalculateNormals()

    index_array.clear()

    #segment / point
    for p in range(point_count):

        var center : Vector3 = points[p]

        var forward = tangent_array[p]
        var norm = normal_array[p]
        var bitangent = norm.cross(forward).normalized()

        #current resolution
        for c in range(resolution):
            var angle = (float(c) / resolution) * 2.0 * PI

            var xVal = sin(angle) * rope_width
            var yVal = cos(angle) * rope_width

            var point = (norm * xVal) + (bitangent * yVal) + center

            vertex_array.append(point)

            if p < point_count - 1:
                var start_index = resolution * p
                #INT values
                index_array.append(start_index + c);
                index_array.append(start_index + c + resolution);
                index_array.append(start_index + (c + 1) % resolution);


                index_array.append(start_index + (c + 1) % resolution);
                index_array.append(start_index + c + resolution);
                index_array.append(start_index + (c + 1) % resolution + resolution);



    mesh.clear_surfaces()
    mesh.surface_begin(Mesh.PRIMITIVE_TRIANGLES)

    for i in range(index_array.size() / 3):
        var p1 = vertex_array[index_array[3*i]]
        var p2 = vertex_array[index_array[3*i+1]]
        var p3 = vertex_array[index_array[3*i+2]]

        var tangent = Plane(p1, p2, p3)
        var normal = tangent.normal

        mesh.surface_set_tangent(tangent)
        mesh.surface_set_normal(normal)
        mesh.surface_add_vertex(p1)

        mesh.surface_set_tangent(tangent)
        mesh.surface_set_normal(normal)
        mesh.surface_add_vertex(p2)

        mesh.surface_set_tangent(tangent)
        mesh.surface_set_normal(normal)
        mesh.surface_add_vertex(p3)

    # End drawing.
    mesh.surface_end()


func CalculateNormals():
    normal_array.clear()
    tangent_array.clear()

    var helper

    for i in range(point_count):
        var tangent := Vector3(0,0,0)
        var normal := Vector3(0,0,0)

        var temp_helper_vector := Vector3(0,0,0)

        #first point
        if i == 0:
            tangent = (points[i+1] - points[i]).normalized()
        #last point
        elif i == point_count - 1:
            tangent = (points[i] - points[i-1]).normalized()
        #between
        else:
            tangent = (points[i+1] - points[i]).normalized() + (
                points[i] - points[i-1]).normalized()

        if i == 0:
            temp_helper_vector = -Vector3.FORWARD if (
                tangent.dot(Vector3.UP) > 0.5) else Vector3.UP

            normal = temp_helper_vector.cross(tangent).normalized()

        else:
            var tangent_prev = tangent_array[i-1]
            var normal_prev = normal_array[i-1]
            var bitangent = tangent_prev.cross(tangent)

            if bitangent.length() == 0:
                normal = normal_prev
            else:
                var bitangent_dir = bitangent.normalized()
                var theta = acos(tangent_prev.dot(tangent))

                var rotate_matrix = Basis(bitangent_dir, theta)
                normal = rotate_matrix * normal_prev

        tangent_array.append(tangent)
        normal_array.append(normal)


func PopulateVertexArray():
    vertex_array.clear()

#   #add player points
#   for i in range(-1, 2, 2):
#       for j in range(-1, 2, 2):
#           vertex_array.append(Vector3(
#               player_position.x + rope_width * i,
#               player_position.y + rope_width * j,
#               player_position.z))
#
#   #add grapple points
#   for i in range(-1, 2, 2):
#       for j in range(-1, 2, 2):
#           vertex_array.append(Vector3(
#               grapple_hook_position.x + rope_width * i,
#               grapple_hook_position.y + rope_width * j,
#               grapple_hook_position.z))

    for point in points:
        vertex_array.append(point)
    pass

func PopulateIndexArray():
    index_array.clear()

#   index_array = [
#       0,1,2,
#       1,2,3,
#       4,5,6,
#       5,6,7,
#       2,3,6,
#       3,6,7,
#       0,1,4,
#       1,4,5,
#       1,3,5,
#       3,5,7,
#       0,2,4,
#       2,4,6
#   ]
    for i in range(vertex_array.size()-1):
        index_array.append(i)
        index_array.append(i+1)
    pass

func DrawRope():
    mesh.clear_surfaces()
    # Begin draw.
#   mesh.surface_begin(Mesh.PRIMITIVE_TRIANGLES)
    mesh.surface_begin(Mesh.PRIMITIVE_LINES)
    # Draw mesh.
    # Prepare attributes for add_vertex.
#   mesh.surface_set_normal(Vector3(0, 0, 1))
#   mesh.surface_set_uv(Vector2(0, 0))
#   # Call last for each vertex, adds the above attributes.
#   mesh.surface_add_vertex(Vector3(-1, -1, 0))
#
#   mesh.surface_set_normal(Vector3(0, 0, 1))
#   mesh.surface_set_uv(Vector2(0, 1))
#   mesh.surface_add_vertex(Vector3(-1, 1, 0))
#
#   mesh.surface_set_normal(Vector3(0, 0, 1))
#   mesh.surface_set_uv(Vector2(1, 1))
#   mesh.surface_add_vertex(Vector3(1, 1, 0))
    for i in index_array:
        mesh.surface_add_vertex(vertex_array[i])

    # End drawing.
    mesh.surface_end()