Example #1
0
func NewButton(ctx gl.Context, x, y float32, w, h float32) *Button {
	btn := &Button{r: 1, g: 1, b: 1, a: 1}

	btn.x = (-(-1 - x)) / 2
	btn.y = (1 - y) / 2
	btn.w, btn.h = (w)/2, (-h)/2

	btn.verts = []float32{
		x, y, 0,
		x + w, y, 0,
		x, y + h, 0,
		x, y + h, 0,
		x + w, y, 0,
		x + w, y + h, 0,
	}

	btn.data = make([]byte, len(btn.verts)*4)

	var err error
	btn.program, err = glutil.CreateProgram(ctx, vertexShader, fragmentShader)
	if err != nil {
		panic(fmt.Errorf("error creating GL program: %v", err))
	}

	// create and alloc hw buf
	btn.buf = ctx.CreateBuffer()
	ctx.BindBuffer(gl.ARRAY_BUFFER, btn.buf)
	ctx.BufferData(gl.ARRAY_BUFFER, make([]byte, len(btn.verts)*4), gl.STATIC_DRAW)

	btn.position = ctx.GetAttribLocation(btn.program, "position")
	btn.color = ctx.GetUniformLocation(btn.program, "color")
	return btn
}
Example #2
0
// TODO just how many samples do we want/need to display something useful?
func NewWaveform(ctx gl.Context, n int, in Sound) (*Waveform, error) {
	wf := &Waveform{Sound: in}

	wf.outs = make([][]float64, n)
	for i := range wf.outs {
		wf.outs[i] = make([]float64, in.BufferLen()*in.Channels())
	}
	wf.samples = make([]float64, in.BufferLen()*in.Channels()*n)
	// wf.aligned = make([]float64, in.BufferLen()*in.Channels()*n)

	wf.verts = make([]float32, len(wf.samples)*3)
	wf.data = make([]byte, len(wf.verts)*4)

	if ctx == nil {
		return wf, nil
	}

	var err error
	wf.program, err = glutil.CreateProgram(ctx, vertexShader, fragmentShader)
	if err != nil {
		return nil, fmt.Errorf("error creating GL program: %v", err)
	}

	// create and alloc hw buf
	wf.buf = ctx.CreateBuffer()
	ctx.BindBuffer(gl.ARRAY_BUFFER, wf.buf)
	ctx.BufferData(gl.ARRAY_BUFFER, make([]byte, len(wf.samples)*12), gl.STREAM_DRAW)

	wf.position = ctx.GetAttribLocation(wf.program, "position")
	wf.color = ctx.GetUniformLocation(wf.program, "color")
	return wf, nil
}
Example #3
0
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)
}
Example #4
0
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)
}
Example #5
0
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)
}
Example #6
0
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)
}
Example #7
0
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)

		}

	}

}
Example #8
0
func (tex Texture) Bind(ctx gl.Context, options ...func(gl.Context, Texture)) {
	ctx.ActiveTexture(gl.Enum(uint32(gl.TEXTURE0) + tex.Value - 1))
	ctx.BindTexture(gl.TEXTURE_2D, tex.Texture)
	for _, opt := range options {
		opt(ctx, tex)
	}
}
Example #9
0
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
}
Example #10
0
func (prg Program) Mat4(ctx gl.Context, dst gl.Uniform, src f32.Mat4) {
	ctx.UniformMatrix4fv(dst, []float32{
		src[0][0], src[1][0], src[2][0], src[3][0],
		src[0][1], src[1][1], src[2][1], src[3][1],
		src[0][2], src[1][2], src[2][2], src[3][2],
		src[0][3], src[1][3], src[2][3], src[3][3],
	})
}
Example #11
0
func (prg Program) Mat4(ctx gl.Context, dst gl.Uniform, src f32.Mat4) {
	m := make([]float32, 16)
	for i, v := range src {
		for j, x := range v {
			m[i*4+j] = x
		}
	}
	ctx.UniformMatrix4fv(dst, m)
}
Example #12
0
File: main.go Project: bmatsuo/rex
func onStop(glctx gl.Context) {
	glctx.DeleteProgram(program)
	glctx.DeleteBuffer(buf)
	fps.Release()
	if statusPainter != nil {
		statusPainter.Release()
	}
	images.Release()
}
Example #13
0
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)
}
Example #14
0
// TODO pass in an actual Texture ...
func NewTextureBuffer(ctx gl.Context, width, height int) *TextureFramebuffer {
	buf := &TextureFramebuffer{w: width, h: height}
	buf.fbo = Framebuffer{ctx.CreateFramebuffer()}
	buf.tex = Texture{ctx.CreateTexture()}

	buf.def = TextureDef(0, width, height, gl.RGBA, nil)
	buf.filter = TextureFilter(gl.LINEAR, gl.LINEAR)
	buf.wrap = TextureWrap(gl.REPEAT, gl.REPEAT)
	buf.withtex = FramebufferWithTex(buf.tex, 0, buf.def, buf.filter, buf.wrap)
	return buf
}
Example #15
0
// NewWhiteKey is a constructor that creates and returns a WhiteKey
func NewWhiteKey(glctx gl.Context, note util.KeyNote, sz size.Event, count int) *WhiteKey {
	newWhiteKey := new(WhiteKey)
	// Create the coloring and sound for the white key.
	newWhiteKey.PianoKey = newPianoKey(glctx, whiteKeyRGBColor, note)

	// Create coordinates for this specific white key
	newWhiteKey.openGLCoords, newWhiteKey.keyOutline, newWhiteKey.keyOuterBoundary = makeWhiteKeyVector(float32(sz.WidthPx), count)
	glctx.BufferData(gl.ARRAY_BUFFER, newWhiteKey.openGLCoords, gl.STATIC_DRAW)

	return newWhiteKey
}
Example #16
0
// LoadProgram reads shader sources from the asset repository, compiles, and
// links them into a program.
func LoadProgram(glctx gl.Context, vertexAsset, fragmentAsset string) (program gl.Program, err error) {
	log.Println("LoadProgram:", vertexAsset, fragmentAsset)

	program = glctx.CreateProgram()
	if program.Value == 0 {
		return gl.Program{}, fmt.Errorf("glutil: no programs available")
	}

	err = LoadShaders(glctx, program, vertexAsset, fragmentAsset)
	return
}
Example #17
0
// Use this to exit your game safely
// It will automatically unload all your assets and dispose the stage
// Schedule an exit from the application. On android, this will cause a call to pause() and dispose() some time in the future,
// it will not immediately finish your application.
// On iOS this should be avoided in production as it breaks Apples guidelines
func appStop(glctx gl.Context) {
	println("Exiting")
	running = false
	if currentScene.OnPause != nil {
		currentScene.OnPause(currentScene)
		soundsPlayer.Close()
	}
	glctx.DeleteProgram(program)
	glctx.DeleteBuffer(buf)
	fps.Release()
	images.Release()
}
Example #18
0
// NewBlackKey is a constructor that creates and returns a BlackKey
func NewBlackKey(leftWhiteKey Key, glctx gl.Context, note util.KeyNote, sz size.Event) *BlackKey {
	newBlackKey := new(BlackKey)
	// Create the coloring and sound for the black key.
	newBlackKey.PianoKey = newPianoKey(glctx, blackKeyRGBColor, note)

	// Create coordinates for this specific black key
	newBlackKey.openGLCoords, newBlackKey.keyOutline, newBlackKey.keyOuterBoundary =
		makeBlackKeyVector(leftWhiteKey)
	glctx.BufferData(gl.ARRAY_BUFFER, newBlackKey.openGLCoords, gl.STATIC_DRAW)

	return newBlackKey
}
Example #19
0
// writeAff3 must only be called while holding windowImpl.glctxMu.
func writeAff3(glctx gl.Context, 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
	glctx.UniformMatrix3fv(u, m[:])
}
Example #20
0
// writeAffine writes the contents of an Affine to a 3x3 matrix GL uniform.
func writeAffine(glctx gl.Context, u gl.Uniform, a *f32.Affine) {
	var m [9]float32
	m[0*3+0] = a[0][0]
	m[0*3+1] = a[1][0]
	m[0*3+2] = 0
	m[1*3+0] = a[0][1]
	m[1*3+1] = a[1][1]
	m[1*3+2] = 0
	m[2*3+0] = a[0][2]
	m[2*3+1] = a[1][2]
	m[2*3+2] = 1
	glctx.UniformMatrix3fv(u, m[:])
}
Example #21
0
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)
}
Example #22
0
func onStart(ctx gl.Context) {
	env.SetPalette(material.Palette{
		Primary: material.BlueGrey500,
		Dark:    material.BlueGrey700,
		Light:   material.BlueGrey100,
		Accent:  material.DeepOrangeA200,
	})

	quits = []chan struct{}{}

	sig = make(snd.Discrete, len(material.ExpSig))
	copy(sig, material.ExpSig)
	rsig := make(snd.Discrete, len(material.ExpSig))
	copy(rsig, material.ExpSig)
	rsig.UnitInverse()
	sig = append(sig, rsig...)
	sig.NormalizeRange(0, 1)

	ctx.Enable(gl.BLEND)
	ctx.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)

	ctx.Enable(gl.CULL_FACE)
	ctx.CullFace(gl.BACK)

	env.Load(ctx)

	for i := range boxes {
		boxes[i] = env.NewMaterial(ctx)
		boxes[i].SetColor(material.BlueGrey200)
	}
}
Example #23
0
// newPianoKey creates a PianoKey with color and sound.
func newPianoKey(glctx gl.Context, keyColor util.RGBColor, note util.KeyNote) *PianoKey {
	key := new(PianoKey)
	key.keyColor = keyColor
	// Create buffer
	key.glBuf = glctx.CreateBuffer()
	glctx.BindBuffer(gl.ARRAY_BUFFER, key.glBuf)
	// Generate sound
	_ = al.OpenDevice()
	key.soundBuffers = al.GenBuffers(1)
	key.soundSources = al.GenSources(1)
	key.soundBuffers[0].BufferData(al.FormatStereo8, audio.GenSound(note), audio.SampleRate)
	key.soundSources[0].QueueBuffers(key.soundBuffers)
	return key
}
Example #24
0
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)
	}
}
Example #25
0
func unproject(glctx gl.Context, x, y float32) (mgl32.Vec3, mgl32.Vec3) {
	var wx, wy float32
	var viewport [4]int32
	glctx.GetIntegerv(viewport[:], gl.VIEWPORT)

	wx = x
	wy = float32(viewport[3]) - y

	posStart, err := mgl32.UnProject(mgl32.Vec3{wx, wy, 0}, arcball.getMtx(), projectionMtx, int(viewport[0]), int(viewport[1]), int(viewport[2]), int(viewport[3]))
	posEnd, err := mgl32.UnProject(mgl32.Vec3{wx, wy, 1}, arcball.getMtx(), projectionMtx, int(viewport[0]), int(viewport[1]), int(viewport[2]), int(viewport[3]))

	if err != nil {
		log.Printf("unable to unproject: %+v", err)
	}

	return posStart, posEnd
}
Example #26
0
func (buf *uintBuffer) Update(ctx gl.Context, data []uint32) {
	buf.count = len(data)
	subok := len(buf.bin) > 0 && len(data)*4 <= len(buf.bin)
	if !subok {
		buf.bin = make([]byte, len(data)*4)
	}
	for i, u := range data {
		buf.bin[4*i+0] = byte(u >> 0)
		buf.bin[4*i+1] = byte(u >> 8)
		buf.bin[4*i+2] = byte(u >> 16)
		buf.bin[4*i+3] = byte(u >> 24)
	}
	if subok {
		ctx.BufferSubData(gl.ELEMENT_ARRAY_BUFFER, 0, buf.bin)
	} else {
		ctx.BufferData(gl.ELEMENT_ARRAY_BUFFER, buf.bin, buf.usage)
	}
}
Example #27
0
func onStart(ctx gl.Context) {
	ctx.Enable(gl.BLEND)
	ctx.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
	ctx.Enable(gl.CULL_FACE)
	ctx.CullFace(gl.BACK)

	env.Load(ctx)
	env.LoadGlyphs(ctx)

	t112 = env.NewButton(ctx)
	t112.SetTextColor(material.White)
	t112.SetText("AAAH`e_llo |jJ go 112px")
	t112.BehaviorFlags = material.DescriptorFlat

	t56 = env.NewButton(ctx)
	t56.SetTextColor(material.White)
	t56.SetText("Hello go 56px")
	t56.BehaviorFlags = material.DescriptorFlat

	t45 = env.NewButton(ctx)
	t45.SetTextColor(material.White)
	t45.SetText("Hello go 45px")
	t45.BehaviorFlags = material.DescriptorFlat

	t34 = env.NewButton(ctx)
	t34.SetTextColor(material.White)
	t34.SetText("Hello go 34px")
	t34.BehaviorFlags = material.DescriptorFlat

	t24 = env.NewButton(ctx)
	t24.SetTextColor(material.White)
	t24.SetText("Hello go 24px")
	t24.BehaviorFlags = material.DescriptorFlat

	t20 = env.NewButton(ctx)
	t20.SetTextColor(material.White)
	t20.SetText("Hello go 20px")
	t20.BehaviorFlags = material.DescriptorFlat

	t16 = env.NewButton(ctx)
	t16.SetTextColor(material.White)
	t16.SetText("Hello go 16px")
	t16.BehaviorFlags = material.DescriptorFlat

	t14 = env.NewButton(ctx)
	t14.SetTextColor(material.White)
	t14.SetText("Hello go 14px")
	t14.BehaviorFlags = material.DescriptorFlat

	t12 = env.NewButton(ctx)
	t12.SetTextColor(material.White)
	t12.SetText("Hello go 12px")
	t12.BehaviorFlags = material.DescriptorFlat
}
Example #28
0
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
		}
	}
}
Example #29
0
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)
}
Example #30
0
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)
}