Golang Context.Viewport方法代码示例

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(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 (buf *TextureFramebuffer) StopSample(ctx gl.Context) {
	ctx.Viewport(int(int32v4[0]), int(int32v4[1]), int(int32v4[2]), int(int32v4[3]))
	// TODO Unbind should maybe take options too?
	buf.fbo.Unbind(ctx)
	// sbuf.tex.Unbind(ctx)
}

func main() {
	app.Main(func(a app.App) {
		var glctx gl.Context
		visible, sz := false, size.Event{}
		for e := range a.Events() {
			switch e := a.Filter(e).(type) {
			case lifecycle.Event:
				switch e.Crosses(lifecycle.StageVisible) {
				case lifecycle.CrossOn:
					visible = true
					glctx, _ = e.DrawContext.(gl.Context)
					onStart(glctx)
				case lifecycle.CrossOff:
					visible = false
					onStop(glctx)
				}
			case size.Event:
				sz = e
				width = sz.WidthPx
				height = sz.HeightPx
				touchX = float32(sz.WidthPx / 2)
				touchY = float32(sz.HeightPx / 2)
				if glctx != nil {
					glctx.Viewport(0, 0, sz.WidthPx, sz.HeightPx)
				}
			case paint.Event:
				onPaint(glctx, sz)
				a.Publish()
				if visible {
					n := time.Now()
					piano.update(n.Sub(lastUpdate))
					lastUpdate = n
					// Drive the animation by preparing to paint the next frame
					// after this one is shown.
					//
					// TODO: is paint.Event the right thing to send? Should we
					// have a dedicated publish.Event type? Should App.Publish
					// take an optional event sender and send a publish.Event?
					a.Send(paint.Event{})
				}
			case touch.Event:
				touchX = e.X
				touchY = e.Y
				worldRayStart, worldRayEnd := unproject(glctx, e.X, e.Y)

				if !piano.HandleTouch(worldRayStart, worldRayEnd, e) && !beganOnPiano {
					if e.Type == touch.TypeMove {
						arcball.move(int(e.X), int(e.Y))
					} else if e.Type == touch.TypeBegin {
						arcball.begin(int(e.X), int(e.Y))
					} else {
						arcball.end()
					}
				} else if e.Type == touch.TypeBegin {
					beganOnPiano = true
				} else if e.Type == touch.TypeEnd {
					beganOnPiano = false
				}

			case key.Event:
				if e.Code == key.CodeEscape {
					visible = false
					onStop(glctx)
					os.Exit(0)
				}
			}
		}
	})
}