func onPaint(glctx gl.Context, sz size.Event) { glctx.ClearColor(0, 0, 0, 1) glctx.Clear(gl.COLOR_BUFFER_BIT) now := clock.Time(time.Since(startTime) * 60 / time.Second) eng.Render(scene, now, sz) log.Draw(sz) }
func onPaint(glctx gl.Context, sz size.Event) { glctx.ClearColor(1, 1, 1, 1) glctx.Clear(gl.COLOR_BUFFER_BIT) now := clock.Time(time.Since(startTime) * 60 / time.Second) game.Update(now) eng.Render(scene, now, sz) }
func onPaint(glctx gl.Context, sz size.Event) { glctx.ClearColor(236, 240, 241, 1) glctx.Clear(gl.COLOR_BUFFER_BIT) columnOffset := (sz.WidthPt / 2) - ((geom.Pt(gridColumnsCount) * tileSize) / 2) rowOffset := (sz.HeightPt / 2) - ((geom.Pt(gridrowsCount) * tileSize) / 2) for c := 0; c < gridColumnsCount; c++ { for r := 0; r < gridrowsCount; r++ { t := &grid[((c+1)*(r+1))-1] t.columnOffset = columnOffset t.rowOffset = rowOffset t.x = geom.Pt(c) * tileSize t.y = geom.Pt(r) * tileSize t.Draw(sz) } } }
func onPaint(glctx gl.Context, sz size.Event) { glctx.ClearColor(1, 1, 1, 1) // white background glctx.Clear(gl.COLOR_BUFFER_BIT) now := clock.Time(time.Since(startTime) * 60 / time.Second) eng.Render(scene, now, sz) fps.Draw(sz) }
func onPaint(glctx gl.Context, sz size.Event) { glctx.Viewport(0, 0, sz.WidthPx, sz.HeightPx) glctx.ClearColor(0.5, 0.5, 0.5, 1) glctx.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) glctx.UseProgram(program) projectionMtx = mgl32.Perspective(45, float32(width)/float32(height), 0.1, 100) arcBallMtx := arcball.getMtx() glctx.UniformMatrix4fv(projection, projectionMtx[:]) glctx.UniformMatrix4fv(view, arcBallMtx[:]) glctx.BindBuffer(gl.ARRAY_BUFFER, triBuf) glctx.EnableVertexAttribArray(position) glctx.EnableVertexAttribArray(color) glctx.EnableVertexAttribArray(normals) vertSize := 4 * (coordsPerVertex + colorPerVertex + normalsPerVertex) glctx.VertexAttribPointer(position, coordsPerVertex, gl.FLOAT, false, vertSize, 0) glctx.VertexAttribPointer(color, colorPerVertex, gl.FLOAT, false, vertSize, 4*coordsPerVertex) glctx.VertexAttribPointer(normals, normalsPerVertex, gl.FLOAT, false, vertSize, 4*(coordsPerVertex+colorPerVertex)) glctx.DepthMask(true) glctx.Uniform3fv(lightPos, light.Pos[:]) glctx.Uniform3fv(lightIntensity, light.Intensities[:]) for _, k := range piano.Keys { glctx.Uniform4fv(tint, k.Color[:]) mtx := k.GetMtx() normMat := mtx.Mat3().Inv().Transpose() glctx.UniformMatrix3fv(normalMatrix, normMat[:]) glctx.UniformMatrix4fv(model, mtx[:]) glctx.DrawArrays(gl.TRIANGLES, 0, len(triangleData)/vertSize) } modelMtx := mgl32.Ident4() modelMtx = modelMtx.Mul4(mgl32.Translate3D(worldPos.X(), worldPos.Y(), worldPos.Z())) modelMtx = modelMtx.Mul4(mgl32.Scale3D(0.5, 0.5, 0.5)) /* glctx.Uniform4fv(tint, red[:]) // Disable depthmask so we dont get the pixel depth of the cursor cube glctx.DepthMask(false) glctx.UniformMatrix4fv(model, modelMtx[:]) glctx.DepthMask(true) */ glctx.DisableVertexAttribArray(position) glctx.DisableVertexAttribArray(color) glctx.DisableVertexAttribArray(normals) fps.Draw(sz) }
func onPaint(glctx gl.Context, sz size.Event) { glctx.ClearColor(1, 1, 1, 1) // クリアする色 glctx.Clear(gl.COLOR_BUFFER_BIT) // 塗りつぶし? now := clock.Time(time.Since(startTime) * 60 / time.Second) // 60FramePerSecで計算し、現在のフレームを計算する game.Update(now) eng.Render(scene, now, sz) }
func (buf *TextureFramebuffer) StartSample(ctx gl.Context) { buf.fbo.Bind(ctx, buf.withtex) ctx.GetIntegerv(int32v4, gl.VIEWPORT) ctx.Viewport(0, 0, buf.w, buf.h) ctx.ClearColor(0, 0, 0, 0) ctx.Clear(gl.COLOR_BUFFER_BIT) }
func onPaint(ctx gl.Context) { ctx.ClearColor(material.BlueGrey100.RGBA()) ctx.Clear(gl.COLOR_BUFFER_BIT) env.Draw(ctx) now := time.Now() fps = int(time.Second / now.Sub(lastpaint)) lastpaint = now }
func onPaint(glctx gl.Context, sz size.Event) { glctx.ClearColor(0.2, 0.2, 0.2, 0.5) glctx.Clear(gl.DEPTH_BUFFER_BIT) glctx.Clear(gl.COLOR_BUFFER_BIT) glctx.UseProgram(program) board.Draw() }
func (vs *viewState) draw(glctx gl.Context, sz size.Event) { now := time.Now() diff := now.Sub(vs.lastDraw) vs.percentColor -= float32(diff.Seconds() * 0.5) if vs.percentColor < .25 { vs.percentColor = .25 } vs.lastDraw = now select { case change := <-vs.tc: vs.touchChange = change default: } switch vs.touchChange.Type { case touch.TypeMove: case touch.TypeBegin: now := time.Now() if vs.lastTouch.Add(time.Millisecond * 1000).Before(now) { vs.lastTouch = now vs.percentColor = 0.5 select { default: case vs.toggle <- now: } } case touch.TypeEnd: } var pingOk bool var connErr error vs.mu.RLock() pingOk = vs.pingOk connErr = vs.connErr vs.mu.RUnlock() var r, g, b = vs.percentColor, vs.percentColor, vs.percentColor if pingOk { r, b = 0, 0 } else { g, b = 0, 0 } glctx.ClearColor(r, g, b, 1) glctx.Clear(gl.COLOR_BUFFER_BIT) msg := "Tap to toggle garage door" if connErr != nil { msg = connErr.Error() } vs.sq.Draw(glctx, sz, "Garage door opener", msg) }
func onTouch(glctx gl.Context, e touch.Event) { touchX = e.X touchY = e.Y // When touch occurs we need to figure out which key is pressed. // Using color picking for this. // That is, scene is redrawn with each key given a unique color. // And then the color is read on the touched pixel to figure out which key // is pressed or if a key is pressed at all. glctx.ClearColor(0.73, 0.5, 0.75, 0.5) glctx.Clear(gl.DEPTH_BUFFER_BIT) glctx.Clear(gl.COLOR_BUFFER_BIT) glctx.UseProgram(program) board.DrawI() // Draw the board with each key in a unique color c := make([]byte, 12, 12) glctx.ReadPixels(c, int(e.X), int(e.Y), 1, 1, gl.RGB, gl.UNSIGNED_BYTE) // gl.RGB, gl.UNSIGNED_BYTE is the combination that is preffered by my Android // phone. And is said to be the one preffered by many. r := (float32(c[0]) / 255) * 100 // Convert byte to float out := float32(math.Floor(float64(r)+0.5)) / 100 // and round up key, ok := board.idColorKey[out] if !ok { curKey, ok := keystate[e.Sequence] //stop already playing sound if ok { StopSound(curKey) } return } if e.Type == touch.TypeBegin { keystate[e.Sequence] = key PlaySound(key) } else if e.Type == touch.TypeEnd { delete(keystate, e.Sequence) StopSound(key) } else if e.Type == touch.TypeMove { if keystate[e.Sequence] != key { // Drag has moved out of initial key curKey, ok := keystate[e.Sequence] //stop already playing sound if ok { StopSound(curKey) } PlaySound(key) // play new key's sound keystate[e.Sequence] = key } } }
func onDraw(glctx gl.Context, sz size.Event) { select { case <-determined: if ok { glctx.ClearColor(0, 1, 0, 1) } else { glctx.ClearColor(1, 0, 0, 1) } default: glctx.ClearColor(0, 0, 0, 1) } glctx.Clear(gl.COLOR_BUFFER_BIT) }
func onPaint(glctx gl.Context, sz size.Event, u *uistate.UIState) { if u.CurView == uistate.None { u.ScanChan = make(chan bool) go sync.ScanForSG(u.Ctx, u.ScanChan, u) view.LoadDiscoveryView(u) } glctx.ClearColor(1, 1, 1, 1) glctx.Clear(gl.COLOR_BUFFER_BIT) now := clock.Time(time.Since(u.StartTime) * 60 / time.Second) u.Eng.Render(u.Scene, now, sz) if u.Debug { fps.Draw(sz) } }
func onPaint(glctx gl.Context, sz size.Event) { //gl.Enable(gl.DEPTH_TEST) //gl.DepthFunc(gl.LESS) //清场 glctx.ClearColor(1, 1, 1, 1) //设置背景颜色 glctx.Clear(gl.COLOR_BUFFER_BIT) glctx.Clear(gl.DEPTH_BUFFER_BIT) //使用program glctx.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) glctx.UniformMatrix4fv(scan, []float32{ touchLocX/float32(sz.WidthPt)*4 - 2, 0, 0, 0, 0, touchLocY/float32(sz.HeightPt)*4 - 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, }) /*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; */ glctx.BindBuffer(gl.ARRAY_BUFFER, positionbuf) glctx.EnableVertexAttribArray(position) defer glctx.DisableVertexAttribArray(position)//必须全部缓存导入完成后再关闭 glctx.VertexAttribPointer(position, coordsPerVertex, gl.FLOAT, false, 0, 0) //导入position缓存 glctx.DrawArrays(gl.TRIANGLES, 0, vertexCount) glctx.BindBuffer(gl.ARRAY_BUFFER, colorbuf) glctx.EnableVertexAttribArray(color) defer glctx.DisableVertexAttribArray(color)//必须全部缓存导入完成后再关闭 glctx.VertexAttribPointer(color, colorsPerVertex, gl.FLOAT, false, 0, 0) //导入color缓存 glctx.DrawArrays(gl.TRIANGLES, 0, vertexCount) fps.Draw(sz) }
func onPaint(glctx gl.Context, sz size.Event) { glctx.ClearColor(1, 0, 0, 1) glctx.Clear(gl.COLOR_BUFFER_BIT) glctx.UseProgram(program) green += 0.01 if green > 1 { green = 0 } glctx.Uniform4f(color, 0, green, 0, 1) glctx.Uniform2f(offset, touchX/float32(sz.WidthPx), touchY/float32(sz.HeightPx)) glctx.BindBuffer(gl.ARRAY_BUFFER, buf) glctx.EnableVertexAttribArray(position) glctx.VertexAttribPointer(position, coordsPerVertex, gl.FLOAT, false, 0, 0) glctx.DrawArrays(gl.TRIANGLES, 0, vertexCount) glctx.DisableVertexAttribArray(position) fps.Draw(sz) }
func onPaint(glctx gl.Context, sz size.Event) { glctx.ClearColor(0.5, 0.5, 0.5, 1) glctx.Clear(gl.COLOR_BUFFER_BIT) glctx.UseProgram(frameData.Program) glctx.Uniform4f(frameData.Color, 0.5, 0.5, 0.5, 1) // Put ourselves in the +x/+y quadrant (upper right quadrant) glctx.Uniform2f(frameData.Offset, 0.0, 1.0) glctx.EnableVertexAttribArray(frameData.Position) manager.PaintLayers(sz, frameData) // End drawing glctx.DisableVertexAttribArray(frameData.Position) }
func (m *Module) draw(glctx gl.Context, sz size.Event, images *glutil.Images) { serverResponse := m.Network.Response() glctx.ClearColor(1, 1, 1, 1) glctx.Clear(gl.COLOR_BUFFER_BIT) var display render.Display display.Loaded = m.loaded if len(serverResponse.Predictions) > 0 { display.NextOK = true display.NextTrainMinutes = serverResponse.Predictions[0].Minutes display.TransitRouteName = fmt.Sprintf("%s (%s)", serverResponse.Stop.Route, serverResponse.Stop.Direction) if len(serverResponse.Predictions) > 1 { display.NextNextOK = true display.NextNextTrainMinutes = serverResponse.Predictions[1].Minutes } display.UpdatedSecondsAgo = int(time.Now().Sub(serverResponse.LastRefresh).Seconds()) display.PredictionSource = serverResponse.Predictions[0].Source } m.Render.Display(display, sz, glctx, images) }
func onPaint(ctx gl.Context) { ctx.ClearColor(0, 0, 0, 1) ctx.Clear(gl.COLOR_BUFFER_BIT) pianowf.Prepare(1) switch sz.Orientation { case size.OrientationPortrait: pianowf.Paint(ctx, -1, -1, 2, 0.5) mixwf.Paint(ctx, -1, 0.25, 2, 0.5) default: pianowf.Paint(ctx, -1, -1, 2, 1) mixwf.Paint(ctx, -1, 0.25, 2, 0.5) } btnreverb.Paint(ctx) btnlowpass.Paint(ctx) btnmetronome.Paint(ctx) btnloop.Paint(ctx) btnsndbank.Paint(ctx) now := time.Now() fps = int(time.Second / now.Sub(lastpaint)) lastpaint = now }
// This is the main rendering call that updates the current scene and all children in the scene func appPaint(glctx gl.Context, sz size.Event, delta float32) { glctx.ClearColor(currentScene.BGColor.R, currentScene.BGColor.G, currentScene.BGColor.B, currentScene.BGColor.A) glctx.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) for _, child := range currentScene.Children { child.act(delta) child.draw(tempBatch, 1.0) if len(InputChannel) > 0 { for e := range InputChannel { if child.Input != nil { child.Input(child, e) } if len(InputChannel) == 0 { break } } } } glctx.UseProgram(program) green += 0.01 if green > 1 { green = 0 } glctx.Uniform4f(color, 0, green, 0, 1) glctx.Uniform2f(offset, touchX/float32(sz.WidthPx), touchY/float32(sz.HeightPx)) glctx.BindBuffer(gl.ARRAY_BUFFER, buf) glctx.EnableVertexAttribArray(position) glctx.VertexAttribPointer(position, coordsPerVertex, gl.FLOAT, false, 0, 0) glctx.DrawArrays(gl.TRIANGLES, 0, vertexCount) glctx.DisableVertexAttribArray(position) fps.Draw(sz) }
func main() { app.Main(func(a app.App) { var ( glctx gl.Context visible bool ) addr := "127.0.0.1:" + apptest.Port log.Printf("addr: %s", addr) conn, err := net.Dial("tcp", addr) if err != nil { log.Fatal(err) } defer conn.Close() log.Printf("dialled") comm := &apptest.Comm{ Conn: conn, Fatalf: log.Panicf, Printf: log.Printf, } comm.Send("hello_from_testapp") comm.Recv("hello_from_host") color := "red" sendPainting := false for e := range a.Events() { switch e := a.Filter(e).(type) { case lifecycle.Event: switch e.Crosses(lifecycle.StageVisible) { case lifecycle.CrossOn: comm.Send("lifecycle_visible") sendPainting = true visible = true glctx, _ = e.DrawContext.(gl.Context) case lifecycle.CrossOff: comm.Send("lifecycle_not_visible") visible = false } case size.Event: comm.Send("size", e.PixelsPerPt, e.Orientation) case paint.Event: if visible { if color == "red" { glctx.ClearColor(1, 0, 0, 1) } else { glctx.ClearColor(0, 1, 0, 1) } glctx.Clear(gl.COLOR_BUFFER_BIT) a.Publish() } if sendPainting { comm.Send("paint", color) sendPainting = false } case touch.Event: comm.Send("touch", e.Type, e.X, e.Y) if e.Type == touch.TypeEnd { if color == "red" { color = "green" } else { color = "red" } sendPainting = true // Send a paint event so the screen gets redrawn. a.Send(paint.Event{}) } } } }) }
func (self *window) run() { var glctx gl.Context var frame geom.Size var scale float64 defer close(self.events) for v := range self.app.Events() { switch e := v.(type) { default: // This is none of the events that we know the mobile package should send, // probably a custom event from the application so we simply forward it. self.events <- v case paint.Event: if glctx != nil { // Always clear the content before redrawing so we don't leak left overs // of the video buffer. glctx.ClearColor(0, 0, 0, 1) glctx.Clear(gl.COLOR_BUFFER_BIT) gc := newGraphicContext(self.app, glctx) self.events <- event.Redraw{ GC: gc, Clip: geom.Rect{W: frame.W, H: frame.H}, External: e.External, } gc.join.Wait() } case size.Event: w := float64(e.WidthPt) h := float64(e.HeightPt) d := float64(e.PixelsPerPt) if w != frame.W || h != frame.H || d != scale { frame.W = w frame.H = h scale = d self.events <- event.ChangeScreen{ Bounds: geom.Rect{W: frame.W, H: frame.H}, Scale: scale, } self.events <- event.Move{} self.events <- event.Resize{ Size: frame, } } case lifecycle.Event: if e.To == lifecycle.StageDead { self.events <- event.Close{} return } switch e.Crosses(lifecycle.StageVisible) { case lifecycle.CrossOn: // The app doesn't send a paint event when it starts so we force // it here to trigger the first drawing of the newly created // window. glctx = e.DrawContext.(gl.Context) self.app.Send(paint.Event{External: true}) self.events <- event.Focus{Focused: true} case lifecycle.CrossOff: glctx = nil self.events <- event.Focus{Focused: false} } } } // Unsure under which condition the events channel could get closed before a // lifecycle event indicating the app is going away but just in case we send // a close event before returning. self.events <- event.Close{} }