func (this *WorldRenderer) Render(ww *gamestate.World, options *settings.BoolOptions, window *sdl.Window) {
camera := ww.Player.Camera
p0 := camera.Pos4f()
w, h := window.GetSize()
camera.MoveRelative(mgl.Vec4{-0.1, 0, 0, 0})
this.View = (ww.PortalTransform(p0, camera.Pos4f()).Mul4(camera.Model())).Inv()
viewport := Viewport{0, 0, w / 2, h}
viewport.Activate()
this.render(ww, options, viewport, 0, nil)
camera.MoveRelative(mgl.Vec4{+0.2, 0, 0, 0})
this.View = (ww.PortalTransform(p0, camera.Pos4f()).Mul4(camera.Model())).Inv()
viewport.X = w / 2
viewport.Activate()
this.render(ww, options, viewport, 0, nil)
gl.Viewport(0, 0, w, h)
gl.ActiveTexture(gl.TEXTURE0)
this.Framebuffer[0].RenderTexture.Bind(gl.TEXTURE_RECTANGLE)
this.ScreenQuadRenderer.Render(this.ScreenQuad, this.Proj, this.View, this.ClippingPlane_ws, nil)
if this.screenShot {
this.screenShot = false
helpers.SaveTexture(gl.TEXTURE_RECTANGLE, 0, "screenshot.png")
}
}
func (this *WorldRenderer) Resize(width, height int) {
this.Proj = mgl.Perspective(90, float32(width)/float32(height), 0.3, 1000)
gl.Viewport(0, 0, width, height)
for _, fb := range this.Framebuffer {
fb.Resize(width, height)
}
}
func onResize(w, h int) {
if h <= 0 {
h = 1
}
if w <= 0 {
w = 1
}
Height = h
Width = w
gl.Viewport(0, 0, w, h)
if GetScene() != nil && CurrentCamera() != nil {
CurrentCamera().UpdateResolution()
}
}
func (drawer *SpriteDrawer) Draw(sprites []Sprite) {
gl.Viewport(0, 0, drawer.width, drawer.height)
if len(sprites) == 0 {
return
}
drawer.Use()
drawer.Texture.Bind(gl.TEXTURE_2D_ARRAY)
tmp := drawer.GetTransform().To32()
drawer.camera_uniform.UniformMatrix2x3f(false, &tmp)
vertexbuffer := gl.GenBuffer()
defer vertexbuffer.Delete()
vertexbuffer.Bind(gl.ARRAY_BUFFER)
stride := int(unsafe.Sizeof(sprites[0]))
gl.BufferData(gl.ARRAY_BUFFER, stride*len(sprites), sprites, gl.STREAM_DRAW)
var transform1, transform2, texcoords, texlevel gl.AttribLocation
transform1 = 0
transform2 = 1
texcoords = 2
texlevel = 3
transform1.AttribPointer(3, gl.FLOAT, false, stride, unsafe.Offsetof(sprites[0].Transform))
transform2.AttribPointer(3, gl.FLOAT, false, stride, unsafe.Offsetof(sprites[0].Transform)+unsafe.Sizeof(sprites[0].Transform[0])*3)
texcoords.AttribPointer(4, gl.FLOAT, false, stride, unsafe.Offsetof(sprites[0].TextureLeft))
texlevel.AttribPointer(1, gl.FLOAT, false, stride, unsafe.Offsetof(sprites[0].Layer))
transform1.EnableArray()
transform2.EnableArray()
texcoords.EnableArray()
texlevel.EnableArray()
gl.DrawArrays(gl.POINTS, 0, len(sprites))
transform1.DisableArray()
transform2.DisableArray()
texcoords.DisableArray()
texlevel.DisableArray()
}
func (v *Video) Reshape(width int, height int) {
x_offset := 0
y_offset := 0
r := ((float64)(height)) / ((float64)(width))
if r > 0.9375 { // Height taller than ratio
h := (int)(math.Floor((float64)(0.9375 * (float64)(width))))
y_offset = (height - h) / 2
height = h
} else if r < 0.9375 { // Width wider
w := (int)(math.Floor((float64)((256.0 / 240.0) * (float64)(height))))
x_offset = (width - w) / 2
width = w
}
v.width = width
v.height = height
gl.Viewport(x_offset, y_offset, width, height)
}
func (this *Viewport) Activate() {
gl.Viewport(this.X, this.Y, this.W, this.H)
}
func main() {
glfw.SetErrorCallback(errorCallback)
// lock glfw/gl calls to a single thread
runtime.LockOSThread()
runtime.GOMAXPROCS(8) // Render, read commands, send input, extra for file loading, etc
if !glfw.Init() {
panic("Could not init glfw!")
}
defer glfw.Terminate()
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True)
glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile)
window, err := glfw.CreateWindow(800, 600, "Example", nil, nil)
if err != nil {
panic(err)
}
window.SetFramebufferSizeCallback(func(w *glfw.Window, width, height int) {
fmt.Printf("Framebuffer size is now %vx%v\n", width, height)
// Keep aspect ratio from camwidth/camheight
camRatio := camWidth / camHeight
bufRatio := float32(width) / float32(height)
var newWidth, newHeight float32
switch {
case camRatio > bufRatio:
newHeight = float32(width) / camRatio
newWidth = float32(width)
case bufRatio > camRatio:
newWidth = float32(height) * camRatio
newHeight = float32(height)
}
fmt.Printf("Viewport size is now %vx%v; cam ratio is %v; viewport ratio is %v;\n", newWidth, newHeight, camRatio, newWidth/newHeight)
gl.Viewport((width-int(newWidth))/2, (height-int(newHeight))/2, int(newWidth), int(newHeight))
})
defer window.Destroy()
window.MakeContextCurrent()
glfw.SwapInterval(1)
gl.Init()
// Enable blending
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
vao := gl.GenVertexArray()
vao.Bind()
vbo := gl.GenBuffer()
vbo.Bind(gl.ARRAY_BUFFER)
verticies := []float32{-0.5, 0.5,
0.5, 0.5,
0.5, -0.5,
-0.5, -0.5}
gl.BufferData(gl.ARRAY_BUFFER, len(verticies)*4, verticies, gl.STATIC_DRAW)
vertex_shader := gl.CreateShader(gl.VERTEX_SHADER)
vertex_shader.Source(vertex)
vertex_shader.Compile()
fmt.Println(vertex_shader.GetInfoLog())
defer vertex_shader.Delete()
fragment_shader := gl.CreateShader(gl.FRAGMENT_SHADER)
fragment_shader.Source(fragment)
fragment_shader.Compile()
fmt.Println(fragment_shader.GetInfoLog())
defer fragment_shader.Delete()
program := gl.CreateProgram()
program.AttachShader(vertex_shader)
program.AttachShader(fragment_shader)
program.BindFragDataLocation(0, "outColor")
program.Link()
program.Use()
defer program.Delete()
positionAttrib := program.GetAttribLocation("position")
positionAttrib.AttribPointer(2, gl.FLOAT, false, 0, nil)
positionAttrib.EnableArray()
defer positionAttrib.DisableArray()
modelMat := program.GetUniformLocation("modelView")
projMat := program.GetUniformLocation("projection")
spriteSize := program.GetUniformLocation("size")
cmd := exec.Command(os.Args[1], os.Args[2:]...)
stdoutReader, stdoutWriter := io.Pipe()
cmd.Stdout = stdoutWriter
input := bufio.NewReader(stdoutReader)
stdinReader, stdinWriter := io.Pipe()
cmd.Stdin = stdinReader
stderr, err := cmd.StderrPipe()
chkErr(err)
go io.Copy(os.Stderr, stderr)
err = cmd.Start()
chkErr(err)
window.SetKeyCallback(handleKey)
go func() {
runtime.LockOSThread()
for !window.ShouldClose() {
sendInput(stdinWriter)
//fmt.Fprintf(stdinWriter, "T %v\n", time.Now())
<-ticks
readCommands(input)
}
}()
frameCnt := 0
queueDepth := 0
then := time.Now()
for !window.ShouldClose() {
frameCnt++
queueDepth += len(commandBus)
if frameCnt%120 == 0 {
fmt.Printf("Queue depth: %v. Render time: %v. Decode time: %v.\n", queueDepth/120, time.Since(then)/120, decodeTime/time.Duration(decodes))
queueDepth = 0
then = time.Now()
decodeTime = time.Duration(0)
decodes = 0
}
for len(commandBus) > 0 {
(<-commandBus)()
}
halfwidth := camWidth / 2.0
halfheight := camHeight / 2.0
projection := mathgl.Ortho2D(camera.x-halfwidth, camera.x+halfwidth, camera.y+halfheight, camera.y-halfheight)
projection = mathgl.Scale3D(camera.sx, camera.sy, 1).Mul4(projection)
projection = mathgl.HomogRotate3DZ(camera.rot).Mul4(projection)
projMat.UniformMatrix4f(false, (*[16]float32)(&projection))
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
for _, sprite := range sprites {
sMat := mathgl.Scale3D(sprite.sx, sprite.sy, 1)
sMat = mathgl.HomogRotate3DZ(sprite.rot).Mul4(sMat)
sMat = mathgl.Translate3D(sprite.x, sprite.y, sprite.z).Mul4(sMat)
// temp hack bank in
sprite.bank = 1
sMap := findSMap(sprite.smap)
spriteSize.Uniform2f(float32(sMap.getWidth()*sprite.cellwidth), float32(sMap.getHeight()*sprite.cellheight))
modelMat.UniformMatrix4f(false, (*[16]float32)(&sMat))
gl.DrawArrays(gl.TRIANGLE_FAN, 0, 4)
}
window.SwapBuffers()
glfw.PollEvents()
if window.GetKey(glfw.KeyEscape) == glfw.Press {
window.SetShouldClose(true)
}
}
}
