`cf7cd1e`

fix some ollie things

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 4 months ago

SHA: cf7cd1e209773abf25c8b10f2e17aadf407fa00f
Parents: 806496f
Tree: 0bb5836

1 changed file

Status	File	+	-
M	`src/renderers/three/octopus.js`	89	49

src/renderers/three/octopus.jsmodified

    rightShine.position.set(0.35, 0.4, -0.38)
    group.add(rightShine)
--  // Create 8 tentacles
++  // Create 8 tentacles - splayed outward evenly around the body like \./
    const tentacles = []
    const tentacleGroup = new THREE.Group()
--  tentacleGroup.position.y = -0.3
++  tentacleGroup.position.y = -0.05 // Raised up so tentacles emerge above water
    for (let i = 0; i < 8; i++) {
      const angle = (i / 8) * Math.PI * 2
      const tentacle = createTentacle(bodyMaterial, suckerMaterial, gradientMap)
++
++    // Position at edge of lower body
      tentacle.position.x = Math.cos(angle) * 0.35
      tentacle.position.z = Math.sin(angle) * 0.35
--    tentacle.rotation.y = -angle + Math.PI / 2
++
--    // Splay outward slightly
++    // Simply rotate around Y to spread evenly - tentacles extend in +Z and curve up
--    tentacle.rotation.z = 0.3
++    tentacle.rotation.y = angle
++
      tentacles.push(tentacle)
      tentacleGroup.add(tentacle)
+   }
    group.add(tentacleGroup)
--  // Magnifying glass - attached to front-right tentacle (index 1)
++  // Magnifying glass - will be attached to front tentacle (index 0)
    const magGlassGroup = new THREE.Group()
--  // Handle
++  // Handle - longer and thicker for visibility
--  const handleGeom = new THREE.CylinderGeometry(0.02, 0.025, 0.3, 6)
++  const handleGeom = new THREE.CylinderGeometry(0.03, 0.035, 0.25, 6)
    const handle = new THREE.Mesh(handleGeom, glassRimMaterial)
    handle.rotation.z = Math.PI / 2
--  handle.position.x = -0.15
++  handle.position.x = -0.18
    magGlassGroup.add(handle)
    // Rim
    lens.position.z = 0.01
    magGlassGroup.add(lens)
--  // Position magnifying glass at end of front-right tentacle
++  // Back of lens for visibility from other side
--  magGlassGroup.position.set(0.9, -0.5, -0.3)
++  const lensBack = new THREE.Mesh(lensGeom, glassMaterial)
--  magGlassGroup.rotation.y = -0.5
++  lensBack.position.z = -0.01
--  group.add(magGlassGroup)
++  lensBack.rotation.y = Math.PI
++  magGlassGroup.add(lensBack)
++
++  // Attach magnifying glass to the TIP of tentacle 2 (side tentacle, away from body)
++  // Navigate to the last joint of that tentacle
++  let magTentacle = tentacles[2]
++  let lastJoint = magTentacle.children[0] // First joint
++  while (lastJoint.children.length > 1 || (lastJoint.children[0] && lastJoint.children[0].type === 'Group')) {
++    // Find the child that is a Group (the next joint)
++    const nextJoint = lastJoint.children.find(c => c.type === 'Group')
++    if (nextJoint) {
++      lastJoint = nextJoint
++    } else {
++      break
++    }
++  }
++
++  // Position at the tip of the last segment
++  magGlassGroup.position.set(0, 0.05, 0.15)
++  magGlassGroup.rotation.x = 0.5 // Angle it forward/up for visibility
++  lastJoint.add(magGlassGroup)
    // Ollie starts hidden below the water
    group.position.y = -3
+   }
    function createTentacle(bodyMat, suckerMat, gradient) {
++    // Build tentacle as a chain of segments, each one a child of the previous
++    // This creates a smooth curve by rotating each joint
      const tentacleObj = new THREE.Group()
--    // 3 segments, getting smaller
++    const numSegments = 5
--    const segments = [
++    let currentParent = tentacleObj
--      { radius: 0.08, length: 0.35 },
++
--      { radius: 0.06, length: 0.3 },
++    for (let idx = 0; idx < numSegments; idx++) {
--      { radius: 0.04, length: 0.25 }
++      const radius = 0.065 - idx * 0.01
--    ]
++      const length = 0.18 - idx * 0.015
++
++      // Create a joint group for this segment
++      const joint = new THREE.Group()
++
++      // Position joint at end of parent (except first one at origin)
++      if (idx > 0) {
++        joint.position.z = 0.16 - (idx - 1) * 0.012 // Length of previous segment
++      }
++
++      // Rotate joint to curve upward - more curve toward the tip
++      joint.rotation.x = -0.28 - idx * 0.08
++
++      // Create the segment mesh
++      const segGeom = new THREE.CylinderGeometry(radius * 0.7, radius, length, 6)
++      segGeom.rotateX(Math.PI / 2) // Lay along Z axis
++      segGeom.translate(0, 0, length / 2) // Move so base is at origin
--    let yOffset = 0
--    segments.forEach((seg, idx) => {
--      const segGeom = new THREE.CylinderGeometry(seg.radius * 0.7, seg.radius, seg.length, 6)
        const segMesh = new THREE.Mesh(segGeom, bodyMat)
--      segMesh.position.y = yOffset - seg.length / 2
++      joint.add(segMesh)
--      tentacleObj.add(segMesh)
++
--
++      // Add suckers on underside
--      // Add suckers on underside (only first two segments)
++      if (idx < 4) {
--      if (idx < 2) {
++        const suckerGeom = new THREE.SphereGeometry(0.015, 4, 4)
--        for (let s = 0; s < 2; s++) {
++        const sucker = new THREE.Mesh(suckerGeom, suckerMat)
--          const suckerGeom = new THREE.SphereGeometry(0.015, 4, 4)
++        sucker.position.set(0, -radius * 0.85, length * 0.5)
--          const sucker = new THREE.Mesh(suckerGeom, suckerMat)
++        sucker.scale.set(1, 0.5, 1)
--          sucker.position.set(-seg.radius * 0.8, yOffset - seg.length * 0.3 - s * 0.12, 0)
++        joint.add(sucker)
--          sucker.scale.set(1, 0.5, 1)
--          tentacleObj.add(sucker)
--        }
+       }
--      yOffset -= seg.length
++      currentParent.add(joint)
--    })
++      currentParent = joint
++    }
--    // Curly tip
++    // Curly tip at the end
--    const tipGeom = new THREE.SphereGeometry(0.03, 6, 4)
++    const tipGeom = new THREE.SphereGeometry(0.02, 6, 4)
--    tipGeom.scale(1, 1.5, 1)
      const tip = new THREE.Mesh(tipGeom, bodyMat)
--    tip.position.y = yOffset - 0.03
++    tip.position.z = 0.12
--    tentacleObj.add(tip)
++    currentParent.add(tip)
      return tentacleObj
+   }
      // Animate tentacles (always, when visible)
      if (group.visible) {
        tentacles.forEach((t, i) => {
++        const baseAngle = (i / 8) * Math.PI * 2
          const phase = i * (Math.PI / 4)
--        // Wave motion
++        // Gentle swaying - each tentacle waves side to side
--        t.rotation.x = 0.3 + Math.sin(elapsed * 2 + phase) * 0.25
++        t.rotation.y = baseAngle + Math.sin(elapsed * 1.5 + phase) * 0.12
--        t.rotation.z = 0.3 + Math.cos(elapsed * 1.5 + phase) * 0.15
++        // Slight up/down bob
++        t.rotation.x = Math.sin(elapsed * 2 + phase) * 0.08
        })
--      // Magnifying glass sway
++      // Magnifying glass gets a little extra wobble for curious inspection look
--      magGlassGroup.rotation.z = Math.sin(elapsed * 3) * 0.15
++      magGlassGroup.rotation.z = Math.sin(elapsed * 3) * 0.1
--      magGlassGroup.rotation.x = Math.sin(elapsed * 2.5) * 0.1
++      magGlassGroup.rotation.y = Math.sin(elapsed * 2) * 0.15
+     }
      switch (state.mode) {
          const easeIn = Math.pow(submergeProgress, 2)
          group.position.y = 0.2 - easeIn * 2.5
--        // Tentacles curl inward as submerging
++        // Tentacles curl as submerging
          tentacles.forEach((t, i) => {
++          const baseAngle = (i / 8) * Math.PI * 2
            const phase = i * (Math.PI / 4)
--          t.rotation.x = 0.3 + easeIn * 0.5 + Math.sin(elapsed * 2 + phase) * 0.15
++          t.rotation.y = baseAngle + Math.sin(elapsed * 2 + phase) * 0.05
++          // Curl downward as sinking
++          t.rotation.x = easeIn * 0.4 + Math.sin(elapsed * 2 + phase) * 0.05
          })
          // Add ripples as submerging