// key events are a way to get input from GLFW.
func keyCallback(w *glfw.Window, key glfw.Key, scancode int, action glfw.Action, mods glfw.ModifierKey) {
//if u only want the on press, do = && && action == glfw.Press
if key == glfw.KeyW && action == glfw.Press {
fmt.Printf("W Pressed!\n")
player.moveUp()
}
if key == glfw.KeyA { //&& action == glfw.Press
fmt.Printf("A Pressed!\n")
if action == glfw.Release {
player.moving_left = false
}
if action == glfw.Press {
player.moving_left = true
}
// player.moveLeft()
}
if key == glfw.KeyS {
fmt.Printf("S Pressed!\n")
player.moveDown()
}
if key == glfw.KeyD {
fmt.Printf("D Pressed!\n")
if action == glfw.Release {
player.moving_right = false
}
if action == glfw.Press {
player.moving_right = true
}
// player.moveRight()
}
if key == glfw.KeyEscape && action == glfw.Press {
w.SetShouldClose(true)
}
}
func (state *State) Render(window *glfw.Window) {
if !state.Dirty {
return
}
state.Dirty = false
state.Reset(window)
state.Time = time.Now()
state.UpdateInput(window)
hue := float32(state.Time.UnixNano()/1e6%360) / 360.0
Highlight = ui.ColorHSLA(hue, 0.7, 0.7, 1.0)
w, h := window.GetSize()
root := &ui.Context{
Backend: state.Backend,
Input: state.Input,
Area: ui.Block(0, 0, float32(w), float32(h)),
}
if root.Input.Mouse.Drag != nil {
if !root.Input.Mouse.Drag(root) {
root.Input.Mouse.Drag = nil
}
}
state.Backend.SetBack(ui.ColorHex(0xEEEEEEFF))
state.Backend.SetFore(ui.ColorHex(0xCCCCCCFF))
state.Backend.SetFontColor(ui.ColorHex(0x000000FF))
view := NewView(state, root, &state.Timeline)
view.Render()
}
func programLoop(window *glfw.Window) {
// the linked shader program determines how the data will be rendered
shaders := compileShaders()
shaderProgram := linkShaders(shaders)
// VAO contains all the information about the data to be rendered
VAO := createTriangleVAO()
for !window.ShouldClose() {
// poll events and call their registered callbacks
glfw.PollEvents()
// perform rendering
gl.ClearColor(0.2, 0.5, 0.5, 1.0)
gl.Clear(gl.COLOR_BUFFER_BIT)
// draw loop
gl.UseProgram(shaderProgram) // ensure the right shader program is being used
gl.BindVertexArray(VAO) // bind data
gl.DrawArrays(gl.TRIANGLES, 0, 3) // perform draw call
gl.BindVertexArray(0) // unbind data (so we don't mistakenly use/modify it)
// end of draw loop
// swap in the rendered buffer
window.SwapBuffers()
}
}
// key events are a way to get input from GLFW.
func keyCallback(w *glfw.Window, key glfw.Key, scancode int, action glfw.Action, mods glfw.ModifierKey) {
//if u only want the on press, do = && && action == glfw.Press
player := game.Player
if key == glfw.KeyW && action == glfw.Press {
fmt.Printf("W Pressed!\n")
player.Jump()
}
if key == glfw.KeyA { //&& action == glfw.Press
fmt.Printf("A Pressed!\n")
player.MoveLeft()
}
if key == glfw.KeyS {
fmt.Printf("S Pressed!\n")
}
if key == glfw.KeyD {
fmt.Printf("D Pressed!\n")
player.MoveRight()
}
if key == glfw.KeyEscape && action == glfw.Press {
w.SetShouldClose(true)
}
}
// mainKeyCallback is the main keyboard input callback for the game
func gameKeyCallback(w *glfw.Window, key glfw.Key, scancode int, action glfw.Action, mods glfw.ModifierKey) {
switch {
// NOTE: For testing purposes, we'll exit on esc button
case key == glfw.KeyEscape && action == glfw.Press:
w.SetShouldClose(true)
}
}
func keyCallback(window *glfw.Window, key glfw.Key, scancode int, action glfw.Action, mods glfw.ModifierKey) {
// When a user presses the escape key, we set the WindowShouldClose property to true,
// which closes the application
if key == glfw.KeyEscape && action == glfw.Press {
window.SetShouldClose(true)
}
}
func onKey(w *glfw.Window, key glfw.Key, scancode int, action glfw.Action, mods glfw.ModifierKey) {
switch {
case key == glfw.KeyEscape && action == glfw.Press,
key == glfw.KeyQ && action == glfw.Press:
w.SetShouldClose(true)
}
}
/* ***************** KEYBOARD INPUT ******************** */
func onKey(w *glfw.Window, key glfw.Key, scancode int,
action glfw.Action, mods glfw.ModifierKey) {
if key == glfw.KeyEscape && action == glfw.Press {
fmt.Println("Close Window")
w.SetShouldClose(true)
}
}
func (state *State) UpdateInput(window *glfw.Window) {
state.Input.Update()
x, y := window.GetCursorPos()
state.Input.Mouse.Position.X = float32(x)
state.Input.Mouse.Position.Y = float32(y)
state.Input.Mouse.Down = window.GetMouseButton(glfw.MouseButtonLeft) == glfw.Press
}
func keyCallback(w *glfw.Window, key glfw.Key, scancode int, action glfw.Action, mods glfw.ModifierKey) {
// Key W == close app
if key == glfw.KeyEscape && action == glfw.Press {
w.SetShouldClose(true)
}
if key == glfw.KeySpace && action == glfw.Press {
fire()
}
}
func (c *chip8) setKeys(window *glfw.Window) {
for k, v := range keyvalues {
if window.GetKey(k) == glfw.Release {
c.key[v] = true
} else {
c.key[v] = false
}
}
}
func onFocus(w *glfw.Window, focused bool) {
if !focused {
for i := range Client.KeyState {
Client.KeyState[i] = false
}
} else if lockMouse {
w.SetInputMode(glfw.CursorMode, glfw.CursorDisabled)
}
}
func drawScene(w *glfw.Window) {
width, height := w.GetFramebufferSize()
ratio := float32(width) / float32(height)
var x1, x2, y1, y2 float32
if ratio > 1 {
x1, x2, y1, y2 = -ratio, ratio, -1, 1
} else {
x1, x2, y1, y2 = -1, 1, -1/ratio, 1/ratio
}
gl.Viewport(0, 0, int32(width), int32(height))
gl.Clear(gl.COLOR_BUFFER_BIT)
// Applies subsequent matrix operations to the projection matrix stack
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity() // replace the current matrix with the identity matrix
gl.Ortho(float64(x1), float64(x2), float64(y1), float64(y2), 1, -1) // multiply the current matrix with an orthographic matrix
// Applies subsequent matrix operations to the modelview matrix stack
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.LineWidth(1)
gl.Begin(gl.LINE) // delimit the vertices of a primitive or a group of like primitives
gl.Color3f(0, 0, 0) // set the current color
gl.Vertex3f(0, y1, 0)
gl.Vertex3f(0, y2, 0)
gl.Vertex3f(x1, 0, 0)
gl.Vertex3f(x2, 0, 0)
gl.End()
gl.Rotatef(float32(glfw.GetTime()*50), 0, 0, 1) // multiply the current matrix by a rotation matrix
s := float32(.95)
gl.Begin(gl.TRIANGLES)
gl.Color3f(1, 0, 0) // set the current color
gl.Vertex3f(0, s, 0) // specify a vertex
gl.Color3f(0, 1, 0)
gl.Vertex3f(s*.866, s*-0.5, 0)
gl.Color3f(0, 0, 1)
gl.Vertex3f(s*-.866, s*-0.5, 0)
gl.End()
gl.LineWidth(5)
gl.Begin(gl.LINE_LOOP)
for i := float64(0); i < 2*math.Pi; i += .05 {
r, g, b := hsb2rgb(float32(i/(2*math.Pi)), 1, 1)
gl.Color3f(r, g, b)
gl.Vertex3f(s*float32(math.Sin(i)), s*float32(math.Cos(i)), 0)
}
gl.End()
}
// onResize sets up a simple 2d ortho context based on the window size
func onResize(window *glfw.Window, w, h int) {
w, h = window.GetSize() // query window to get screen pixels
width, height := window.GetFramebufferSize()
gl.Viewport(0, 0, int32(width), int32(height))
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, float64(w), 0, float64(h), -1, 1)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.ClearColor(1, 1, 1, 1)
}
func drawLoop(win *glfw.Window, vao uint32, shader uint32) {
for !win.ShouldClose() {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.BindVertexArray(vao)
gl.UseProgram(shader)
gl.DrawArrays(gl.TRIANGLES, 0, 3)
glfw.PollEvents()
win.SwapBuffers()
}
}
func initOpenGl(window *glfw.Window, w, h int) {
w, h = window.GetSize() // query window to get screen pixels
width, height := window.GetFramebufferSize()
gl.Viewport(0, 0, width, height)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, float64(w), 0, float64(h), -1, 1)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.ClearColor(.25, .88, .83, 1) // turquoise
}
func onKey(window *glfw.Window, k glfw.Key, s int, action glfw.Action, mods glfw.ModifierKey) {
if action != glfw.Press {
return
}
switch glfw.Key(k) {
case glfw.KeyEscape:
window.SetShouldClose(true)
default:
return
}
}
func (c *chip8) Chip8_FX0A(window *glfw.Window) {
//FX0A: A key press is awaited, and then stored in VX.
glfw.WaitEvents()
for k, v := range keyvalues {
if window.GetKey(k) == glfw.Press {
c.v[(c.opcode & 0x0F00) >> 8] = v
c.key[v] = true
c.pc += 2
break
}
}
}
func render(w *glfw.Window, program uint32) {
gl.ClearColor(0, 0, 0, 1)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.UseProgram(program)
gl.BindVertexArray(firstSprite.GetVAO())
gl.DrawArrays(gl.TRIANGLES, 0, 6)
//Swap buffers
w.SwapBuffers()
glfw.PollEvents()
gl.UseProgram(0)
}
func (state *State) Reset(window *glfw.Window) {
gl.ClearColor(1, 1, 1, 1)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.Disable(gl.DEPTH)
gl.Enable(gl.FRAMEBUFFER_SRGB)
width, height := window.GetSize()
gl.Viewport(0, 0, int32(width), int32(height))
gl.Ortho(0, float64(width), float64(height), 0, 30, -30)
}
func (state *State) Render(window *glfw.Window) {
state.Reset(window)
state.UpdateInput(window)
w, h := window.GetSize()
root := &ui.Context{
Backend: state.Backend,
Input: state.Input,
Area: ui.Block(0, 0, float32(w), float32(h)),
}
if root.Input.Mouse.Drag != nil {
if !root.Input.Mouse.Drag(root) {
root.Input.Mouse.Drag = nil
}
}
state.Backend.SetBack(ui.ColorHex(0xEEEEEEFF))
state.Backend.SetFore(ui.ColorHex(0xCCCCCCFF))
state.Backend.SetFontColor(ui.ColorHex(0x000000FF))
mm := &MainMenu{}
ui.Buttons{
{"☺", mm.File},
{"Load", mm.Load},
{"Save", mm.Save},
{"Quit", mm.Quit},
}.DoDynamic(ui.LayoutToRight(50, root.Top(20).Panel()))
boxbounds := ui.Bounds{
state.Box,
state.Box.Offset(ui.Point{30, 30})}
runtime.ReadMemStats(&state.MemStats)
root.Right(state.SidePanelSize).Reflect("Mem", &state.MemStats)
ui.SplitterX(root.Right(5), func(delta float32) {
state.SidePanelSize -= delta
})
box := root.Child(boxbounds)
box.Backend.SetBack(ui.ColorHex(0xFF88EEFF))
box.Backend.SetFore(ui.ColorHex(0xFF88EEFF))
box.Backend.Fill(box.Area)
box.Backend.Stroke(box.Area)
ui.DoDragXY(box, func(dx, dy float32) {
state.Box.X += dx
state.Box.Y += dy
})
}
func keypress(window *glfw.Window, key glfw.Key, scancode int, action glfw.Action, mods glfw.ModifierKey) {
// Pressing escape will close the window
if key == glfw.KeyEscape {
window.SetShouldClose(true)
}
if action == glfw.Release {
s := strconv.Itoa(scancode)
if key == glfw.KeyA && mods == glfw.ModShift {
fmt.Println("Key 'A' pressed!")
} else if key == glfw.KeyA {
fmt.Println("Key 'a' pressed!")
} else {
fmt.Println("Key '" + s + "' pressed!" + s)
}
}
}
func NewControllerManager(window *glfw.Window) *ControllerManager {
var controllerList []Controller
c := &ControllerManager{controllerList}
window.SetKeyCallback(c.KeyCallback)
window.SetMouseButtonCallback(c.MouseButtonCallback)
window.SetCursorPosCallback(c.CursorPosCallback)
window.SetScrollCallback(c.ScrollCallback)
return c
}
// inputUpdate handles input actions that are dependent on the delta between frames.
// (e.g. how much you move depends on the time delta since the last update)
func inputUpdate(w *glfw.Window, delta float32) {
for key, cb := range activeKeyboard.keyBindings {
if w.GetKey(key) == glfw.Press && cb != nil {
cb(delta)
}
}
// if the joystick is still connected, then we do the joystick polling
// TODO: for now, we're just working with Joystick1 as hardcoded
if glfw.JoystickPresent(glfw.Joystick1) {
buttons := glfw.GetJoystickButtons(glfw.Joystick1)
axes := glfw.GetJoystickAxes(glfw.Joystick1)
//groggy.Logsf("DEBUG", "inputUpdate: %d %d %d %d %d %d %d %d %d %d %d %d %d %d ", buttons[0], buttons[1], buttons[2], buttons[3], buttons[4],
// buttons[5], buttons[6], buttons[7], buttons[8], buttons[9],
// buttons[10], buttons[11], buttons[12], buttons[13])
// process the buttons
for buttonId, cb := range activeJoystick.buttonBindings {
if buttons[buttonId] > 0 && cb != nil {
cb(delta)
}
}
// process the axis values
for _, mapping := range activeJoystick.axisBindings {
if mapping.Callback == nil {
continue
}
v := axes[mapping.Id]
if v >= mapping.Min && v <= mapping.Max {
scale := mapping.Max - mapping.Min
if mapping.NegativeMapping {
// use the Max value here since NegativeMapping implies a negative ranage for the mapping
v = (float32(math.Abs(float64(v))) - float32(math.Abs(float64(mapping.Max)))) / scale
} else {
v = (v - mapping.Min) / scale
}
mapping.Callback(delta * v)
}
} // axisBindings
}
}
// createRenderer creates a new graphics Renderer engine and does
// any initializiation necessary.
//
// NOTE: in the future, this can create either a forward or deferred
// renderer with more advanced options.
func createRenderer(mainWindow *glfw.Window) (*GameRenderer, error) {
gr := new(GameRenderer)
gr.Shaders = make(map[string]*fizzle.RenderShader)
// create the renderer itself
windowW, windowH := mainWindow.GetFramebufferSize()
forwardRenderer := fizzle.NewForwardRenderer(mainWindow)
forwardRenderer.Init(int32(windowW), int32(windowH))
gr.Renderer = forwardRenderer
gr.MainWindow = mainWindow
// load the landscape diffuse shader
shader, err := fizzle.LoadShaderProgramFromFiles(landscapeShaderPath, nil)
if err != nil {
return nil, fmt.Errorf("Failed to compile and link the diffuse shader program!\n%v", err)
}
gr.Shaders["landscape"] = shader
// load the diffuse shader
shader, err = fizzle.LoadShaderProgramFromFiles(diffuseShaderPath, nil)
if err != nil {
return nil, fmt.Errorf("Failed to compile and link the diffuse shader program!\n%v", err)
}
gr.Shaders["diffuse"] = shader
// put a test light in the renderer
light := fizzle.NewLight()
//light.Position = mgl.Vec3{8.0, 8.0, 8.0}
light.DiffuseColor = mgl.Vec4{1.0, 1.0, 1.0, 1.0}
light.Direction = mgl.Vec3{0.1, -1.0, -0.1}
light.DiffuseIntensity = 0.6
light.AmbientIntensity = 0.4
//light.Attenuation = 1.0
forwardRenderer.ActiveLights[0] = light
// setup the camera to look at the cube
gr.camera = fizzle.NewOrbitCamera(mgl.Vec3{0.0, 0.0, 0.0}, mgl.DegToRad(35.0), 16.0, mgl.DegToRad(90.0))
// set some OpenGL flags
gl.Enable(gl.CULL_FACE)
gl.Enable(gl.DEPTH_TEST)
return gr, nil
}
func (c *ChatUI) handleKey(w *glfw.Window, key glfw.Key, scancode int, action glfw.Action, mods glfw.ModifierKey) {
if (key == glfw.KeyEscape || key == glfw.KeyEnter) && action == glfw.Release {
if key == glfw.KeyEnter && len(c.inputLine) != 0 {
Client.network.Write(&protocol.ChatMessage{string(c.inputLine)})
}
// Return control back to the default
c.enteringText = false
c.inputLine = c.inputLine[:0]
lockMouse = true
w.SetInputMode(glfw.CursorMode, glfw.CursorDisabled)
w.SetCharCallback(nil)
return
}
if key == glfw.KeyBackspace && action != glfw.Release {
if len(c.inputLine) > 0 {
c.inputLine = c.inputLine[:len(c.inputLine)-1]
}
}
}
func onKey(window *glfw.Window, k glfw.Key, s int, action glfw.Action, mods glfw.ModifierKey) {
if action != glfw.Press {
return
}
// disable if event handlers are flagged off
if birdCollided && (k != glfw.KeyEscape) {
return
}
switch glfw.Key(k) {
case glfw.KeyEscape:
window.SetShouldClose(true)
case glfw.KeySpace:
jump()
default:
return
}
}
func NewEventHandler(w *glfw.Window) (e *EventHandler) {
e = &EventHandler{
Events: make(chan Event, 100),
window: w,
}
// See http://www.glfw.org/docs/latest/input.html#input_keyboard
w.SetInputMode(glfw.StickyKeysMode, 1)
w.SetCursorPosCallback(e.onMouseMove)
w.SetKeyCallback(e.onKey)
w.SetMouseButtonCallback(e.onMouseButton)
return
}
func OnKey(window *glfw.Window, k glfw.Key, s int, action glfw.Action, mods glfw.ModifierKey) {
if action != glfw.Press {
return
}
nx, ny := game.PlayerX, game.PlayerY
switch k {
case glfw.KeyLeft:
nx--
case glfw.KeyRight:
nx++
case glfw.KeyUp:
ny++
case glfw.KeyDown:
ny--
case glfw.KeyEscape:
window.SetShouldClose(true)
}
if nx >= 0 && nx < game.Width && ny >= 0 && ny < game.Height && game.Tiles[(ny*game.Width)+nx] == 226 {
game.PlayerX, game.PlayerY = nx, ny
}
}
func painalluksetOhjaimiksi(ikkuna *glfw.Window) (ohjaimet Ohjaimet) {
ohjaimet.Kaasu = ikkuna.GetKey(glfw.KeyUp) == glfw.Press
ohjaimet.Liipaisin = ikkuna.GetKey(glfw.KeySpace) == glfw.Press
if ikkuna.GetKey(glfw.KeyLeft) == glfw.Press {
ohjaimet.Ratti += 1
}
if ikkuna.GetKey(glfw.KeyRight) == glfw.Press {
ohjaimet.Ratti -= 1
}
return
}