-
Notifications
You must be signed in to change notification settings - Fork 2
/
camera.go
223 lines (186 loc) · 6.79 KB
/
camera.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
package kamera
import (
"fmt"
"math"
"github.com/hajimehoshi/ebiten/v2"
"github.com/setanarut/fastnoise"
)
// Camera object
// Use the `Camera.LookAt()` function to align the center of the camera to the target.
type Camera struct {
// ZoomFactor is the camera zoom (scaling) factor. Default is 1.
ZoomFactor float64
// Interpolate camera movement
Lerp bool
LerpSpeed float64
// Camera shake options
ShakeOptions *CameraShakeOptions
// private
drawOptions *ebiten.DrawImageOptions
angle, actualAngle, tickSpeed, tick, trauma, w, h, zoomFactorShake float64
tempTarget, centerOffset, topLeft, traumaOffset vec2
}
// NewCamera returns new Camera
func NewCamera(lookAtX, lookAtY, w, h float64) *Camera {
target := vec2{lookAtX, lookAtY}
c := &Camera{
ZoomFactor: 1.0,
Lerp: false,
LerpSpeed: 0.1,
ShakeOptions: DefaultCameraShakeOptions(),
// private
w: w,
h: h,
angle: 0,
zoomFactorShake: 1.0,
trauma: 0,
drawOptions: &ebiten.DrawImageOptions{},
centerOffset: vec2{-(w * 0.5), -(h * 0.5)},
traumaOffset: vec2{},
topLeft: vec2{},
tempTarget: vec2{},
tickSpeed: 1.0 / 60.0,
tick: 0,
}
c.LookAt(lookAtX, lookAtY)
c.tempTarget = target
return c
}
func DefaultCameraShakeOptions() *CameraShakeOptions {
opt := &CameraShakeOptions{
Noise: fastnoise.New[float64](),
MaxX: 10.0,
MaxY: 10.0,
MaxAngle: 0.05,
MaxZoomFactor: 0.1,
Decay: 0.666,
TimeScale: 10,
}
opt.Noise.Frequency = 0.5
return opt
}
// LookAt aligns the midpoint of the camera viewport to the target.
// Use this function only once in Update() and change only the TargetX TargetY variables
func (cam *Camera) LookAt(targetX, targetY float64) {
target := vec2{targetX, targetY}
if cam.Lerp {
cam.tempTarget = cam.tempTarget.Lerp(target, cam.LerpSpeed)
cam.topLeft = cam.tempTarget
} else {
cam.topLeft = target
}
if cam.trauma > 0 {
var shake = math.Pow(cam.trauma, 2)
noiseValueX := cam.ShakeOptions.Noise.GetNoise3D(cam.tick*cam.ShakeOptions.TimeScale, 0, 0)
noiseValueY := cam.ShakeOptions.Noise.GetNoise3D(0, cam.tick*cam.ShakeOptions.TimeScale, 0)
noiseValueAngle := cam.ShakeOptions.Noise.GetNoise3D(0, 0, cam.tick*cam.ShakeOptions.TimeScale)
cam.traumaOffset.X = noiseValueX * cam.ShakeOptions.MaxX * shake
cam.traumaOffset.Y = noiseValueY * cam.ShakeOptions.MaxY * shake
cam.actualAngle = noiseValueAngle * cam.ShakeOptions.MaxAngle * shake
noiseValueZoom := cam.ShakeOptions.Noise.GetNoise3D(cam.tick*cam.ShakeOptions.TimeScale+300, 0, 0)
cam.zoomFactorShake = (noiseValueZoom * cam.ShakeOptions.MaxZoomFactor * shake)
cam.zoomFactorShake *= cam.ZoomFactor
cam.zoomFactorShake += cam.ZoomFactor
cam.trauma = clamp(cam.trauma-(cam.tickSpeed*cam.ShakeOptions.Decay), 0, 1)
} else {
cam.actualAngle = 0.0
cam.zoomFactorShake = cam.ZoomFactor
}
// offset
cam.actualAngle += cam.angle
cam.topLeft = cam.topLeft.Add(cam.traumaOffset)
cam.topLeft = cam.topLeft.Add(cam.centerOffset)
// tick
cam.tick += cam.tickSpeed
if cam.tick > 1000000 {
cam.tick = 0
}
}
// AddTrauma adds trauma. factor is in the range [0-1]
func (cam *Camera) AddTrauma(factor float64) {
cam.trauma = clamp(cam.trauma+factor, 0, 1)
}
// TopLeft() returns top left position of the camera rectangle
func (cam *Camera) TopLeft() (X float64, Y float64) {
return cam.topLeft.X, cam.topLeft.Y
}
// Target returns center point of the camera in world-space
func (cam *Camera) Target() (X float64, Y float64) {
center := cam.topLeft.Sub(cam.centerOffset)
return center.X, center.Y
}
// ActualAngle returns camera rotation angle (including the angle of trauma shaking.). The unit is radian.
func (cam *Camera) ActualAngle() (angle float64) {
return cam.actualAngle
}
// Angle returns camera rotation angle (The angle of trauma shake is not included.). The unit is radian.
func (cam *Camera) Angle() (angle float64) {
return cam.angle
}
// SetAngle sets rotation. The unit is radian.
func (cam *Camera) SetAngle(angle float64) {
cam.angle = angle
}
// Width returns width of the camera
func (cam *Camera) Width() float64 {
return cam.w
}
// Width returns height of the camera
func (cam *Camera) Height() float64 {
return cam.h
}
// SetSize ses camera rectangle size
func (cam *Camera) SetSize(w, h float64) {
cam.w, cam.h = w, h
cam.centerOffset = vec2{-(w * 0.5), -(h * 0.5)}
}
// Reset resets rotation and zoom factor to zero
func (cam *Camera) Reset() {
cam.angle, cam.ZoomFactor, cam.zoomFactorShake = 0.0, 1.0, 1.0
}
// String returns camera values as string
func (cam *Camera) String() string {
x, y := cam.Target()
return fmt.Sprintf(
"TargetX: %.1f\nTargetY: %.1f\nCam Rotation: %.1f\nZoom factor: %.2f\nLerp: %v",
x, y, cam.ActualAngle(), cam.zoomFactorShake, cam.Lerp,
)
}
// ScreenToWorld converts screen-space coordinates to world-space
func (cam *Camera) ScreenToWorld(screenX, screenY int) (worldX float64, worldY float64) {
g := ebiten.GeoM{}
cam.ApplyCameraTransform(&g)
if g.IsInvertible() {
g.Invert()
worldX, worldY := g.Apply(float64(screenX), float64(screenY))
return worldX, worldY
} else {
// When scaling it can happened that matrix is not invertable
return math.NaN(), math.NaN()
}
}
// ApplyCameraTransform applies geometric transformation to given geoM
func (cam *Camera) ApplyCameraTransform(geoM *ebiten.GeoM) {
geoM.Translate(-cam.topLeft.X, -cam.topLeft.Y) // camera movement
geoM.Translate(cam.centerOffset.X, cam.centerOffset.Y) // rotate and scale from center.
geoM.Rotate(cam.actualAngle) // rotate
geoM.Scale(cam.zoomFactorShake, cam.zoomFactorShake) // apply zoom factor
geoM.Translate(math.Abs(cam.centerOffset.X), math.Abs(cam.centerOffset.Y)) // restore center translation
}
// Draw applies the Camera's geometric transformation then draws the object on the screen with drawing options.
func (cam *Camera) Draw(worldObject *ebiten.Image, worldObjectOps *ebiten.DrawImageOptions, screen *ebiten.Image) {
cam.drawOptions = worldObjectOps
cam.ApplyCameraTransform(&cam.drawOptions.GeoM)
screen.DrawImage(worldObject, cam.drawOptions)
cam.drawOptions.GeoM.Reset()
}
type CameraShakeOptions struct {
// Noise generator for noise types and settings.
Noise *fastnoise.State[float64]
MaxX float64 // Maximum X-axis shake. 0 means disabled
MaxY float64 // Maximum Y-axis shake. 0 means disabled
MaxAngle float64 // Max shake angle (radians). 0 means disabled
MaxZoomFactor float64 // Zoom factor strength [1-0]. 0 means disabled
TimeScale float64 // Noise time domain speed
Decay float64 // Decay for trauma
}