func (shape *StaticShape) Draw(shader Shader, camera Camera) {
gl.BindBuffer(gl.ARRAY_BUFFER, shape.VBO)
stride := shape.Stride()
gl.EnableVertexAttribArray(shader.Attrib("vertCoord"))
gl.VertexAttribPointer(shader.Attrib("vertCoord"), vertexDim, gl.FLOAT, false, stride, 0)
if len(shape.normals) > 0 {
gl.EnableVertexAttribArray(shader.Attrib("vertNormal"))
gl.VertexAttribPointer(shader.Attrib("vertNormal"), normalDim, gl.FLOAT, false, stride, vertexDim*vecSize)
}
// TODO: texture
if len(shape.indices) > 0 {
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, shape.IBO)
gl.DrawElements(gl.TRIANGLES, len(shape.indices), gl.UNSIGNED_BYTE, 0)
} else {
gl.DrawArrays(gl.TRIANGLES, 0, shape.Len())
}
gl.DisableVertexAttribArray(shader.Attrib("vertCoord"))
if len(shape.normals) > 0 {
gl.DisableVertexAttribArray(shader.Attrib("vertNormal"))
}
// TODO: texture
}
func (w *windowImpl) Draw(src2dst f64.Aff3, src screen.Texture, sr image.Rectangle, op draw.Op, opts *screen.DrawOptions) {
t := src.(*textureImpl)
a := w.vertexAff3(sr)
gl.UseProgram(w.s.texture.program)
writeAff3(w.s.texture.mvp, mul(a, src2dst))
// OpenGL's fragment shaders' UV coordinates run from (0,0)-(1,1),
// unlike vertex shaders' XY coordinates running from (-1,+1)-(+1,-1).
//
// We are drawing a rectangle PQRS, defined by two of its
// corners, onto the entire texture. The two quads may actually
// be equal, but in the general case, PQRS can be smaller.
//
// (0,0) +---------------+ (1,0)
// | P +-----+ Q |
// | | | |
// | S +-----+ R |
// (0,1) +---------------+ (1,1)
//
// The PQRS quad is always axis-aligned. First of all, convert
// from pixel space to texture space.
tw := float64(t.size.X)
th := float64(t.size.Y)
px := float64(sr.Min.X-0) / tw
py := float64(sr.Min.Y-0) / th
qx := float64(sr.Max.X-0) / tw
sy := float64(sr.Max.Y-0) / th
// Due to axis alignment, qy = py and sx = px.
//
// The simultaneous equations are:
// 0 + 0 + a02 = px
// 0 + 0 + a12 = py
// a00 + 0 + a02 = qx
// a10 + 0 + a12 = qy = py
// 0 + a01 + a02 = sx = px
// 0 + a11 + a12 = sy
writeAff3(w.s.texture.uvp, f64.Aff3{
qx - px, 0, px,
0, sy - py, py,
})
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, t.id)
gl.Uniform1i(w.s.texture.sample, 0)
gl.BindBuffer(gl.ARRAY_BUFFER, w.s.texture.quadXY)
gl.EnableVertexAttribArray(w.s.texture.pos)
gl.VertexAttribPointer(w.s.texture.pos, 2, gl.FLOAT, false, 0, 0)
gl.BindBuffer(gl.ARRAY_BUFFER, w.s.texture.quadUV)
gl.EnableVertexAttribArray(w.s.texture.inUV)
gl.VertexAttribPointer(w.s.texture.inUV, 2, gl.FLOAT, false, 0, 0)
gl.DrawArrays(gl.TRIANGLE_STRIP, 0, 4)
gl.DisableVertexAttribArray(w.s.texture.pos)
gl.DisableVertexAttribArray(w.s.texture.inUV)
}
func (e *Engine) Draw(c size.Event) {
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
gl.ClearColor(0.2, 0.2, 0.2, 1)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.Clear(gl.DEPTH_BUFFER_BIT)
gl.UseProgram(e.shader.program)
m := mgl32.Perspective(0.785, float32(c.WidthPt/c.HeightPt), 0.1, 10.0)
gl.UniformMatrix4fv(e.shader.projection, m[:])
eye := mgl32.Vec3{0, 0, 8}
center := mgl32.Vec3{0, 0, 0}
up := mgl32.Vec3{0, 1, 0}
m = mgl32.LookAtV(eye, center, up)
gl.UniformMatrix4fv(e.shader.view, m[:])
m = mgl32.HomogRotate3D(float32(e.touchLoc.X/c.WidthPt-0.5)*3.14*2, mgl32.Vec3{0, 1, 0})
gl.UniformMatrix4fv(e.shader.modelx, m[:])
m = mgl32.HomogRotate3D(float32(e.touchLoc.Y/c.HeightPt-0.5)*3.14, mgl32.Vec3{1, 0, 0})
gl.UniformMatrix4fv(e.shader.modely, m[:])
coordsPerVertex := 3
for _, obj := range e.shape.Objs {
gl.BindBuffer(gl.ARRAY_BUFFER, obj.coord)
gl.EnableVertexAttribArray(e.shader.vertCoord)
gl.VertexAttribPointer(e.shader.vertCoord, coordsPerVertex, gl.FLOAT, false, 12, 0)
if obj.useuv == true {
gl.Uniform1i(e.shader.useuv, 1)
texCoordsPerVertex := 2
gl.BindBuffer(gl.ARRAY_BUFFER, obj.uvcoord)
gl.EnableVertexAttribArray(e.shader.vertTexCoord)
gl.VertexAttribPointer(e.shader.vertTexCoord, texCoordsPerVertex, gl.FLOAT, false, 8, 0)
gl.BindTexture(gl.TEXTURE_2D, obj.tex)
} else {
gl.Uniform1i(e.shader.useuv, 0)
gl.Uniform4f(e.shader.color, obj.color[0], obj.color[1], obj.color[2], obj.color[3])
}
gl.DrawArrays(gl.TRIANGLES, 0, obj.vcount)
if obj.useuv {
gl.DisableVertexAttribArray(e.shader.vertTexCoord)
}
gl.DisableVertexAttribArray(e.shader.vertCoord)
}
debug.DrawFPS(c)
}
func (e *Engine) Draw(c size.Event) {
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
gl.ClearColor(0.5, 0.8, 0.8, 1)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.Clear(gl.DEPTH_BUFFER_BIT)
gl.UseProgram(e.shader.program)
gl.Uniform3fv(e.shader.lightdir, []float32{0.5, 0.6, 0.7})
m := mgl32.Perspective(1.3, float32(c.WidthPt/c.HeightPt), 0.1, 10.0)
gl.UniformMatrix4fv(e.shader.projectionmatrix, m[:])
eye := mgl32.Vec3{0, 0, 0.2}
center := mgl32.Vec3{0, 0, 0}
up := mgl32.Vec3{0, 1, 0}
m = mgl32.LookAtV(eye, center, up)
gl.UniformMatrix4fv(e.shader.viewmatrix, m[:])
m = mgl32.HomogRotate3D((e.touchx/float32(c.WidthPt)-0.5)*6.28, mgl32.Vec3{0, 1, 0})
gl.UniformMatrix4fv(e.shader.modelmatrix, m[:])
m = mgl32.HomogRotate3D((e.touchx/float32(c.WidthPt)-0.5)*6.28, mgl32.Vec3{0, -1, 0})
gl.UniformMatrix4fv(e.shader.lightmatrix, m[:])
coordsPerVertex := 3
for _, obj := range e.shape.Objs {
gl.BindBuffer(gl.ARRAY_BUFFER, obj.coord)
gl.EnableVertexAttribArray(e.shader.vertCoord)
gl.VertexAttribPointer(e.shader.vertCoord, coordsPerVertex, gl.FLOAT, false, 12, 0)
texCoordsPerVertex := 2
gl.BindBuffer(gl.ARRAY_BUFFER, obj.uvcoord)
gl.EnableVertexAttribArray(e.shader.texcoord)
gl.VertexAttribPointer(e.shader.texcoord, texCoordsPerVertex, gl.FLOAT, false, 8, 0)
gl.BindBuffer(gl.ARRAY_BUFFER, obj.normal)
gl.EnableVertexAttribArray(e.shader.normal)
gl.VertexAttribPointer(e.shader.normal, 3, gl.FLOAT, false, 12, 0)
gl.BindTexture(gl.TEXTURE_2D, obj.tex)
gl.DrawArrays(gl.TRIANGLES, 0, obj.vcount)
gl.DisableVertexAttribArray(e.shader.texcoord)
gl.DisableVertexAttribArray(e.shader.normal)
gl.DisableVertexAttribArray(e.shader.vertCoord)
}
debug.DrawFPS(c)
}
func onPaint(sz size.Event) {
gl.ClearColor(rgb(156), rgb(39), rgb(176), 1)
gl.Clear(gl.COLOR_BUFFER_BIT)
var rotationMatrix = []float32{
f32.Cos(-alpha), -f32.Sin(-alpha), 0.0,
f32.Sin(-alpha), f32.Cos(-alpha), 0.0,
0.0, 0.0, 1.0,
}
gl.UseProgram(program)
// setting color
gl.Uniform4f(color, rgb(255), rgb(255), rgb(255), 1)
gl.UniformMatrix3fv(matrixId, rotationMatrix)
gl.Uniform1f(resolutionId, resIndex)
gl.BindBuffer(gl.ARRAY_BUFFER, swasBuffer)
gl.EnableVertexAttribArray(position)
gl.VertexAttribPointer(position, 3, gl.FLOAT, false, 0, 0)
gl.DrawArrays(gl.LINES, 0, 16)
gl.DisableVertexAttribArray(position)
gl.UseProgram(texProgram)
// setting color
gl.Uniform4f(color2, rgb(130), rgb(50), rgb(80), 1)
gl.Uniform1f(resolutionId2, resIndex)
gl.UniformMatrix3fv(matrixId2, rotationMatrix)
gl.BindBuffer(gl.ARRAY_BUFFER, quadBuffer)
gl.EnableVertexAttribArray(position2)
gl.VertexAttribPointer(position2, 3, gl.FLOAT, false, 0, 0)
gl.BindBuffer(gl.ARRAY_BUFFER, quadTexBuffer)
gl.EnableVertexAttribArray(textureCoords)
gl.VertexAttribPointer(textureCoords, 2, gl.FLOAT, false, 0, 0)
gl.Uniform1i(gl.GetUniformLocation(texProgram, "myTexture"), 0)
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, textureId)
gl.DrawArrays(gl.TRIANGLES, 0, 6)
gl.DisableVertexAttribArray(position2)
gl.DisableVertexAttribArray(textureCoords)
if spin == true {
alpha += 0.1
}
if alpha >= 360 {
alpha = 0.0
}
}
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 onPaint(c size.Event) {
//清场
gl.ClearColor(1, 1, 1, 1) //设置背景颜色
gl.Clear(gl.COLOR_BUFFER_BIT)
//使用program
gl.UseProgram(program)
gl.Uniform4f(color, 0, 0.5, 0.8, 1) //设置color对象值,设置4个浮点数.
//offset有两个值X,Y,窗口左上角为(0,0),右下角为(1,1)
//gl.Uniform4f(offset,5.0,1.0,1.0,1.0 )
//gl.Uniform2f(offset,offsetx,offsety )//为2参数的uniform变量赋值
//log.Println("offset:",offsetx,offsety, 0, 0)
gl.UniformMatrix4fv(scan, []float32{
float32(touchLoc.X/c.WidthPt*4 - 2), 0, 0, 0,
0, float32(touchLoc.Y/c.HeightPt*4 - 2), 0, 0,
0, 0, 0, 0,
0, 0, 0, 1,
})
gl.BindBuffer(gl.ARRAY_BUFFER, buf)
gl.EnableVertexAttribArray(position)
/*glVertexAttribPointer 指定了渲染时索引值为 index 的顶点属性数组的数据格式和位置。调用gl.vertexAttribPointer()方法，把顶点着色器中某个属性相对应的通用属性索引连接到绑定的webGLBUffer对象上。
index 指定要修改的顶点属性的索引值
size 指定每个顶点属性的组件数量。必须为1、2、3或者4。初始值为4。（如position是由3个（x,y,z）组成，而颜色是4个（r,g,b,a））
type 指定数组中每个组件的数据类型。可用的符号常量有GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT,GL_UNSIGNED_SHORT, GL_FIXED, 和 GL_FLOAT，初始值为GL_FLOAT。
normalized 指定当被访问时，固定点数据值是否应该被归一化（GL_TRUE）或者直接转换为固定点值（GL_FALSE）。
stride 指定连续顶点属性之间的偏移量。如果为0，那么顶点属性会被理解为：它们是紧密排列在一起的。初始值为0。
pointer 指定第一个组件在数组的第一个顶点属性中的偏移量。该数组与GL_ARRAY_BUFFER绑定，储存于缓冲区中。初始值为0；
*/
gl.VertexAttribPointer(position, coordsPerVertex, gl.FLOAT, false, 0, 0) //更新position值
gl.DrawArrays(gl.TRIANGLES, 0, vertexCount)
gl.DisableVertexAttribArray(position)
debug.DrawFPS(c)
}
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 draw() {
if program.Value == 0 {
initGL()
initCL()
}
if numPlatforms == 0 {
gl.ClearColor(1, 0, 0, 1)
} else {
gl.ClearColor(0, 1, 0, 1)
}
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.UseProgram(program)
blue += 0.01
if blue > 1 {
blue = 0
}
gl.Uniform4f(color, 0, 0, blue, 1)
gl.Uniform2f(offset, float32(touchLoc.X/geom.Width), float32(touchLoc.Y/geom.Height))
gl.BindBuffer(gl.ARRAY_BUFFER, buf)
gl.EnableVertexAttribArray(position)
gl.VertexAttribPointer(position, coordsPerVertex, gl.FLOAT, false, 0, 0)
gl.DrawArrays(gl.TRIANGLES, 0, vertexCount)
gl.DisableVertexAttribArray(position)
debug.DrawFPS()
}
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 (e *Engine) Draw(c size.Event) {
since := time.Now().Sub(e.started)
//gl.Enable()
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
gl.ClearColor(0, 0, 0, 1)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.Clear(gl.DEPTH_BUFFER_BIT)
gl.UseProgram(e.shader.program)
m := mgl32.Perspective(0.785, float32(c.WidthPt/c.HeightPt), 0.1, 10.0)
gl.UniformMatrix4fv(e.shader.projection, m[:])
eye := mgl32.Vec3{3, 3, 3}
center := mgl32.Vec3{0, 0, 0}
up := mgl32.Vec3{0, 1, 0}
m = mgl32.LookAtV(eye, center, up)
gl.UniformMatrix4fv(e.shader.view, m[:])
m = mgl32.HomogRotate3D(float32(since.Seconds()), mgl32.Vec3{0, 1, 0})
gl.UniformMatrix4fv(e.shader.model, m[:])
gl.BindBuffer(gl.ARRAY_BUFFER, e.shape.buf)
coordsPerVertex := 3
texCoordsPerVertex := 2
vertexCount := len(cubeData) / (coordsPerVertex + texCoordsPerVertex)
gl.EnableVertexAttribArray(e.shader.vertCoord)
gl.VertexAttribPointer(e.shader.vertCoord, coordsPerVertex, gl.FLOAT, false, 20, 0) // 4 bytes in float, 5 values per vertex
gl.EnableVertexAttribArray(e.shader.vertTexCoord)
gl.VertexAttribPointer(e.shader.vertTexCoord, texCoordsPerVertex, gl.FLOAT, false, 20, 12)
gl.BindTexture(gl.TEXTURE_2D, e.shape.texture)
gl.DrawArrays(gl.TRIANGLES, 0, vertexCount)
gl.DisableVertexAttribArray(e.shader.vertCoord)
debug.DrawFPS(c)
}
func (e *Engine) Draw(c event.Config) {
since := time.Now().Sub(e.started)
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
gl.ClearColor(0, 0, 0, 1)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.Clear(gl.DEPTH_BUFFER_BIT)
gl.UseProgram(e.shader.program)
// Setup MVP
var m mgl.Mat4
m = mgl.Perspective(0.785, float32(c.Width/c.Height), 0.1, 10.0)
gl.UniformMatrix4fv(e.shader.projection, m[:])
m = mgl.LookAtV(
mgl.Vec3{3, 3, 3}, // eye
mgl.Vec3{0, 0, 0}, // center
mgl.Vec3{0, 1, 0}, // up
)
gl.UniformMatrix4fv(e.shader.view, m[:])
m = mgl.HomogRotate3D(float32(since.Seconds()), mgl.Vec3{0, 1, 0})
gl.UniformMatrix4fv(e.shader.model, m[:])
// Draw our shape
gl.BindBuffer(gl.ARRAY_BUFFER, e.shape.buf)
gl.EnableVertexAttribArray(e.shader.vertCoord)
gl.VertexAttribPointer(e.shader.vertCoord, e.shape.coordsPerVertex, gl.FLOAT, false, 20, 0) // 4 bytes in float, 5 values per vertex
gl.EnableVertexAttribArray(e.shader.vertTexCoord)
gl.VertexAttribPointer(e.shader.vertTexCoord, e.shape.texCoordsPerVertex, gl.FLOAT, false, 20, 12)
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, e.shape.texture)
gl.DrawArrays(gl.TRIANGLES, 0, e.shape.vertexCount)
gl.DisableVertexAttribArray(e.shader.vertCoord)
//debug.DrawFPS(c)
}
func (emitter *particleEmitter) Draw(shader Shader, camera Camera) {
gl.BindBuffer(gl.ARRAY_BUFFER, emitter.VBO)
gl.EnableVertexAttribArray(shader.Attrib("vertCoord"))
gl.VertexAttribPointer(shader.Attrib("vertCoord"), vertexDim, gl.FLOAT, false, emitter.Stride(), 0)
gl.DrawArrays(gl.TRIANGLES, 0, emitter.Len()*particleLen/vertexDim)
gl.DisableVertexAttribArray(shader.Attrib("vertCoord"))
}
func (e *Engine) Draw(c size.Event) {
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
gl.ClearColor(0, 0, 0, 1)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.Clear(gl.DEPTH_BUFFER_BIT)
gl.UseProgram(e.shader.program)
m := mgl32.Perspective(0.785, float32(c.WidthPt/c.HeightPt), 0.1, 10.0)
gl.UniformMatrix4fv(e.shader.projection, m[:])
eye := mgl32.Vec3{0, 3, 3}
center := mgl32.Vec3{0, 0, 0}
up := mgl32.Vec3{0, 1, 0}
m = mgl32.LookAtV(eye, center, up)
gl.UniformMatrix4fv(e.shader.view, m[:])
m = mgl32.HomogRotate3D(float32(e.touchLocX*5/c.WidthPt), mgl32.Vec3{0, 1, 0})
gl.UniformMatrix4fv(e.shader.modelx, m[:])
m = mgl32.HomogRotate3D(float32(e.touchLocY*5/c.HeightPt), mgl32.Vec3{1, 0, 0})
gl.UniformMatrix4fv(e.shader.modely, m[:])
gl.BindBuffer(gl.ARRAY_BUFFER, e.shape.buf)
gl.EnableVertexAttribArray(e.shader.vertCoord)
gl.VertexAttribPointer(e.shader.vertCoord, coordsPerVertex, gl.FLOAT, false, 0, 0)
gl.BindBuffer(gl.ARRAY_BUFFER, e.shape.colorbuf)
gl.EnableVertexAttribArray(e.shader.color)
gl.VertexAttribPointer(e.shader.color, colorsPerVertex, gl.FLOAT, false, 0, 0) //更新color值
gl.DrawArrays(gl.TRIANGLES, 0, vertexCount)
gl.DisableVertexAttribArray(e.shader.vertCoord)
gl.DisableVertexAttribArray(e.shader.color)
debug.DrawFPS(c)
}
func onPaint(c config.Event) {
gl.ClearColor(1, 1, 1, 1)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.UseProgram(program)
gl.Uniform4f(color, 0.3, 0.3, 0.3, 1) // color
// position
x := float32(touchLoc.X / c.Width)
y := float32(touchLoc.Y / c.Height)
gl.Uniform2f(offset, x, y)
gl.BindBuffer(gl.ARRAY_BUFFER, buf)
gl.EnableVertexAttribArray(position)
gl.VertexAttribPointer(position, 2, gl.FLOAT, false, 0, 0)
gl.DrawArrays(gl.TRIANGLE_STRIP, 0, 4)
gl.DisableVertexAttribArray(position)
}
func (e *Engine) Draw(c size.Event) {
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
gl.ClearColor(0.2, 0.2, 0.2, 1)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.Clear(gl.DEPTH_BUFFER_BIT)
gl.UseProgram(e.shader.program)
m := mgl32.Perspective(0.785, float32(c.WidthPt/c.HeightPt), 0.1, 10.0)
gl.UniformMatrix4fv(e.shader.projection, m[:])
eye := mgl32.Vec3{0, 0, 5}
center := mgl32.Vec3{0, 0, 0}
up := mgl32.Vec3{0, 1, 0}
m = mgl32.LookAtV(eye, center, up)
gl.UniformMatrix4fv(e.shader.view, m[:])
m = mgl32.HomogRotate3D(float32(e.touchLoc.X*10/c.WidthPt), mgl32.Vec3{0, 1, 0})
gl.UniformMatrix4fv(e.shader.modelx, m[:])
m = mgl32.HomogRotate3D(float32(e.touchLoc.Y*10/c.HeightPt), mgl32.Vec3{1, 0, 0})
gl.UniformMatrix4fv(e.shader.modely, m[:])
coordsPerVertex := 3
for _, buf := range e.shape.bufs {
gl.BindBuffer(gl.ARRAY_BUFFER, buf.coord)
gl.EnableVertexAttribArray(e.shader.vertCoord)
gl.VertexAttribPointer(e.shader.vertCoord, coordsPerVertex, gl.FLOAT, false, 0, 0)
gl.Uniform4f(e.shader.color, buf.color[0], buf.color[1], buf.color[2], buf.color[3])
gl.DrawArrays(gl.TRIANGLES, 0, buf.vcount)
gl.DisableVertexAttribArray(e.shader.vertCoord)
}
debug.DrawFPS(c)
}
func (shape *Line) Draw(camera Camera) {
shader := shape.shader
// Set uniforms
gl.Uniform1f(shader.Uniform("lights[0].intensity"), 2.0)
gl.Uniform3fv(shader.Uniform("lights[0].position"), shape.position[:])
gl.Uniform3fv(shader.Uniform("lights[0].color"), []float32{0.4, 0.2, 0.1})
gl.Uniform3fv(shader.Uniform("material.ambient"), []float32{0.1, 0.15, 0.4})
//gl.Uniform3fv(shader.Uniform("material.diffuse"), []float32{0.8, 0.6, 0.6})
//gl.Uniform3fv(shader.Uniform("material.specular"), []float32{1.0, 1.0, 1.0})
//gl.Uniform1f(shader.Uniform("material.shininess"), 16.0)
//gl.Uniform1f(shader.Uniform("material.refraction"), 1.0/1.52)
gl.BindBuffer(gl.ARRAY_BUFFER, shape.VBO)
stride := shape.Stride()
gl.EnableVertexAttribArray(shader.Attrib("vertCoord"))
gl.VertexAttribPointer(shader.Attrib("vertCoord"), vertexDim, gl.FLOAT, false, stride, 0)
gl.DrawArrays(gl.TRIANGLE_STRIP, 0, shape.Len())
}
func onDraw(c config.Event) {
gl.ClearColor(1, 0, 0, 1)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.UseProgram(program)
green += 0.01
if green > 1 {
green = 0
}
gl.Uniform4f(color, 0, green, 0, 1)
gl.Uniform2f(offset, float32(touchLoc.X/c.Width), float32(touchLoc.Y/c.Height))
gl.BindBuffer(gl.ARRAY_BUFFER, buf)
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 onPaint(sz size.Event) {
gl.ClearColor(1, 0, 0, 1)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.UseProgram(program)
green += 0.01
if green > 1 {
green = 0
}
gl.Uniform4f(color, 0, green, 0, 1)
gl.Uniform2f(offset, touchX/float32(sz.WidthPx), touchY/float32(sz.HeightPx))
gl.BindBuffer(gl.ARRAY_BUFFER, buf)
gl.EnableVertexAttribArray(position)
gl.VertexAttribPointer(position, coordsPerVertex, gl.FLOAT, false, 0, 0)
gl.DrawArrays(gl.TRIANGLES, 0, vertexCount)
gl.DisableVertexAttribArray(position)
debug.DrawFPS(sz)
}
func onStart() {
var err error
program, err = glutil.CreateProgram(vertexShader, fragmentShader)
if err != nil {
log.Printf("error creating GL program: %v", err)
return
}
/*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.GetAttribLocation(program, "color") // 获取颜色对象(索引)
scan = gl.GetUniformLocation(program, "scan") // 获取偏移对象(索引)
positionbuf = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, positionbuf)
gl.BufferData(gl.ARRAY_BUFFER, triangleData, gl.STATIC_DRAW)
colorbuf = gl.CreateBuffer()
gl.BindBuffer(gl.ARRAY_BUFFER, colorbuf)
gl.BufferData(gl.ARRAY_BUFFER, colorData, gl.STATIC_DRAW)
gl.VertexAttribPointer(color, colorsPerVertex, gl.FLOAT, false, 0, 0) //更新color值
gl.DrawArrays(gl.TRIANGLES, 0, vertexCount)
// 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 (shape *Skybox) Draw(camera Camera) {
shader := shape.shader
gl.DepthFunc(gl.LEQUAL)
gl.DepthMask(false)
projection, view := camera.Projection(), camera.View().Mat3().Mat4()
gl.UniformMatrix4fv(shader.Uniform("projection"), projection[:])
gl.UniformMatrix4fv(shader.Uniform("view"), view[:])
gl.BindTexture(gl.TEXTURE_CUBE_MAP, shape.Texture)
gl.BindBuffer(gl.ARRAY_BUFFER, shape.VBO)
gl.EnableVertexAttribArray(shader.Attrib("vertCoord"))
gl.VertexAttribPointer(shader.Attrib("vertCoord"), vertexDim, gl.FLOAT, false, shape.Stride(), 0)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, shape.IBO)
gl.DrawElements(gl.TRIANGLES, len(shape.indices), gl.UNSIGNED_BYTE, 0)
gl.DisableVertexAttribArray(shader.Attrib("vertCoord"))
gl.DepthMask(true)
gl.DepthFunc(gl.LESS)
}
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)
}
// Draw draws the srcBounds part of the image onto a parallelogram, defined by
// three of its corners, in the current GL framebuffer.
func (img *Image) Draw(topLeft, topRight, bottomLeft geom.Point, srcBounds image.Rectangle) {
// TODO(crawshaw): Adjust viewport for the top bar on android?
gl.UseProgram(glimage.program)
{
// We are drawing a parallelogram PQRS, defined by three of its
// corners, onto the entire GL framebuffer ABCD. The two quads may
// actually be equal, but in the general case, PQRS can be smaller,
// and PQRS is not necessarily axis-aligned.
//
// A +---------------+ B
// | P +-----+ Q |
// | | | |
// | S +-----+ R |
// D +---------------+ C
//
// There are two co-ordinate spaces: geom space and framebuffer space.
// In geom space, the ABCD rectangle is:
//
// (0, 0) (geom.Width, 0)
// (0, geom.Height) (geom.Width, geom.Height)
//
// and the PQRS quad is:
//
// (topLeft.X, topLeft.Y) (topRight.X, topRight.Y)
// (bottomLeft.X, bottomLeft.Y) (implicit, implicit)
//
// In framebuffer space, the ABCD rectangle is:
//
// (-1, +1) (+1, +1)
// (-1, -1) (+1, -1)
//
// First of all, convert from geom space to framebuffer space. For
// later convenience, we divide everything by 2 here: px2 is half of
// the P.X co-ordinate (in framebuffer space).
px2 := -0.5 + float32(topLeft.X/geom.Width)
py2 := +0.5 - float32(topLeft.Y/geom.Height)
qx2 := -0.5 + float32(topRight.X/geom.Width)
qy2 := +0.5 - float32(topRight.Y/geom.Height)
sx2 := -0.5 + float32(bottomLeft.X/geom.Width)
sy2 := +0.5 - float32(bottomLeft.Y/geom.Height)
// Next, solve for the affine transformation matrix
// [ a00 a01 a02 ]
// a = [ a10 a11 a12 ]
// [ 0 0 1 ]
// that maps A to P:
// a × [ -1 +1 1 ]' = [ 2*px2 2*py2 1 ]'
// and likewise maps B to Q and D to S. Solving those three constraints
// implies that C maps to R, since affine transformations keep parallel
// lines parallel. This gives 6 equations in 6 unknowns:
// -a00 + a01 + a02 = 2*px2
// -a10 + a11 + a12 = 2*py2
// +a00 + a01 + a02 = 2*qx2
// +a10 + a11 + a12 = 2*qy2
// -a00 - a01 + a02 = 2*sx2
// -a10 - a11 + a12 = 2*sy2
// which gives:
// a00 = (2*qx2 - 2*px2) / 2 = qx2 - px2
// and similarly for the other elements of a.
glimage.mvp.WriteAffine(&f32.Affine{{
qx2 - px2,
px2 - sx2,
qx2 + sx2,
}, {
qy2 - py2,
py2 - sy2,
qy2 + sy2,
}})
}
{
// Mapping texture co-ordinates is similar, except that in texture
// space, the ABCD rectangle is:
//
// (0,0) (1,0)
// (0,1) (1,1)
//
// and the PQRS quad is always axis-aligned. First of all, convert
// from pixel space to texture space.
w := float32(img.texWidth)
h := float32(img.texHeight)
px := float32(srcBounds.Min.X-img.Rect.Min.X) / w
py := float32(srcBounds.Min.Y-img.Rect.Min.Y) / h
qx := float32(srcBounds.Max.X-img.Rect.Min.X) / w
sy := float32(srcBounds.Max.Y-img.Rect.Min.Y) / h
// Due to axis alignment, qy = py and sx = px.
//
// The simultaneous equations are:
// 0 + 0 + a02 = px
// 0 + 0 + a12 = py
// a00 + 0 + a02 = qx
// a10 + 0 + a12 = qy = py
// 0 + a01 + a02 = sx = px
// 0 + a11 + a12 = sy
glimage.uvp.WriteAffine(&f32.Affine{{
qx - px,
0,
px,
}, {
0,
sy - py,
py,
}})
}
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, img.Texture)
gl.Uniform1i(glimage.textureSample, 0)
gl.BindBuffer(gl.ARRAY_BUFFER, glimage.quadXY)
gl.EnableVertexAttribArray(glimage.pos)
gl.VertexAttribPointer(glimage.pos, 2, gl.FLOAT, false, 0, 0)
gl.BindBuffer(gl.ARRAY_BUFFER, glimage.quadUV)
gl.EnableVertexAttribArray(glimage.inUV)
gl.VertexAttribPointer(glimage.inUV, 2, gl.FLOAT, false, 0, 0)
gl.DrawArrays(gl.TRIANGLE_STRIP, 0, 4)
gl.DisableVertexAttribArray(glimage.pos)
gl.DisableVertexAttribArray(glimage.inUV)
}
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)
}