コード例 #1
0
func ExampleRebase() {
	parent1 := NewTransformStack()

	scale := mgl32.Scale3D(2, 2, 2)
	rot := mgl32.HomogRotate3DY(mgl32.DegToRad(90))
	trans := mgl32.Translate3D(5, 5, 5)

	parent1.Push(trans)
	parent1.Push(rot)
	parent1.Push(scale)

	parent2 := parent1.Copy()

	trans2 := mgl32.Translate3D(1, 1, 1)
	rot2 := mgl32.HomogRotate3DX(mgl32.DegToRad(45))
	parent1.Push(trans2)
	parent1.Push(rot2)

	// Replay the pushes the changes from parent1 after the copy onto parent2, as if
	// they had been done on parent2 instead
	parent2, err := Rebase(parent1, 4, parent2)

	if err != nil {
		panic(err)
	}

	// Now parent2 and parent 1 should be the same!
	fmt.Println(parent2.Peek().ApproxEqualThreshold(parent1.Peek(), 1e-4))
	// Output: true
}
コード例 #2
0
ファイル: cube.go プロジェクト: noonat/goggles
func main() {
	document := js.Global.Get("document")

	var viewportScale float32 = 2.0

	canvas := document.Call("createElement", "canvas")
	canvas.Set("id", "canvas")
	canvas.Set("width", viewportWidth*viewportScale)
	canvas.Set("height", viewportHeight*viewportScale)
	canvas.Get("style").Set("width", fmt.Sprintf("%dpx", int(viewportWidth)))
	canvas.Get("style").Set("height", fmt.Sprintf("%dpx", int(viewportHeight)))
	document.Get("body").Call("appendChild", canvas)

	textCanvas := document.Call("createElement", "canvas")
	textCanvas.Set("id", "text-canvas")
	textCanvas.Set("width", viewportWidth*viewportScale)
	textCanvas.Set("height", viewportHeight*viewportScale)
	textCanvas.Get("style").Set("width", fmt.Sprintf("%dpx", int(viewportWidth)))
	textCanvas.Get("style").Set("height", fmt.Sprintf("%dpx", int(viewportHeight)))
	document.Get("body").Call("appendChild", textCanvas)

	textContext := textCanvas.Call("getContext", "2d")
	textContext.Call("setTransform", viewportScale, 0, 0, viewportScale, 0, 0)

	attrs := webgl.DefaultAttributes()
	attrs.Alpha = false

	gl, err := webgl.NewContext(canvas, attrs)
	if err != nil {
		goggles.Error(err.Error())
		return
	}

	fragmentShader := gl.CreateShader(gl.FRAGMENT_SHADER)
	gl.ShaderSource(fragmentShader, fragmentShaderSource)
	gl.CompileShader(fragmentShader)
	if !gl.GetShaderParameterb(fragmentShader, gl.COMPILE_STATUS) {
		goggles.Error(gl.GetShaderInfoLog(fragmentShader))
		return
	}

	vertexShader := gl.CreateShader(gl.VERTEX_SHADER)
	gl.ShaderSource(vertexShader, vertexShaderSource)
	gl.CompileShader(vertexShader)
	if !gl.GetShaderParameterb(vertexShader, gl.COMPILE_STATUS) {
		goggles.Error(gl.GetShaderInfoLog(vertexShader))
		return
	}

	program := gl.CreateProgram()
	gl.AttachShader(program, vertexShader)
	gl.AttachShader(program, fragmentShader)
	gl.LinkProgram(program)
	if !gl.GetProgramParameterb(program, gl.LINK_STATUS) {
		goggles.Error(gl.GetProgramInfoLog(program))
		return
	}

	gl.UseProgram(program)

	inVertexPositionLocation := gl.GetAttribLocation(program, "inVertexPosition")
	inVertexColorLocation := gl.GetAttribLocation(program, "inVertexColor")
	modelViewMatrixLocation := gl.GetUniformLocation(program, "modelViewMatrix")
	projectionMatrixLocation := gl.GetUniformLocation(program, "projectionMatrix")

	gl.EnableVertexAttribArray(inVertexPositionLocation)
	gl.EnableVertexAttribArray(inVertexColorLocation)

	vertexPositionBuffer := gl.CreateBuffer()
	gl.BindBuffer(gl.ARRAY_BUFFER, vertexPositionBuffer)
	gl.BufferData(gl.ARRAY_BUFFER, vertexPositionData, gl.STATIC_DRAW)

	vertexColorBuffer := gl.CreateBuffer()
	gl.BindBuffer(gl.ARRAY_BUFFER, vertexColorBuffer)
	gl.BufferData(gl.ARRAY_BUFFER, vertexColorData, gl.STATIC_DRAW)

	indexBuffer := gl.CreateBuffer()
	gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer)
	gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, indexData, gl.STATIC_DRAW)

	gl.Viewport(0, 0, int(viewportWidth*viewportScale), int(viewportHeight*viewportScale))

	var pitch float32 = 0.0
	var yaw float32 = 0.0
	var tweenTime float32 = 0.0

	var tick func(float32)

	tick = func(timeMs float32) {
		textContext.Call("clearRect", 0, 0, viewportWidth, viewportHeight)
		textContext.Set("font", "12px sans-serif")
		textContext.Set("fillStyle", "rgb(255, 255, 255)")
		textContext.Call("fillText", "Hello, world!", 10, 20)

		time := timeMs / 1000

		if tweenTime == 0.0 {
			tweenTime = time + 1.0
		}

		for tweenTime < time {
			tweenTime += 1.0
			pitch = float32(math.Mod(float64(pitch)+60.0, 360.0))
			yaw = float32(math.Mod(float64(yaw)+40.0, 360.0))
		}

		factor := tweenTime - time
		if factor < 0.0 {
			factor = 0.0
		} else if factor > 1.0 {
			factor = 1.0
		}
		factor = 1.0 - float32(math.Pow(float64(factor), 4.0))

		tweenPitch := pitch + (60.0 * factor)
		tweenYaw := yaw + (40.0 * factor)

		gl.ClearColor(0, 0, 0, 1)
		gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
		gl.Enable(gl.CULL_FACE)
		gl.FrontFace(gl.CW)

		modelViewMatrix := mgl32.Ident4().
			Mul4(mgl32.Translate3D(0, 0, -4)).
			Mul4(mgl32.HomogRotate3DX(goggles.DegToRad(tweenPitch))).
			Mul4(mgl32.HomogRotate3DY(goggles.DegToRad(tweenYaw)))
		gl.UniformMatrix4fv(modelViewMatrixLocation, false, modelViewMatrix[:])

		projectionMatrix := mgl32.Perspective(goggles.DegToRad(60), viewportWidth/viewportHeight, 0.1, 2048)
		gl.UniformMatrix4fv(projectionMatrixLocation, false, projectionMatrix[:])

		gl.BindBuffer(gl.ARRAY_BUFFER, vertexPositionBuffer)
		gl.VertexAttribPointer(inVertexPositionLocation, 3, gl.FLOAT, false, 0, 0)
		gl.BindBuffer(gl.ARRAY_BUFFER, vertexColorBuffer)
		gl.VertexAttribPointer(inVertexColorLocation, 3, gl.FLOAT, false, 0, 0)
		gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer)
		gl.DrawElements(gl.TRIANGLES, len(indexData), gl.UNSIGNED_SHORT, 0)

		goggles.RequestAnimationFrame(tick)
	}

	goggles.RequestAnimationFrame(tick)
}
コード例 #3
0
ファイル: main.go プロジェクト: yucchiy/toybox-opengl
func main() {
	// init glfw
	if err := glfw.Init(); err != nil {
		panic(err)
	}

	defer glfw.Terminate()

	glfw.WindowHint(glfw.Resizable, glfw.False)
	glfw.WindowHint(glfw.ContextVersionMajor, 4)
	glfw.WindowHint(glfw.ContextVersionMinor, 1)
	glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
	glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True)

	// make an application window
	window, err := glfw.CreateWindow(windowWidth, windowHeight, "Transform", nil, nil)
	if err != nil {
		panic(err)
	}
	window.MakeContextCurrent()

	// init gl
	if err := gl.Init(); err != nil {
		panic(err)
	}
	fmt.Println("OpenGL version", gl.GoStr(gl.GetString(gl.VERSION)))

	// create vertex & fragment shader
	program, err := newProgram(vertexShader, fragmentShader)
	if err != nil {
		panic(err)
	}
	gl.UseProgram(program)

	projection := mgl32.Perspective(mgl32.DegToRad(45.0), float32(windowWidth)/windowHeight, 0.1, 10.0)
	projectionUniform := gl.GetUniformLocation(program, gl.Str("projection\x00"))
	gl.UniformMatrix4fv(projectionUniform, 1, false, &projection[0])

	camera := mgl32.LookAtV(
		mgl32.Vec3{3, 3, 3},
		mgl32.Vec3{0, 0, 0},
		mgl32.Vec3{0, 1, 0},
	)
	cameraUniform := gl.GetUniformLocation(program, gl.Str("camera\x00"))
	gl.UniformMatrix4fv(cameraUniform, 1, false, &camera[0])

	model := mgl32.Ident4()
	modelUniform := gl.GetUniformLocation(program, gl.Str("model\x00"))
	gl.UniformMatrix4fv(modelUniform, 1, false, &model[0])

	gl.BindFragDataLocation(program, 0, gl.Str("vert\x00"))

	points := []float32{
		-0.9, -0.9, -0.9,
		0.9, -0.9, -0.9,
		0.9, -0.9, 0.9,
		-0.9, -0.9, 0.9,
		-0.9, 0.9, -0.9,
		0.9, 0.9, -0.9,
		0.9, 0.9, 0.9,
		-0.9, 0.9, 0.9,
	}

	vertices := []uint32{
		0, 1,
		1, 2,
		2, 3,
		3, 0,
		0, 4,
		1, 5,
		2, 6,
		3, 7,
		4, 5,
		5, 6,
		6, 7,
		7, 4,
	}

	// configure the vertex data
	var vao uint32
	gl.GenVertexArrays(1, &vao)
	gl.BindVertexArray(vao)

	defer gl.BindVertexArray(0)

	var vbo uint32
	gl.GenBuffers(1, &vbo)
	gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
	gl.BufferData(gl.ARRAY_BUFFER, len(points)*4, gl.Ptr(points), gl.STATIC_DRAW)

	var ibo uint32
	gl.GenBuffers(1, &ibo)
	gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo)
	gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW)

	vertAttrib := uint32(gl.GetAttribLocation(program, gl.Str("vert\x00")))
	gl.EnableVertexAttribArray(vertAttrib)
	gl.VertexAttribPointer(vertAttrib, 3, gl.FLOAT, false, 3*4, gl.PtrOffset(0))

	// global settings
	gl.Enable(gl.DEPTH_TEST)
	gl.DepthFunc(gl.LESS)
	gl.ClearColor(0.0, 0.0, 0.0, 1.0)

	angleX := 0.0
	angleY := 0.0
	angleZ := 0.0
	previousTime := glfw.GetTime()

	for !window.ShouldClose() {
		gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)

		time := glfw.GetTime()
		elapsed := time - previousTime
		previousTime = time

		angleX += math.Sin((elapsed / period) * math.Pi * 2.0)
		angleY += math.Sin((elapsed / period) / 6.0 * math.Pi * 2.0)
		angleZ += math.Sin((elapsed / period) / 3.0 * math.Pi * 2.0)
		model = mgl32.HomogRotate3DY(float32(angleY)).Mul4(mgl32.HomogRotate3DX(float32(angleX))).Mul4(mgl32.HomogRotate3DZ(float32(angleZ)))
		gl.UseProgram(program)
		gl.UniformMatrix4fv(modelUniform, 1, false, &model[0])

		gl.BindVertexArray(vao)

		gl.DrawElements(gl.LINES, int32(len(vertices)), gl.UNSIGNED_INT, gl.PtrOffset(0))

		window.SwapBuffers()
		glfw.PollEvents()
	}
}