Attempt at 3D

[insomniacUNDERSCORElemon]

EDIT: Updated code, probably going to try to go mouse+KB only. There are also some errors that I'm not sure if are caused by me or not. that was related to a door I tried to make with pure physics, though it just flew off the hinges (so unrelated to code)

Maybe I'm overextending myself, but I figured a 3D demo would be nice. Given how the difficulties here happen I'm not even sure 2D would be much easier.

This is what I have so far, relative WASD movement (camera rotation with Q and E), not-great jumping:

import gdext
import gdext/classes / [gdCharacterBody3D, gdInput, gdSceneTree]

type Player* = ptr object of CharacterBody3D
  velocity:Vector3
  Input:Input
  speed:float32
  look_speed:float32
  camera:Camera3D

proc vec_mult(vec:Vector3, num:float64):Vector3 =
  return [(vec.*x * num).float32, (vec.*y * num).float32, (vec.*z * num).float32]

proc vec_replace_y(vec:Vector3, num:float32):Vector3 =
  return [(vec.*x).float32, (num).float32, (vec.*z).float32]


method ready(self:Player) {.gdsync.} =
  if Engine.isEditorHint: return #running code in the editor may produce unintented scene changes, even if nodes are hidden
  self.speed = 250.0'f32

  self.look_speed = 1.5'f32
  self.camera = self/"view" as Camera3D
  Input.setMouseMode(mouseModeCaptured)
  print "ready!"

method physicsProcess(self:Player, delta:float64) {.gdsync.} =
  if Engine.isEditorHint: return

  var move_direction:Vector3
  var look_direction:Vector3

  look_direction.*y = Input.getActionStrength("look_left") - Input.getActionStrength("look_right")
  self.setRotation([0.0'f32, (self.rotation.*y + (look_direction.*y * self.look_speed * delta)).float32, 0.0'f32])
  # if added, vertical look must use camera (or other camera rig) rotation
  look_direction.*x = Input.getActionStrength("look_down") - Input.getActionStrength("look_up")
  self.camera.setRotation([(self.camera.rotation.*x + (look_direction.*x * self.look_speed * delta)).float32, 0.0'f32, 0.0'f32])


  let gravity:Vector3 = [0.0, (-9.8 * 60.0) * delta, 0.0]
  self.velocity = vec_mult(self.velocity, delta)

  #if Input.isAnythingPressed:
  move_direction.*x =
    Input.getActionStrength("move_right") - Input.getActionStrength("move_left")
  move_direction.*z =
    Input.getActionStrength("move_backward") - Input.getActionStrength("move_forward")
  move_direction = move_direction.rotated(Vector3_Up, self.rotation.*y).normalized #for non-analog

  self.velocity.*x = move_direction.*x * (self.speed * delta)
  self.velocity.*z = move_direction.*z * (self.speed * delta)

  if Input.isActionPressed "jump":
    self.velocity.*y += self.speed

  if self.isOnFloor: self.setVelocity(self.velocity)
  else:
    self.velocity = vec_replace_y(self.velocity, gravity.*y)
    #self.velocity = vec_replace_y(self.velocity, (gravity.*y + self.velocity.*y)) #jetpack, change jump velocity too
    self.velocity.*y += (Input.getActionStrength("right_trigger") * self.speed * 5.0) * delta #jetpack
    if Input.isActionPressed("hover"): self.velocity = vec_replace_y(self.velocity, math.max(0.0'f32, self.velocity.*y))
    self.setVelocity(self.velocity)
  discard self.moveAndSlide()
  if Input.isActionJustPressed "ui_cancel": Input.setMouseMode(mouseModeVisible)
  if self.position.*y < -4.0: self.getTree.quit() #voidquit

Editor actions needed for this:

• children of class
  • camera3d
  • meshinstance 3d + Mesh>create simplified convex..
• csg with use collision turned on for floor+wall (I tried to use gridmap but couldn't figure out how to get collision w/builtin models)
• input map additions

I was thinking that the code I have now might work with controllers (I have a Steam Controller), though I use that less and was thinking it may not be good to add more niche-ness. Though it would be fun to use the analog triggers or perhaps gyro. EDIT: Yes, but need to remove .normalized for analog control. This is way easier than mouse input.

In the future I may use simple 3D models w/vertex colors, though it would be nice if I had an importer script that could use object names to set existing Godot materials (matte, metal, glass, perhaps more variations especially with vertex color(-as-albedo) as input such as for emission).

[insomniacUNDERSCORElemon]

Not code, but I've been tinkering with vertex colors and materials for that workflow.

For instance that eye has no textures, uses a Ybillboard material and is actually slightly 3D. Could allow for some comical effects, such as if you change the Z scale it makes the eye pop out... if you enable grow on the material it makes the pupil+eye itself larger (this would apply to every UI instance, but I also have distance fade on this so ideally if this were animated/scripted you'd only see it where intended, and I have no idea if other models would benefit from these options).

I have about 9 materials so far (2 of which are different glass materials, some others like wood and a fur material I am not so sure of until I test with other models), I plan to apply these to models using an import script (which likely will be gdscript to start with at least). See this video by Octodemy: mmZ11qSGD3k (Change how your 3D MODELS are imported). Section on shared materials is most important, though I would like to include the single mesh functionality as well (or whatever I can do to remove the outer container that makes the object not centered).

I am not sure how I want to handle transparency (and its impact), for instance I have not explored actually including alpha as part of the vertex colors for glass/other effects. I have had the thought that deleting faces should be another method for stylized transparency that works with any material without needing partial transparency (though I guess that does lose some capability like light/reflections on a fully transparent surface).