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
|
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package gldriver provides an OpenGL driver for accessing a screen.
package gldriver
import (
"encoding/binary"
"fmt"
"math"
"golang.org/x/exp/shiny/driver/internal/errscreen"
"golang.org/x/exp/shiny/screen"
"golang.org/x/image/math/f64"
"golang.org/x/mobile/gl"
)
// Main is called by the program's main function to run the graphical
// application.
//
// It calls f on the Screen, possibly in a separate goroutine, as some OS-
// specific libraries require being on 'the main thread'. It returns when f
// returns.
func Main(f func(screen.Screen)) {
if err := main(f); err != nil {
f(errscreen.Stub(err))
}
}
func mul(a, b f64.Aff3) f64.Aff3 {
return f64.Aff3{
a[0]*b[0] + a[1]*b[3],
a[0]*b[1] + a[1]*b[4],
a[0]*b[2] + a[1]*b[5] + a[2],
a[3]*b[0] + a[4]*b[3],
a[3]*b[1] + a[4]*b[4],
a[3]*b[2] + a[4]*b[5] + a[5],
}
}
func writeAff3(u gl.Uniform, a f64.Aff3) {
var m [9]float32
m[0*3+0] = float32(a[0*3+0])
m[0*3+1] = float32(a[1*3+0])
m[0*3+2] = 0
m[1*3+0] = float32(a[0*3+1])
m[1*3+1] = float32(a[1*3+1])
m[1*3+2] = 0
m[2*3+0] = float32(a[0*3+2])
m[2*3+1] = float32(a[1*3+2])
m[2*3+2] = 1
gl.UniformMatrix3fv(u, m[:])
}
// f32Bytes returns the byte representation of float32 values in the given byte
// order. byteOrder must be either binary.BigEndian or binary.LittleEndian.
func f32Bytes(byteOrder binary.ByteOrder, values ...float32) []byte {
le := false
switch byteOrder {
case binary.BigEndian:
case binary.LittleEndian:
le = true
default:
panic(fmt.Sprintf("invalid byte order %v", byteOrder))
}
b := make([]byte, 4*len(values))
for i, v := range values {
u := math.Float32bits(v)
if le {
b[4*i+0] = byte(u >> 0)
b[4*i+1] = byte(u >> 8)
b[4*i+2] = byte(u >> 16)
b[4*i+3] = byte(u >> 24)
} else {
b[4*i+0] = byte(u >> 24)
b[4*i+1] = byte(u >> 16)
b[4*i+2] = byte(u >> 8)
b[4*i+3] = byte(u >> 0)
}
}
return b
}
func compileProgram(vSrc, fSrc string) (gl.Program, error) {
program := gl.CreateProgram()
if program.Value == 0 {
return gl.Program{}, fmt.Errorf("gldriver: no programs available")
}
vertexShader, err := compileShader(gl.VERTEX_SHADER, vSrc)
if err != nil {
return gl.Program{}, err
}
fragmentShader, err := compileShader(gl.FRAGMENT_SHADER, fSrc)
if err != nil {
gl.DeleteShader(vertexShader)
return gl.Program{}, err
}
gl.AttachShader(program, vertexShader)
gl.AttachShader(program, fragmentShader)
gl.LinkProgram(program)
// Flag shaders for deletion when program is unlinked.
gl.DeleteShader(vertexShader)
gl.DeleteShader(fragmentShader)
if gl.GetProgrami(program, gl.LINK_STATUS) == 0 {
defer gl.DeleteProgram(program)
return gl.Program{}, fmt.Errorf("gldriver: program compile: %s", gl.GetProgramInfoLog(program))
}
return program, nil
}
func compileShader(shaderType gl.Enum, src string) (gl.Shader, error) {
shader := gl.CreateShader(shaderType)
if shader.Value == 0 {
return gl.Shader{}, fmt.Errorf("gldriver: could not create shader (type %v)", shaderType)
}
gl.ShaderSource(shader, src)
gl.CompileShader(shader)
if gl.GetShaderi(shader, gl.COMPILE_STATUS) == 0 {
defer gl.DeleteShader(shader)
return gl.Shader{}, fmt.Errorf("gldriver: shader compile: %s", gl.GetShaderInfoLog(shader))
}
return shader, nil
}
|
