138 lines
3.0 KiB
Go
138 lines
3.0 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"image"
|
|
"os"
|
|
"time"
|
|
|
|
_ "image/png"
|
|
|
|
"github.com/faiface/pixel"
|
|
"github.com/faiface/pixel/pixelgl"
|
|
)
|
|
|
|
// InstallShader ...
|
|
func InstallShader(w *pixelgl.Window, weight *float32) {
|
|
wc := w.GetCanvas()
|
|
wc.SetFragmentShader(edgeDetectionFragShader)
|
|
wc.BindUniform("u_weight", weight)
|
|
wc.UpdateShader()
|
|
}
|
|
|
|
func loadPicture(path string) (pixel.Picture, error) {
|
|
file, err := os.Open(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer file.Close()
|
|
img, _, err := image.Decode(file)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return pixel.PictureDataFromImage(img), nil
|
|
}
|
|
|
|
const (
|
|
windowWidth = 600
|
|
windowHeight = 450
|
|
foregroundHeight = 149
|
|
// This is the scrolling speed (pixels per second)
|
|
// Negative values will make background to scroll to the left,
|
|
// positive to the right.
|
|
backgroundSpeed = -60
|
|
foregroundSpeed = -120
|
|
)
|
|
|
|
func run() {
|
|
fmt.Println("Use +/- to adjust weight")
|
|
|
|
cfg := pixelgl.WindowConfig{
|
|
Title: "Parallax scrolling demo",
|
|
Bounds: pixel.R(0, 0, windowWidth, windowHeight),
|
|
VSync: true,
|
|
}
|
|
win, err := pixelgl.NewWindow(cfg)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
var uWeight float32
|
|
|
|
uWeight = 4.0
|
|
|
|
InstallShader(win, &uWeight)
|
|
|
|
// Pic must have double the width of the window, as it will scroll to the left or right
|
|
picBackground, err := loadPicture("background.png")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
picForeground, err := loadPicture("foreground.png")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
background := NewScrollingBackground(picBackground, windowWidth, windowHeight, backgroundSpeed)
|
|
foreground := NewScrollingBackground(picForeground, windowWidth, foregroundHeight, foregroundSpeed)
|
|
win.SetTitle(fmt.Sprint("Weight: ", uWeight))
|
|
last := time.Now()
|
|
for !win.Closed() {
|
|
dt := time.Since(last).Seconds()
|
|
last = time.Now()
|
|
background.Update(win, dt)
|
|
foreground.Update(win, dt)
|
|
|
|
if win.Pressed(pixelgl.KeyEqual) {
|
|
uWeight += 0.1
|
|
win.SetTitle(fmt.Sprint("Weight: ", uWeight))
|
|
}
|
|
if win.Pressed(pixelgl.KeyMinus) {
|
|
uWeight -= 0.1
|
|
win.SetTitle(fmt.Sprint("Weight: ", uWeight))
|
|
}
|
|
|
|
win.Update()
|
|
|
|
}
|
|
}
|
|
|
|
func main() {
|
|
pixelgl.Run(run)
|
|
}
|
|
|
|
var edgeDetectionFragShader = `
|
|
#version 330 core
|
|
|
|
#ifdef GL_ES
|
|
precision mediump float;
|
|
precision mediump int;
|
|
#endif
|
|
|
|
in vec2 texcoords;
|
|
|
|
out vec4 fragColor;
|
|
|
|
uniform vec4 u_texbounds;
|
|
uniform sampler2D u_texture;
|
|
uniform float u_weight;
|
|
|
|
void main(void)
|
|
{
|
|
vec2 t = (texcoords - u_texbounds.xy) / u_texbounds.zw;
|
|
vec2 onePixel = vec2(1.0, 1.0) / u_texbounds.zw;
|
|
vec4 colorSum =
|
|
texture(u_texture, t + onePixel * vec2(-1, -1)) * -0.1 +
|
|
texture(u_texture, t + onePixel * vec2( 0, -1)) * -0.1 +
|
|
texture(u_texture, t + onePixel * vec2( 1, -1)) * -0.1 +
|
|
texture(u_texture, t + onePixel * vec2(-1, 0)) * -0.1 +
|
|
texture(u_texture, t + onePixel * vec2( 0, 0)) * 8.0 +
|
|
texture(u_texture, t + onePixel * vec2( 1, 0)) * -0.1 +
|
|
texture(u_texture, t + onePixel * vec2(-1, 1)) * -0.1 +
|
|
texture(u_texture, t + onePixel * vec2( 0, 1)) * -0.1 +
|
|
texture(u_texture, t + onePixel * vec2( 1, 1)) * -0.1 ;
|
|
|
|
fragColor = (colorSum / u_weight).rgba;
|
|
}
|
|
`
|