func start() {
var err error
glimage.program, err = CreateProgram(vertexShader, fragmentShader)
if err != nil {
panic(err)
}
glimage.quadXY = gl.CreateBuffer()
glimage.quadUV = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, glimage.quadXY)
gl.BufferData(gl.ARRAY_BUFFER, quadXYCoords, gl.STATIC_DRAW)
gl.BindBuffer(gl.ARRAY_BUFFER, glimage.quadUV)
gl.BufferData(gl.ARRAY_BUFFER, quadUVCoords, gl.STATIC_DRAW)
glimage.pos = gl.GetAttribLocation(glimage.program, "pos")
glimage.mvp = gl.GetUniformLocation(glimage.program, "mvp")
glimage.uvp = gl.GetUniformLocation(glimage.program, "uvp")
glimage.inUV = gl.GetAttribLocation(glimage.program, "inUV")
glimage.textureSample = gl.GetUniformLocation(glimage.program, "textureSample")
texmap.Lock()
defer texmap.Unlock()
for key, tex := range texmap.texs {
texmap.init(key)
tex.needsUpload = true
}
}
func (e *Engine) Start() {
var err error
e.shader.program, err = LoadProgram("shader.v.glsl", "shader.f.glsl")
if err != nil {
panic(fmt.Sprintln("LoadProgram failed:", err))
}
e.shape.buf = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, e.shape.buf)
gl.BufferData(gl.ARRAY_BUFFER, cubeData, gl.STATIC_DRAW)
fmt.Println(len(cubeData))
e.shader.vertCoord = gl.GetAttribLocation(e.shader.program, "vertCoord")
e.shader.projection = gl.GetUniformLocation(e.shader.program, "projection")
e.shader.view = gl.GetUniformLocation(e.shader.program, "view")
e.shader.modelx = gl.GetUniformLocation(e.shader.program, "modelx")
e.shader.modely = gl.GetUniformLocation(e.shader.program, "modely")
e.shader.color = gl.GetAttribLocation(e.shader.program, "color")
e.shape.colorbuf = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, e.shape.colorbuf)
gl.BufferData(gl.ARRAY_BUFFER, colorData, gl.STATIC_DRAW)
gl.VertexAttribPointer(e.shader.color, colorsPerVertex, gl.FLOAT, false, 4, 0) //更新color值
gl.DrawArrays(gl.TRIANGLES, 0, vertexCount)
e.started = time.Now()
}
func (video *Video) initGL() {
log.Print("Initing")
video.fpsmanager = gfx.NewFramerate()
video.fpsmanager.SetFramerate(60)
gl.ClearColor(0.0, 0.0, 0.0, 1.0)
gl.Enable(gl.CULL_FACE)
gl.Enable(gl.DEPTH_TEST)
log.Print("Creating program")
video.prog = createProgram(vertShaderSrcDef, fragShaderSrcDef)
log.Print("Attrib loc 1")
posAttrib := attribLocation(video.prog, "vPosition")
log.Print("Attrib loc 2")
texCoordAttr := attribLocation(video.prog, "vTexCoord")
log.Print("Uniform loc 1")
paletteLoc := uniformLocation(video.prog, "palette")
log.Print("Uniform loc 2")
video.textureUni = uniformLocation(video.prog, "texture")
log.Print("Gen Texture")
video.texture = genTexture()
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, video.texture)
log.Print("TexParam")
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
gl.UseProgram(video.prog)
gl.EnableVertexAttribArray(posAttrib)
gl.EnableVertexAttribArray(texCoordAttr)
gl.Uniform3iv(paletteLoc, nes.SPaletteRgb)
log.Print("VertBO")
vertVBO := genBuffer()
checkGLError()
gl.BindBuffer(gl.ARRAY_BUFFER, vertVBO)
verts := f32.Bytes(binary.LittleEndian, -1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, 1.0, -1.0, 1.0)
gl.BufferData(gl.ARRAY_BUFFER, verts, gl.STATIC_DRAW)
textCoorBuf := genBuffer()
checkGLError()
gl.BindBuffer(gl.ARRAY_BUFFER, textCoorBuf)
texVerts := f32.Bytes(binary.LittleEndian, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0)
gl.BufferData(gl.ARRAY_BUFFER, texVerts, gl.STATIC_DRAW)
gl.VertexAttribPointer(posAttrib, 2, gl.FLOAT, false, 0, 0)
gl.VertexAttribPointer(texCoordAttr, 2, gl.FLOAT, false, 0, 0)
log.Print("Started")
}
func (shape *StaticShape) Buffer() {
data := shape.Bytes()
if len(data) > 0 {
gl.BindBuffer(gl.ARRAY_BUFFER, shape.VBO)
gl.BufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW)
}
if len(shape.indices) > 0 {
data = EncodeObjects(0, len(shape.indices), NewDimSlice(1, shape.indices))
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, shape.IBO)
gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, data, gl.STATIC_DRAW)
}
}
func (e *Engine) Start() {
var err error
e.shader.program, err = LoadProgram("shader.v.glsl", "shader.f.glsl")
if err != nil {
panic(fmt.Sprintln("LoadProgram failed:", err))
}
e.shader.models, err = wavefront.Read("spiritframe.obj")
check(err)
e.shader.projectionmatrix = gl.GetUniformLocation(e.shader.program, "u_projectionMatrix")
e.shader.viewmatrix = gl.GetUniformLocation(e.shader.program, "u_viewMatrix")
e.shader.modelmatrix = gl.GetUniformLocation(e.shader.program, "u_modelMatrix")
e.shader.normalmatrix = gl.GetUniformLocation(e.shader.program, "u_normalMatrix")
e.shader.lightdir = gl.GetUniformLocation(e.shader.program, "u_lightDirection")
e.shader.lightmatrix = gl.GetUniformLocation(e.shader.program, "u_lightmatrix")
e.shader.vertCoord = gl.GetAttribLocation(e.shader.program, "a_vertex")
e.shader.normal = gl.GetAttribLocation(e.shader.program, "a_normal")
e.shader.texcoord = gl.GetAttribLocation(e.shader.program, "a_texCoord")
for _, model := range e.shader.models {
for _, group := range model.Groups {
//颜色
color := group.Material.Ambient
//顶点
data := f32.Bytes(binary.LittleEndian, group.Vertexes...)
vertexCount := len(group.Vertexes) / 3
databuf := gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, databuf)
gl.BufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW)
//UV坐标
textcoords := f32.Bytes(binary.LittleEndian, group.Textcoords...)
uvbuf := gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, uvbuf)
gl.BufferData(gl.ARRAY_BUFFER, textcoords, gl.STATIC_DRAW)
//发现坐标
normals := f32.Bytes(binary.LittleEndian, group.Normals...)
normalbuf := gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, normalbuf)
gl.BufferData(gl.ARRAY_BUFFER, normals, gl.STATIC_DRAW)
tex, _ := LoadTexture(group.Material.Texturefile)
e.shape.Objs = append(e.shape.Objs, Obj{vcount: vertexCount, coord: databuf, color: color, uvcoord: uvbuf, tex: tex, normal: normalbuf})
}
}
}
func (e *Engine) Start() {
var err error
e.shader.program, err = LoadProgram("shader.v.glsl", "shader.f.glsl")
if err != nil {
panic(fmt.Sprintln("LoadProgram failed:", err))
}
e.shader.models, err = wavefront.Read("girl.obj")
check(err)
e.shader.vertCoord = gl.GetAttribLocation(e.shader.program, "vertCoord")
e.shader.vertTexCoord = gl.GetAttribLocation(e.shader.program, "vertTexCoord")
e.shader.projection = gl.GetUniformLocation(e.shader.program, "projection")
e.shader.view = gl.GetUniformLocation(e.shader.program, "view")
e.shader.modelx = gl.GetUniformLocation(e.shader.program, "modelx")
e.shader.modely = gl.GetUniformLocation(e.shader.program, "modely")
e.shader.color = gl.GetUniformLocation(e.shader.program, "color")
e.shader.useuv = gl.GetUniformLocation(e.shader.program, "useuv")
for _, model := range e.shader.models {
for _, group := range model.Groups {
//颜色
color := group.Material.Ambient
//顶点
data := f32.Bytes(binary.LittleEndian, group.Vertexes...)
vertexCount := len(group.Vertexes) / 3
databuf := gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, databuf)
gl.BufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW)
//UV坐标
textcoords := f32.Bytes(binary.LittleEndian, group.Textcoords...)
uvbuf := gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, uvbuf)
gl.BufferData(gl.ARRAY_BUFFER, textcoords, gl.STATIC_DRAW)
//贴图文件
var useuv bool
tex, err := LoadTexture(group.Material.Texturefile)
if err != nil {
useuv = false
} else {
useuv = true
}
e.shape.Objs = append(e.shape.Objs, Obj{vcount: vertexCount, coord: databuf, color: color, useuv: useuv, uvcoord: uvbuf, tex: tex})
}
}
}
func onPaint(c size.Event) {
gl.ClearColor(0, 0.3, 0.3, 1)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.UseProgram(program)
green += direction
if green > 1 {
green = 1
direction = -direction
}
if green < 0.4 {
green = 0.4
direction = -direction
}
gl.Uniform4f(color, 0, green, 0, 1)
gl.Uniform2f(offset, touchX/float32(c.WidthPx), touchY/float32(c.HeightPx))
gl.BindBuffer(gl.ARRAY_BUFFER, buf)
gl.BufferData(gl.ARRAY_BUFFER, triangleData, gl.STATIC_DRAW) // ?
gl.EnableVertexAttribArray(position)
gl.VertexAttribPointer(position, coordsPerVertex, gl.FLOAT, false, 0, 0)
gl.DrawArrays(gl.TRIANGLES, 0, vertexCount)
gl.DisableVertexAttribArray(position)
debug.DrawFPS(c)
}
func (e *Engine) Start() {
var err error
e.shader.program, err = LoadProgram("shader.v.glsl", "shader.f.glsl")
if err != nil {
panic(fmt.Sprintln("LoadProgram failed:", err))
}
e.shape.buf = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, e.shape.buf)
gl.BufferData(gl.ARRAY_BUFFER, EncodeObject(cubeData), gl.STATIC_DRAW)
e.shader.vertCoord = gl.GetAttribLocation(e.shader.program, "vertCoord")
e.shader.vertTexCoord = gl.GetAttribLocation(e.shader.program, "vertTexCoord")
e.shader.projection = gl.GetUniformLocation(e.shader.program, "projection")
e.shader.view = gl.GetUniformLocation(e.shader.program, "view")
e.shader.model = gl.GetUniformLocation(e.shader.program, "model")
e.shape.texture, err = LoadTexture("gopher.png")
if err != nil {
panic(fmt.Sprintln("LoadTexture failed:", err))
}
e.started = time.Now()
}
func (e *Engine) Start() {
var err error
e.shader.program, err = LoadProgram("shader.v.glsl", "shader.f.glsl")
if err != nil {
panic(fmt.Sprintln("LoadProgram failed:", err))
}
e.shader.models, err = wavefront.Read("gopher.obj")
check(err)
e.shader.vertCoord = gl.GetAttribLocation(e.shader.program, "vertCoord")
e.shader.projection = gl.GetUniformLocation(e.shader.program, "projection")
e.shader.view = gl.GetUniformLocation(e.shader.program, "view")
e.shader.modelx = gl.GetUniformLocation(e.shader.program, "modelx")
e.shader.modely = gl.GetUniformLocation(e.shader.program, "modely")
e.shader.color = gl.GetUniformLocation(e.shader.program, "color")
for _, model := range e.shader.models {
for _, group := range model.Groups {
data := f32.Bytes(binary.LittleEndian, group.Vertexes...)
color := group.Material.Ambient
vertexCount := len(data)
databuf := gl.CreateBuffer()
e.shape.bufs = append(e.shape.bufs, Buf{vertexCount, databuf, color})
gl.BindBuffer(gl.ARRAY_BUFFER, databuf)
gl.BufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW)
}
}
}
func onStart() {
var err error
program, err = glutil.CreateProgram(vertexShader, fragmentShader)
if err != nil {
log.Printf("error creating GL program: %v", err)
return
}
//创建一个WebGLBuffer对象，把它绑定到顶点缓冲上，并把顶点数据载入到顶点冲。
buf = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, buf)
gl.BufferData(gl.ARRAY_BUFFER, lineData, gl.STATIC_DRAW)
/*opengl中三种变量
uniform变量是外部application程序传递给（vertex和fragment）shader的变量。因此它是application通过函数glUniform**（）函数赋值的。
在（vertex和fragment）shader程序内部，uniform变量就像是C语言里面的常量（const ），它不能被shader程序修改。（shader只能用，不能改）
attribute变量是只能在vertex shader中使用的变量。（它不能在fragment shader中声明attribute变量，也不能被fragment shader中使用）
一般用attribute变量来表示一些顶点的数据，如：顶点坐标，法线，纹理坐标，顶点颜色等。
在application中，一般用函数glBindAttribLocation（）来绑定每个attribute变量的位置，然后用函数glVertexAttribPointer（）为每个attribute变量赋值。
varying变量是vertex和fragment shader之间做数据传递用的。一般vertex shader修改varying变量的值，然后fragment shader使用该varying变量的值。
因此varying变量在vertex和fragment shader二者之间的声明必须是一致的。application不能使用此变量。
*/
position = gl.GetAttribLocation(program, "position") //获取位置对象(索引)
color = gl.GetUniformLocation(program, "color") // 获取颜色对象(索引)
scan = gl.GetUniformLocation(program, "scan") // 获取偏移对象(索引)
// fmt.Println(position.String(),color.String(),offset.String())//Attrib(0) Uniform(1) Uniform(0)
// TODO(crawshaw): the debug package needs to put GL state init here
// Can this be an event.Register call now??
}
func onStart() {
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA)
texture := loadImages("495.png")
textureId = gl.CreateTexture()
gl.BindTexture(gl.TEXTURE_2D, textureId)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT)
gl.TexImage2D(gl.TEXTURE_2D, 0, texture.Rect.Size().X, texture.Rect.Size().Y, gl.RGBA, gl.UNSIGNED_BYTE, texture.Pix)
// loading Shaders & linking programs
program = createProgram("vShader.vs", "fShader.vs")
texProgram = createProgram("vTexShader.vs", "fTexShader.vs")
quadBuffer = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, quadBuffer)
gl.BufferData(gl.ARRAY_BUFFER, quadData, gl.STATIC_DRAW)
quadTexBuffer = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, quadTexBuffer)
gl.BufferData(gl.ARRAY_BUFFER, quadTexData, gl.STATIC_DRAW)
swasBuffer = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, swasBuffer)
gl.BufferData(gl.ARRAY_BUFFER, swastikaData, gl.STATIC_DRAW)
position = gl.GetAttribLocation(program, "position")
color = gl.GetUniformLocation(program, "color")
matrixId = gl.GetUniformLocation(program, "rotationMatrix")
resolutionId = gl.GetUniformLocation(program, "resIndex")
position2 = gl.GetAttribLocation(texProgram, "position")
textureCoords = gl.GetAttribLocation(texProgram, "texCoords")
matrixId2 = gl.GetUniformLocation(texProgram, "rotationMatrix")
resolutionId2 = gl.GetUniformLocation(texProgram, "resIndex")
color2 = gl.GetUniformLocation(texProgram, "color")
}
func glInit() {
var err error
glimage.program, err = CreateProgram(vertexShader, fragmentShader)
if err != nil {
panic(err)
}
glimage.quadXY = gl.GenBuffer()
glimage.quadUV = gl.GenBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, glimage.quadXY)
gl.BufferData(gl.ARRAY_BUFFER, gl.STATIC_DRAW, quadXYCoords)
gl.BindBuffer(gl.ARRAY_BUFFER, glimage.quadUV)
gl.BufferData(gl.ARRAY_BUFFER, gl.STATIC_DRAW, quadUVCoords)
glimage.pos = gl.GetAttribLocation(glimage.program, "pos")
glimage.mvp = gl.GetUniformLocation(glimage.program, "mvp")
glimage.uvp = gl.GetUniformLocation(glimage.program, "uvp")
glimage.inUV = gl.GetAttribLocation(glimage.program, "inUV")
glimage.textureSample = gl.GetUniformLocation(glimage.program, "textureSample")
}
func (s *screenImpl) NewTexture(size image.Point) (screen.Texture, error) {
s.mu.Lock()
defer s.mu.Unlock()
if !gl.IsProgram(s.texture.program) {
p, err := compileProgram(textureVertexSrc, textureFragmentSrc)
if err != nil {
return nil, err
}
s.texture.program = p
s.texture.pos = gl.GetAttribLocation(p, "pos")
s.texture.mvp = gl.GetUniformLocation(p, "mvp")
s.texture.uvp = gl.GetUniformLocation(p, "uvp")
s.texture.inUV = gl.GetAttribLocation(p, "inUV")
s.texture.sample = gl.GetUniformLocation(p, "sample")
s.texture.quadXY = gl.CreateBuffer()
s.texture.quadUV = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, s.texture.quadXY)
gl.BufferData(gl.ARRAY_BUFFER, quadXYCoords, gl.STATIC_DRAW)
gl.BindBuffer(gl.ARRAY_BUFFER, s.texture.quadUV)
gl.BufferData(gl.ARRAY_BUFFER, quadUVCoords, gl.STATIC_DRAW)
}
t := &textureImpl{
id: gl.CreateTexture(),
size: size,
}
gl.BindTexture(gl.TEXTURE_2D, t.id)
gl.TexImage2D(gl.TEXTURE_2D, 0, size.X, size.Y, gl.RGBA, gl.UNSIGNED_BYTE, nil)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
return t, nil
}
func onStart() {
var err error
program, err = glutil.CreateProgram(vertexShader, fragmentShader)
if err != nil {
log.Printf("error creating GL program: %v", err)
return
}
buf = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, buf)
gl.BufferData(gl.ARRAY_BUFFER, rectData, gl.STATIC_DRAW)
position = gl.GetAttribLocation(program, "position")
color = gl.GetUniformLocation(program, "color")
offset = gl.GetUniformLocation(program, "offset")
}
func initGL() {
var err error
program, err = glutil.CreateProgram(vertexShader, fragmentShader)
if err != nil {
log.Printf("error creating GL program: %v", err)
return
}
buf = gl.GenBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, buf)
gl.BufferData(gl.ARRAY_BUFFER, gl.STATIC_DRAW, triangleData)
position = gl.GetAttribLocation(program, "position")
color = gl.GetUniformLocation(program, "color")
offset = gl.GetUniformLocation(program, "offset")
touchLoc = geom.Point{geom.Width / 2, geom.Height / 2}
}
func (e *Engine) Start() {
var err error
e.shader.program, err = LoadProgram("shader.v.glsl", "shader.f.glsl")
if err != nil {
panic(fmt.Sprintln("LoadProgram failed:", err))
}
fmt.Println(len(cubeData))
e.shape.buf = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, e.shape.buf)
gl.BufferData(gl.ARRAY_BUFFER, cubeData, gl.STATIC_DRAW)
e.shader.vertCoord = gl.GetAttribLocation(e.shader.program, "vertCoord")
e.shader.projection = gl.GetUniformLocation(e.shader.program, "projection")
e.shader.view = gl.GetUniformLocation(e.shader.program, "view")
e.shader.modelx = gl.GetUniformLocation(e.shader.program, "modelx")
e.shader.modely = gl.GetUniformLocation(e.shader.program, "modely")
}
func onStart() {
var err error
program, err = glutil.CreateProgram(vertexShader, fragmentShader)
if err != nil {
log.Printf("error creating GL program: %v", err)
return
}
buf = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, buf)
gl.BufferData(gl.ARRAY_BUFFER, triangleData, gl.STATIC_DRAW)
position = gl.GetAttribLocation(program, "position")
color = gl.GetUniformLocation(program, "color")
offset = gl.GetUniformLocation(program, "offset")
// TODO(crawshaw): the debug package needs to put GL state init here
// Can this be an app.RegisterFilter call now??
}
func (w *windowImpl) Fill(dr image.Rectangle, src color.Color, op draw.Op) {
if !gl.IsProgram(w.s.fill.program) {
p, err := compileProgram(fillVertexSrc, fillFragmentSrc)
if err != nil {
// TODO: initialize this somewhere else we can better handle the error.
panic(err.Error())
}
w.s.fill.program = p
w.s.fill.pos = gl.GetAttribLocation(p, "pos")
w.s.fill.mvp = gl.GetUniformLocation(p, "mvp")
w.s.fill.color = gl.GetUniformLocation(p, "color")
w.s.fill.quadXY = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, w.s.fill.quadXY)
gl.BufferData(gl.ARRAY_BUFFER, quadXYCoords, gl.STATIC_DRAW)
}
gl.UseProgram(w.s.fill.program)
writeAff3(w.s.fill.mvp, w.vertexAff3(dr))
r, g, b, a := src.RGBA()
gl.Uniform4f(
w.s.fill.color,
float32(r)/65535,
float32(g)/65535,
float32(b)/65535,
float32(a)/65535,
)
gl.BindBuffer(gl.ARRAY_BUFFER, w.s.fill.quadXY)
gl.EnableVertexAttribArray(w.s.fill.pos)
gl.VertexAttribPointer(w.s.fill.pos, 2, gl.FLOAT, false, 0, 0)
gl.DrawArrays(gl.TRIANGLE_STRIP, 0, 4)
gl.DisableVertexAttribArray(w.s.fill.pos)
}
func drawKeys() {
gl.UseProgram(program)
projection.WriteMat4(&projmat)
iPlaying := []int{}
playing := []ratio{}
amps := []float64{}
for i, k := range keys {
k := k.base()
if k.voice != nil && !k.voice.Done() {
iPlaying = append(iPlaying, i)
playing = append(playing, k.ratio)
amps = append(amps, k.voice.amp())
}
}
complexities := make([]float64, len(keys))
minComplexity := math.MaxFloat64
for i, k := range keys {
k := k.base()
c := -1.0
for j, iPlaying := range iPlaying {
if i == iPlaying {
a := amps[j]
amps[j] = 1
c = complexity(playing, amps)
amps[j] = a
break
}
}
if c == -1 {
c = complexity(append(playing, k.ratio), append(amps, 1))
}
complexities[i] = c
if c < minComplexity {
minComplexity = c
}
}
data := []float32{}
pointsizedata := []float32{}
for i, k := range keys {
k := k.base()
k.y = 1 - math.Exp2(-float64(complexities[i]-minComplexity)/4)
k.size = math.Exp2(-float64(complexities[i])/4) * float64(geom.Width) * float64(geom.PixelsPerPt) / 4
data = append(data, float32(k.pitch), float32(k.y))
pointsizedata = append(pointsizedata, float32(k.size))
}
gl.BindBuffer(gl.ARRAY_BUFFER, positionbuf)
gl.BufferData(gl.ARRAY_BUFFER, f32.Bytes(binary.LittleEndian, data...), gl.DYNAMIC_DRAW)
gl.BindBuffer(gl.ARRAY_BUFFER, pointsizebuf)
gl.BufferData(gl.ARRAY_BUFFER, f32.Bytes(binary.LittleEndian, pointsizedata...), gl.DYNAMIC_DRAW)
gl.EnableVertexAttribArray(position)
gl.EnableVertexAttribArray(pointsize)
gl.Uniform4f(color, 1, 1, 1, 1)
gl.BindBuffer(gl.ARRAY_BUFFER, positionbuf)
gl.VertexAttribPointer(position, 2, gl.FLOAT, false, 0, 0)
gl.BindBuffer(gl.ARRAY_BUFFER, pointsizebuf)
gl.VertexAttribPointer(pointsize, 1, gl.FLOAT, false, 0, 0)
gl.DrawArrays(gl.POINTS, 0, len(keys))
gl.DisableVertexAttribArray(position)
gl.DisableVertexAttribArray(pointsize)
}