suzanne.soy/kiki
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

camera

Browse Source
This commit is contained in:
monsterkodi 2016-08-23 23:39:43 +02:00
parent f97ac83d63
commit 96e4680904
6 changed files with 276 additions and 393 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
coffee/bot.coffee
View File

@ -114,10 +114,11 @@ class Bot extends Pushable
getDown: -> @orientation.rotate Vector.minusY getDown: -> @orientation.rotate Vector.minusY
getUp: -> @orientation.rotate Vector.unitY getUp: -> @orientation.rotate Vector.unitY
getDir: -> @orientation.rotate new Vector 0,0,@dir_sgn getDir: -> @orientation.rotate new Vector 0,0,@dir_sgn
getCurrentDir: -> @current_orientation.rotate(Vector.unitZ).normal() currentPos: -> @current_position.clone()
getCurrentUp: -> @current_orientation.rotate(Vector.unitY).normal() currentDir: -> @current_orientation.rotate(Vector.unitZ).normal()
getCurrentLeft: -> @current_orientation.rotate(Vector.unitX).normal() currentUp: -> @current_orientation.rotate(Vector.unitY).normal()
currentLeft: -> @current_orientation.rotate(Vector.unitX).normal()
# 0000000 000 00000000 # 0000000 000 00000000
# 000 000 000 000 # 000 000 000 000

2
coffee/bullet.coffee
View File

@ -33,7 +33,7 @@ class Bullet extends Item
@shootFromBot: (bot) -> @shootFromBot: (bot) ->
bullet = new Bullet() bullet = new Bullet()
world.addObject bullet world.addObject bullet
bullet.direction = bot.getCurrentDir() bullet.direction = bot.currentDir()
bullet.setPosition bot.position.plus bullet.direction.mul 0.8 bullet.setPosition bot.position.plus bullet.direction.mul 0.8
bullet.src_object = bot bullet.src_object = bot
bullet.mesh.material.color.set bot.mesh.material.color bullet.mesh.material.color.set bot.mesh.material.color

241
coffee/camera.coffee Normal file
View File

@ -0,0 +1,241 @@
# 0000000 0000000 00 00 00000000 00000000 0000000
# 000 000 000 000 000 000 000 000 000 000
# 000 000000000 000000000 0000000 0000000 000000000
# 000 000 000 000 0 000 000 000 000 000 000
# 0000000 000 000 000 000 00000000 000 000 000 000
{
clamp
} = require '/Users/kodi/s/ko/js/tools/tools'
log = require '/Users/kodi/s/ko/js/tools/log'
Matrix = require './lib/matrix'
Vector = require './lib/vector'
class Camera extends Matrix
@INSIDE = 0
@BEHIND = 1
@FOLLOW = 2
constructor: (@player, opt) ->
@fov = opt?.fov ? 90
@near = opt?.near ? 0.01
@eye_distance = @near
@far = opt?.far ? 20
@mode = Camera.BEHIND
@aspect = opt.aspect ? -1
@dist = 10
@border = [0,0,0,0]
super
@setViewport 0.0, 0.0, 1.0, 1.0
@cam = new THREE.PerspectiveCamera @fov, @aspect, @near, @far
@cam.position.z = @dist
step: (step) ->
switch @mode
when Camera.INSIDE then @insideProjection()
when Camera.BEHIND then @behindProjection()
when Camera.FOLLOW then @followProjection()
camPos = @getPosition()
@cam.position.copy camPos
@cam.up.copy @getYVector()
@cam.lookAt camPos.plus @getZVector()
if @light?
pos = @getPosition().plus @light_offset
@light.setDirection -@getZVector()
@light.setPosition new Vector pos[X], pos[Y], pos[Z], 1.0 # positional light source
getLookAtPosition: -> @getZVector().mul(-@eye_distance).plus @getPosition()
updateViewport: ->
ss = world.screenSize
vp = []
vp[0] = @viewport[0] * ss.w + @border[0]
vp[1] = @viewport[1] * ss.h + @border[1]
vp[2] = @viewport[2] * ss.w - @border[0] - @border[2]
vp[3] = @viewport[3] * ss.h - @border[1] - @border[3]
setViewportBorder: (l, b, r, t) ->
@border = [l,b,r,t]
@updateViewport()
setViewport: (l, b, w, h) ->
@viewport = [l,b,w,h]
@updateViewport()
setFov: (fov) -> @fov = Math.max(2.0, Math.min fov, 175.0)
# 00000000 00000000 0000000 000 00000000 0000000 000000000 000 0000000 000 000
# 000 000 000 000 000 000 000 000 000 000 000 000 000 0000 000
# 00000000 0000000 000 000 000 0000000 000 000 000 000 000 000 0 000
# 000 000 000 000 000 000 000 000 000 000 000 000 000 000 0000
# 000 000 000 0000000 0000000 00000000 0000000 000 000 0000000 000 000
insideProjection: () ->
playerPos = @player.currentPos()
playerDir = @player.currentDir()
playerUp = @player.currentUp()
lookAngle = @player.look_angle
posDelta = world.getSpeed() / 10.0 # smooth camera movement a little bit
camPos = playerPos
if lookAngle < 0
camPos.add playerUp.mul -2*lookAngle/90
@setPosition @getPosition().mul(1.0-posDelta).plus camPos.mul posDelta
if lookAngle # player is looking up or down
@setXVector playerDir.cross(playerUp).normal()
rot = Quaternion.rotationAroundVector lookAngle, @getXVector()
@setYVector rot.rotate playerUp
@setZVector rot.rotate playerDir #.neg()
else
# smooth camera rotation a little bit
lookDelta = (2.0 - @getZVector().dot playerDir) * world.getSpeed() / 50.0
newLookVector = @getZVector().mul(1.0 - lookDelta).plus playerDir.mul lookDelta
newLookVector.normalize()
@setXVector playerUp.cross(newLookVector).normal()
@setYVector playerUp
@setZVector newLookVector
@projection
# 0000000 00000000 000 000 000 000 000 0000000
# 000 000 000 000 000 000 0000 000 000 000
# 0000000 0000000 000000000 000 000 0 000 000 000
# 000 000 000 000 000 000 000 0000 000 000
# 0000000 00000000 000 000 000 000 000 0000000
behindProjection: () ->
playerPos = @player.currentPos()
playerDir = @player.currentDir()
playerUp = @player.currentUp()
lookAngle = @player.look_angle
# find a valid camera position
botToCamera = playerUp.minus playerDir.mul 2
min_f = botToCamera.length()
botToCamera.normalize()
min_f = Math.min world.getWallDistanceForRay(playerPos, botToCamera), min_f
camPos = playerPos.plus botToCamera.mul Math.max(min_f, 0.72) * (1-Math.abs(lookAngle)/90)
if lookAngle < 0
camPos.add playerUp.mul -2*lookAngle/90
camPos = world.getInsideWallPosWithDelta camPos, 0.2
# smooth camera movement a little bit
posDelta = 0.2
@setPosition @getPosition().mul(1.0 - posDelta).plus camPos.mul posDelta
if lookAngle
# log "look_angle #{lookAngle}"
@setXVector playerDir.cross(playerUp).normal()
rot = Quaternion.rotationAroundVector lookAngle, @getXVector()
@setYVector rot.rotate playerUp
@setZVector rot.rotate playerDir #.neg()
else
# smooth camera rotation a little bit
lookDelta = 0.3
newLookVector = @getZVector().mul(1.0 - lookDelta).plus (playerDir.minus(playerUp.mul(0.2)).normal()).mul lookDelta
newLookVector.normalize()
@setZVector newLookVector
@setXVector playerUp.cross(newLookVector).normal()
@setYVector newLookVector.cross(@getXVector()).normal()
# 00000000 0000000 000 000 0000000 000 000
# 000 000 000 000 000 000 000 000 0 000
# 000000 000 000 000 000 000 000 000000000
# 000 000 000 000 000 000 000 000 000
# 000 0000000 0000000 0000000 0000000 00 00
followProjection: () ->
camPos = @getPosition()
desiredDistance = 2.0 # desired distance from camera to bot
playerPos = @player.currentPos()
playerDir = @player.currentDir()
playerUp = @player.currentUp()
playerLeft = @player.currentLeft()
# first, adjust distance from camera to bot
botToCamera = camPos.minus playerPos # vector from bot to current pos
cameraBotDistance = botToCamera.length() # distance from camera to bot
if cameraBotDistance >= desiredDistance
difference = cameraBotDistance - desiredDistance
delta = difference*difference/400.0 # weight for following speed
camPos = camPos.mul(1.0-delta).plus playerPos.mul delta
else
difference = desiredDistance - cameraBotDistance
delta = difference/20.0 # weight for negative following speed
camPos = camPos.mul(1.0-delta).plus (playerPos.plus botToCamera.normal().mul desiredDistance).mul delta
# second, rotate around bot
botToCamera = camPos.minus playerPos
botToCameraNormal = botToCamera.normal()
# rotate camera vertically
verticalAngle = Vector.RAD2DEG Math.acos(clamp(-1.0, 1.0, botToCameraNormal.dot playerUp))
if verticalAngle > 45
# log "verticalAngle #{verticalAngle}"
rotQuat = Quaternion.rotationAroundVector(verticalAngle/400.0, botToCameraNormal.cross(playerUp))
botToCamera = rotQuat.rotate botToCamera
botToCameraNormal = botToCamera.normal()
camPos = playerPos.plus botToCamera
rotFactor = 1.0
wall_distance = world.getWallDistanceForPos camPos
if wall_distance < 0.5 # try avoid piercing walls
if wall_distance < 0.2
camPos = world.getInsideWallPosWithDelta camPos, 0.2
botToCamera = camPos.minus playerPos
botToCameraNormal = botToCamera.normal()
rotFactor = 0.5 / (wall_distance-0.2)
# try view bot from behind
# calculate horizontal angle between bot orientation and vector to camera
mappedToXZ = (botToCamera.minus playerUp.mul(botToCamera.dot playerUp)).normal()
horizontalAngle = Vector.RAD2DEG Math.acos(clamp(-1.0, 1.0, -playerDir.dot mappedToXZ))
if botToCameraNormal.dot(playerLeft) < 0
horizontalAngle = -horizontalAngle
rotQuat = Quaternion.rotationAroundVector horizontalAngle/(rotFactor*400.0), playerUp
camPos = playerPos.plus rotQuat.rotate botToCamera
botToCamera = camPos.minus playerPos
botToCameraNormal = botToCamera.normal()
@setPosition camPos # finally, set the position
# slowly adjust look direction by interpolating current and desired directions
lookDelta = @getZVector().dot botToCameraNormal
lookDelta *= lookDelta / 30.0
newLookVector = @getZVector().mul(1.0-lookDelta).plus botToCameraNormal.neg().mul(lookDelta)
newLookVector.normalize()
# slowly adjust up vector by interpolating current and desired up vectors
upDelta = 1.5-@getYVector().dot playerUp
upDelta *= upDelta / 100.0
newUpVector = @getYVector().mul(1.0-upDelta).plus playerUp.mul(upDelta)
newUpVector.normalize()
newLeftVector = newUpVector.cross newLookVector
# finished interpolations, update camera matrix
@setXVector newLeftVector
@setYVector newUpVector
@setZVector newLookVector
@projection
module.exports = Camera

119
coffee/perspective.coffee
View File

@ -1,119 +0,0 @@
# 00000000 00000000 00000000 0000000 00000000 00000000 0000000 000000000 000 000 000 00000000
# 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000
# 00000000 0000000 0000000 0000000 00000000 0000000 000 000 000 000 000 0000000
# 000 000 000 000 000 000 000 000 000 000 000 000
# 000 00000000 000 000 0000000 000 00000000 0000000 000 000 0 00000000
{
clamp
} = require '/Users/kodi/s/ko/js/tools/tools'
log = require '/Users/kodi/s/ko/js/tools/log'
Matrix = require './lib/matrix'
class Perspective extends Matrix
constructor: (fov,near=0.01,far=1000) ->
@znear = near
@zfar = far
@fov = fov
@aspect_ratio = -1.0
@eye_distance = @znear
# @eye_distance = 5.0
@border = [0,0,0,0]
@setViewport 0.0, 0.0, 1.0, 1.0
super
# log "Perspective #{@fov} #{@znear} #{@zfar}"
reset: ->
@fov = 60.0
@eye_distance = @znear
super
@translate 0, 0, @eye_distance
# rotate: (x,y,z) ->
# savePos = @getLookAtPosition()
# @translate -@getPosition()
#
# up = @getYVector()
# look = @getZVector()
#
# rotxz = Matrix.rotation x, 0.0, z
# roty = Matrix.rotation 0.0, y, 0.0
#
# yunit = new Vector 0.0, 1.0, 0.0
# zunit = new Vector 0.0, 0.0, 1.0
#
# lookperp = @look.perpendicular yunit # y-axis rotation
# if lookperp.length() > 0
# look = roty.transform lookperp.plus look.parallel(yunit)
# up = roty.transform up.perpendicular(yunit).plus up.parallel(yunit)
#
# # x & z-axis rotation
# transmat = new Matrix up.cross(look), up, look
#
# uprotxz = rotxz.transform yunit
# lookrotxz = rotxz.transform zunit
#
# up = transmat.transform uprotxz
# look = transmat.transform lookrotxz
#
# @.initXYZ up.cross(look), up, look
#
# @setPosition savePos.plus @getZVector().mul @eye_distance
apply: (camera) ->
camPos = @getPosition()
camera.position.copy camPos
camera.up.copy @getYVector()
camera.lookAt camPos.plus @getZVector()
if @light?
pos = @getPosition().plus @light_offset
@light.setDirection -@getZVector()
@light.setPosition new Vector pos[X], pos[Y], pos[Z], 1.0 # positional light source
# setEyeDistance: (distance) ->
# log 'setEyeDistance', distance
# lookAtPos = @getLookAtPosition()
# @eye_distance = Math.min Math.max(@znear, distance), 0.9*@zfar
# @setPosition lookAtPos.plus @getZVector().mul @eye_distance
# setLookAtPosition: (lookAtPos) ->
# up = @getYVector()
# newLook = lookAtPos.minus(@getPosition()).normal()
# newRight = up.cross(newLook).normal()
# newUp = newLook.cross(newRight).normal()
#
# @setXVector newRight
# @setYVector newUp
# @setZVector newLook
# # log 'setLookAtPosition', @matrix
# @eye_distance = lookAtPos.minus(@getPosition()).length()
getLookAtPosition: -> @getZVector().mul(-@eye_distance).plus @getPosition()
updateViewport: ->
ss = world.screenSize
vp = []
vp[0] = @viewport[0] * ss.w + @border[0]
vp[1] = @viewport[1] * ss.h + @border[1]
vp[2] = @viewport[2] * ss.w - @border[0] - @border[2]
vp[3] = @viewport[3] * ss.h - @border[1] - @border[3]
getCurrentAspectRatio: ->
vps = @getViewportSize()
@aspect_ratio <= 0.0 and vps.w/vps.h or @aspect_ratio
getScreenCoordinates: (pos, sx, sy) ->
setViewportBorder: (l, b, r, t) ->
@border = [l,b,r,t]
@updateViewport()
setViewport: (l, b, w, h) ->
@viewport = [l,b,w,h]
@updateViewport()
setFov: (fov) -> @fov = Math.max(2.0, Math.min fov, 175.0)
module.exports = Perspective

201
coffee/player.coffee
View File

@ -12,8 +12,8 @@ Bot = require './bot'
Action = require './action' Action = require './action'
Timer = require './timer' Timer = require './timer'
Vector = require './lib/vector' Vector = require './lib/vector'
Camera = require './camera'
Quaternion = require './lib/quaternion' Quaternion = require './lib/quaternion'
Perspective = require './perspective'
class Player extends Bot class Player extends Bot
@ -33,6 +33,9 @@ class Player extends Bot
view: 'c' view: 'c'
push: 'shift' push: 'shift'
@camera = new Camera @,
aspect: world.view.offsetWidth / world.view.offsetHeight
@look_action = null @look_action = null
@look_angle = 0.0 @look_angle = 0.0
@new_dir_sgn = 1.0 @new_dir_sgn = 1.0
@ -47,178 +50,8 @@ class Player extends Bot
@addEventWithName "landed" @addEventWithName "landed"
@projection = new Perspective 90.0
@projection.updateViewport()
bulletHitSound: -> 'BULLET_HIT_PLAYER' bulletHitSound: -> 'BULLET_HIT_PLAYER'
# 00000000 00000000 0000000 000 00000000 0000000 000000000 000 0000000 000 000
# 000 000 000 000 000 000 000 000 000 000 000 000 000 0000 000
# 00000000 0000000 000 000 000 0000000 000 000 000 000 000 000 0 000
# 000 000 000 000 000 000 000 000 000 000 000 000 000 000 0000
# 000 000 000 0000000 0000000 00000000 0000000 000 000 0000000 000 000
getInsideProjection: () ->
# smooth camera movement a little bit
posDelta = world.getSpeed() / 10.0
playerDir = @getCurrentDir()
playerUp = @current_orientation.rotate(new Vector(0,1,0)).normal()
camPos = @current_position.clone()
if @look_angle < 0
camPos.add playerUp.mul -2*@look_angle/90
@projection.setPosition @projection.getPosition().mul(1.0-posDelta).plus camPos.mul posDelta
if @look_angle # player is looking up or down
@projection.setXVector playerDir.cross(playerUp).normal()
rot = Quaternion.rotationAroundVector @look_angle, @projection.getXVector()
@projection.setYVector rot.rotate playerUp
@projection.setZVector rot.rotate playerDir #.neg()
else
# smooth camera rotation a little bit
lookDelta = (2.0 - @projection.getZVector().dot playerDir) * world.getSpeed() / 50.0
newLookVector = @projection.getZVector().mul(1.0 - lookDelta).plus playerDir.mul lookDelta
newLookVector.normalize()
@projection.setXVector playerUp.cross(newLookVector).normal()
@projection.setYVector playerUp
@projection.setZVector newLookVector
@projection
# 0000000 00000000 000 000 000 000 000 0000000
# 000 000 000 000 000 000 0000 000 000 000
# 0000000 0000000 000000000 000 000 0 000 000 000
# 000 000 000 000 000 000 000 0000 000 000
# 0000000 00000000 000 000 000 000 000 0000000
getBehindProjection: () ->
playerDir = @getCurrentDir()
playerUp = @current_orientation.rotate(new Vector(0,1,0)).normal()
# find a valid camera position
botToCamera = playerUp.minus playerDir.mul 2
min_f = botToCamera.length()
botToCamera.normalize()
min_f = Math.min world.getWallDistanceForRay(@current_position, botToCamera), min_f
camPos = @current_position.plus botToCamera.mul Math.max(min_f, 0.72) * (1-Math.abs(@look_angle)/90)
if @look_angle < 0
camPos.add playerUp.mul -2*@look_angle/90
camPos = world.getInsideWallPosWithDelta camPos, 0.2
# smooth camera movement a little bit
posDelta = 0.2
@projection.setPosition @projection.getPosition().mul(1.0 - posDelta).plus camPos.mul posDelta
if @look_angle
# log "look_angle #{@look_angle}"
@projection.setXVector playerDir.cross(playerUp).normal()
rot = Quaternion.rotationAroundVector @look_angle, @projection.getXVector()
@projection.setYVector rot.rotate playerUp
@projection.setZVector rot.rotate playerDir #.neg()
else
# smooth camera rotation a little bit
lookDelta = 0.3
newLookVector = @projection.getZVector().mul(1.0 - lookDelta).plus (playerDir.minus(@getCurrentUp().mul(0.2)).normal()).mul lookDelta
newLookVector.normalize()
@projection.setZVector newLookVector
@projection.setXVector playerUp.cross(newLookVector).normal()
@projection.setYVector newLookVector.cross(@projection.getXVector()).normal()
# log 'Player.getBehindProjection', @projection.getPosition()
@projection
# 00000000 0000000 000 000 0000000 000 000
# 000 000 000 000 000 000 000 000 0 000
# 000000 000 000 000 000 000 000 000000000
# 000 000 000 000 000 000 000 000 000
# 000 0000000 0000000 0000000 0000000 00 00
getFollowProjection: () ->
camPos = @projection.getPosition()
desiredDistance = 2.0 # desired distance from camera to bot
playerPos = @current_position
playerDir = @getCurrentDir()
playerUp = @getCurrentUp()
playerLeft = @getCurrentLeft()
# first, adjust distance from camera to bot
botToCamera = camPos.minus playerPos # vector from bot to current pos
cameraBotDistance = botToCamera.length() # distance from camera to bot
if cameraBotDistance >= desiredDistance
difference = cameraBotDistance - desiredDistance
delta = difference*difference/400.0 # weight for following speed
camPos = camPos.mul(1.0-delta).plus playerPos.mul delta
else
difference = desiredDistance - cameraBotDistance
delta = difference/20.0 # weight for negative following speed
camPos = camPos.mul(1.0-delta).plus (playerPos.plus botToCamera.normal().mul desiredDistance).mul delta
# second, rotate around bot
botToCamera = camPos.minus playerPos
botToCameraNormal = botToCamera.normal()
# rotate camera vertically
verticalAngle = Vector.RAD2DEG Math.acos(clamp(-1.0, 1.0, botToCameraNormal.dot playerUp))
if verticalAngle > 45
# log "verticalAngle #{verticalAngle}"
rotQuat = Quaternion.rotationAroundVector(verticalAngle/400.0, botToCameraNormal.cross(playerUp))
botToCamera = rotQuat.rotate botToCamera
botToCameraNormal = botToCamera.normal()
camPos = playerPos.plus botToCamera
rotFactor = 1.0
wall_distance = world.getWallDistanceForPos camPos
if wall_distance < 0.5 # try avoid piercing walls
if wall_distance < 0.2
camPos = world.getInsideWallPosWithDelta camPos, 0.2
botToCamera = camPos.minus playerPos
botToCameraNormal = botToCamera.normal()
rotFactor = 0.5 / (wall_distance-0.2)
# try view bot from behind
# calculate horizontal angle between bot orientation and vector to camera
mappedToXZ = (botToCamera.minus playerUp.mul(botToCamera.dot playerUp)).normal()
horizontalAngle = Vector.RAD2DEG Math.acos(clamp(-1.0, 1.0, -playerDir.dot mappedToXZ))
if botToCameraNormal.dot(playerLeft) < 0
horizontalAngle = -horizontalAngle
rotQuat = Quaternion.rotationAroundVector horizontalAngle/(rotFactor*400.0), playerUp
camPos = playerPos.plus rotQuat.rotate botToCamera
botToCamera = camPos.minus playerPos
botToCameraNormal = botToCamera.normal()
@projection.setPosition camPos # finally, set the position
# slowly adjust look direction by interpolating current and desired directions
lookDelta = @projection.getZVector().dot botToCameraNormal
lookDelta *= lookDelta / 30.0
newLookVector = @projection.getZVector().mul(1.0-lookDelta).plus botToCameraNormal.neg().mul(lookDelta)
newLookVector.normalize()
# slowly adjust up vector by interpolating current and desired up vectors
upDelta = 1.5-@projection.getYVector().dot playerUp
upDelta *= upDelta / 100.0
newUpVector = @projection.getYVector().mul(1.0-upDelta).plus playerUp.mul(upDelta)
newUpVector.normalize()
newLeftVector = newUpVector.cross newLookVector
# finished interpolations, update camera matrix
@projection.setXVector newLeftVector
@projection.setYVector newUpVector
@projection.setZVector newLookVector
@projection
# 0000000 0000000 000000000 000 0000000 000 000 # 0000000 0000000 000000000 000 0000000 000 000
# 000 000 000 000 000 000 000 0000 000 # 000 000 000 000 000 000 000 0000 000
# 000000000 000 000 000 000 000 000 0 000 # 000000000 000 000 000 000 000 000 0 000
@ -419,30 +252,4 @@ class Player extends Bot
false false
# 0000000 000 0000000 00000000 000 0000000 000 000
# 000 000 000 000 000 000 000 000 000 000 000
# 000 000 000 0000000 00000000 000 000000000 00000
# 000 000 000 000 000 000 000 000 000
# 0000000 000 0000000 000 0000000 000 000 000
step: (step) -> super step
getBodyColor: () ->
if world.getCameraMode() == world.CAMERA_BEHIND
# static bodyColor
bodyColor = colors[KikiPlayer_base_color]
bodyColor.setAlpha(kMin(0.7, (@projection.getPosition()-@current_position).length()-0.4))
return bodyColor
return colors[KikiPlayer_base_color]
getTireColor: () ->
if world.getCameraMode() == world.CAMERA_BEHIND
# static tireColor
tireColor = colors[KikiPlayer_tire_color]
tireColor.setAlpha(kMin(1.0, (@projection.getPosition()-@current_position).length()-0.4))
return tireColor
return colors[KikiPlayer_tire_color]
module.exports = Player module.exports = Player

97
coffee/world.coffee
View File

@ -15,6 +15,7 @@ Pos = require './lib/pos'
Size = require './lib/size' Size = require './lib/size'
Cell = require './cell' Cell = require './cell'
Gate = require './gate' Gate = require './gate'
Camera = require './camera'
Light = require './light' Light = require './light'
Levels = require './levels' Levels = require './levels'
Player = require './player' Player = require './player'
@ -43,10 +44,6 @@ Face} = require './items'
world = null world = null
class World extends Actor class World extends Actor
@CAMERA_INSIDE = 0
@CAMERA_BEHIND = 1
@CAMERA_FOLLOW = 2
@levels = null @levels = null
@ -63,10 +60,7 @@ class World extends Actor
@speed = 6 @speed = 6
@raster_size = 0.05 @rasterSize = 0.05
# @camera_mode = World.CAMERA_INSIDE
@camera_mode = World.CAMERA_BEHIND
# @camera_mode = World.CAMERA_FOLLOW
super super
@ -84,22 +78,7 @@ class World extends Actor
@renderer.setClearColor 0x000000 @renderer.setClearColor 0x000000
@renderer.setSize @view.offsetWidth, @view.offsetHeight @renderer.setSize @view.offsetWidth, @view.offsetHeight
@renderer.shadowMap.type = THREE.PCFSoftShadowMap @renderer.shadowMap.type = THREE.PCFSoftShadowMap
# 0000000 0000000 00 00 00000000 00000000 0000000
# 000 000 000 000 000 000 000 000 000 000
# 000 000000000 000000000 0000000 0000000 000000000
# 000 000 000 000 0 000 000 000 000 000 000
# 0000000 000 000 000 000 00000000 000 000 000 000
@fov = 90
@near = 0.1
@far = 20
@aspect = @view.offsetWidth / @view.offsetHeight
@dist = 10
@camera = new THREE.PerspectiveCamera @fov, @aspect, @near, @far
@camera.position.z = @dist
# 0000000 0000000 00000000 000 000 00000000 # 0000000 0000000 00000000 000 000 00000000
# 000 000 000 0000 000 000 # 000 000 000 0000 000 000
# 0000000 000 0000000 000 0 000 0000000 # 0000000 000 0000000 000 0 000 0000000
@ -115,7 +94,7 @@ class World extends Actor
# 0000000 000 0000000 000 000 000 # 0000000 000 0000000 000 000 000
@sun = new THREE.PointLight 0xffffff @sun = new THREE.PointLight 0xffffff
@sun.position.copy @camera.position @sun.position.copy @player.camera.getPosition() if @player?
@scene.add @sun @scene.add @sun
@ambient = new THREE.AmbientLight 0x111111 @ambient = new THREE.AmbientLight 0x111111
@ -199,11 +178,6 @@ class World extends Actor
# else # else
# @setName "noname" # @setName "noname"
# if @preview
# @getProjection().setViewport(0.0, 0.4, 1.0, 0.6)
# else
# @getProjection().setViewport(0.0, 0.0, 1.0, 1.0)
# ............................................................ escape # ............................................................ escape
# escape_event = Controller.getEventWithName ("escape") # escape_event = Controller.getEventWithName ("escape")
# escape_event.removeAllActions() # escape_event.removeAllActions()
@ -251,7 +225,7 @@ class World extends Actor
else if @dict.player.coordinates? else if @dict.player.coordinates?
@addObjectAtPos @player, new Pos @dict.player.coordinates @addObjectAtPos @player, new Pos @dict.player.coordinates
@getProjection().setPosition new Vector 0,0,0 @player.camera.setPosition new Vector 0,0,0
restart: () -> @create @dict restart: () -> @create @dict
@ -344,10 +318,10 @@ class World extends Actor
# calcuate max distance (for position relative sound) # calcuate max distance (for position relative sound)
@max_distance = Math.max(@size.x, Math.max(@size.y, @size.z)) # heuristic of a heuristic :-) @max_distance = Math.max(@size.x, Math.max(@size.y, @size.z)) # heuristic of a heuristic :-)
@cage?.del() @cage?.del()
@cage = new Cage @size, @raster_size @cage = new Cage @size, @rasterSize
getCellAtPos: (pos) -> return @cells[@posToIndex(pos)] if @isValidPos pos getCellAtPos: (pos) -> return @cells[@posToIndex(pos)] if @isValidPos pos
getBotAtPos: (pos) -> @getObjectOfTypeAtPos KikiBot, new Pos pos getBotAtPos: (pos) -> @getObjectOfTypeAtPos Bot, new Pos pos
posToIndex: (pos) -> posToIndex: (pos) ->
p = new Pos pos p = new Pos pos
@ -477,9 +451,7 @@ class World extends Actor
newObject: (object) -> newObject: (object) ->
if _.isString object if _.isString object
if object.startsWith 'Kiki' if object.startsWith 'new'
return new (require "./#{object.slice(4).toLowerCase()}")()
else if object.startsWith 'new'
return eval object return eval object
return new (require "./#{object.toLowerCase()}")() return new (require "./#{object.toLowerCase()}")()
if object instanceof Item if object instanceof Item
@ -548,9 +520,9 @@ class World extends Actor
log "World.getObjectWithName [WARNING] no object with name #{objectName}" log "World.getObjectWithName [WARNING] no object with name #{objectName}"
null null
setCameraMode: (mode) -> @camera_mode = clamp World.CAMERA_INSIDE, World.CAMERA_FOLLOW, mode setCameraMode: (mode) -> @player.camera.mode = clamp Camera.INSIDE, Camera.FOLLOW, mode
changeCameraMode: -> @camera_mode = (@camera_mode+1) % (World.CAMERA_FOLLOW+1) changeCameraMode: -> @player.camera.mode = (@player.camera.mode+1) % (Camera.FOLLOW+1)
# 0000000 0000000 000 00 00 0000000 000 000 00000000 # 0000000 0000000 000 00 00 0000000 000 000 00000000
# 000 000 000 000 000 000 000 000 000 000 000 000 # 000 000 000 000 000 000 000 000 000 000 000 000
@ -638,14 +610,6 @@ class World extends Actor
else else
log "world.objectMoved [WARNING] #{movedObject.name} no target cell?" log "world.objectMoved [WARNING] #{movedObject.name} no target cell?"
setObjectColor: (color_name, color) ->
if color_name == 'base'
# KikiWall::setObjectColor "base", color
@colors[0] = color
else if color_name == 'plate'
# KikiWall::setObjectColor "plate", color
@colors[1] = color
# 0000000 000000000 00000000 00000000 # 0000000 000000000 00000000 00000000
# 000 000 000 000 000 # 000 000 000 000 000
# 0000000 000 0000000 00000000 # 0000000 000 0000000 00000000
@ -653,31 +617,27 @@ class World extends Actor
# 0000000 000 00000000 000 # 0000000 000 00000000 000
step: (step) -> step: (step) ->
camera = @player.camera.cam
if false if false
quat = @camera.quaternion.clone() quat = camera.quaternion.clone()
quat.multiply new THREE.Quaternion().setFromAxisAngle new THREE.Vector3(1,0,0), step.dsecs*0.2 quat.multiply new THREE.Quaternion().setFromAxisAngle new THREE.Vector3(1,0,0), step.dsecs*0.2
quat.multiply new THREE.Quaternion().setFromAxisAngle new THREE.Vector3(0,1,0), step.dsecs*0.1 quat.multiply new THREE.Quaternion().setFromAxisAngle new THREE.Vector3(0,1,0), step.dsecs*0.1
center = @size.div 2 center = @size.div 2
@camera.position.set(center.x,center.y,center.z+@dist).applyQuaternion quat camera.position.set(center.x,center.y,center.z+@dist).applyQuaternion quat
@camera.quaternion.copy quat camera.quaternion.copy quat
Timer.event.triggerActions() Timer.event.triggerActions()
Timer.event.finishActions() Timer.event.finishActions()
o.step?(step) for o in @objects o.step?(step) for o in @objects
@player.camera.step step
switch @camera_mode Sound.setMatrix @player.camera
when World.CAMERA_INSIDE then @projection = @player.getInsideProjection()
when World.CAMERA_BEHIND then @projection = @player.getBehindProjection()
when World.CAMERA_FOLLOW then @projection = @player.getFollowProjection()
Sound.setMatrix @projection
# Material.tire.visible = @camera_mode != World.CAMERA_INSIDE @player.setOpacity clamp 0, 1, @player.camera.getPosition().minus(@player.current_position).length()-0.4
@player.setOpacity clamp 0, 1, @projection.getPosition().minus(@player.current_position).length()-0.4
@projection.apply @camera @sun.position.copy camera.position
@sun.position.copy @camera.position @renderer.render @scene, camera
@renderer.render @scene, @camera
# 000000000 000 00 00 00000000 # 000000000 000 00 00 00000000
# 000 000 000 000 000 # 000 000 000 000 000
@ -711,8 +671,9 @@ class World extends Actor
resized: (w,h) -> resized: (w,h) ->
@aspect = w/h @aspect = w/h
@camera?.aspect = @aspect camera = @player.camera.cam
@camera?.updateProjectionMatrix() camera?.aspect = @aspect
camera?.updateProjectionMatrix()
@renderer?.setSize w,h @renderer?.setSize w,h
@screenSize = new Size w,h @screenSize = new Size w,h
@ -819,7 +780,7 @@ class World extends Actor
if less_text if less_text
page.getEventWithName("previous").addAction (i=index-1) => @outro i page.getEventWithName("previous").addAction (i=index-1) => @outro i
resetProjection: -> world.getProjection().setViewport 0.0, 0.0, 1.0, 1.0 resetProjection: -> @player.camera.setViewport 0.0, 0.0, 1.0, 1.0
# 00000000 0000000 0000000 # 00000000 0000000 0000000
# 000 000 000 # 000 000 000
@ -891,15 +852,7 @@ class World extends Actor
displayLights: () -> displayLights: () ->
for light in @lights for light in @lights
lignt.display() lignt.display()
getProjection: () ->
if not @projection
switch @camera_mode
when World.CAMERA_INSIDE then @projection = @player.getInsideProjection()
when World.CAMERA_BEHIND then @projection = @player.getBehindProjection()
when World.CAMERA_FOLLOW then @projection = @player.getFollowProjection()
@projection
playSound: (sound, pos, time) -> Sound.play sound, pos, time playSound: (sound, pos, time) -> Sound.play sound, pos, time
# 000 000 00000000 000 000 # 000 000 00000000 000 000