func TestStackPushPopPeek(t *testing.T) {
stack := NewTransformStack()
if !stack.Peek().ApproxEqual(mgl32.Ident4()) {
t.Errorf("Peek not working")
}
stack.Push(mgl32.HomogRotate3DY(mgl32.DegToRad(90)))
if !stack.Peek().ApproxEqual(mgl32.HomogRotate3DY(mgl32.DegToRad(90))) {
t.Errorf("Peek not working")
}
if stack.Len() != 2 {
t.Errorf("Peek alters stack length")
}
pop, err := stack.Pop()
if err != nil || !pop.ApproxEqual(mgl32.HomogRotate3DY(mgl32.DegToRad(90))) {
t.Errorf("Pop is unsuccessful")
}
if stack.Len() != 1 {
t.Errorf("Pop does not actually shorten stack")
}
_, err = stack.Pop()
if err == nil {
t.Errorf("Popping stack with 1 element does not return error as expected")
}
}
// GetCone returns the Source's directional volume cones by inner angle, outer angle,
// and outer volume.
func (s *Source) GetCone() (float32, float32, float32) {
if s.isValid() {
c := s.source.Cone()
return mgl32.DegToRad(float32(c.InnerAngle)), mgl32.DegToRad(float32(c.OuterAngle)), c.OuterVolume
}
return mgl32.DegToRad(float32(s.cone.InnerAngle)), mgl32.DegToRad(float32(s.cone.OuterAngle)), s.cone.OuterVolume
}
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
}
//NewTransform defines a new Rotation and Translation
//x, y, z are the angle in degrees rotation around the repsective axis
//addition is true when this will be applied in addition to an existing orientation
//localref is true if the orientation should be applied in the object local reference
//or in the absolute reference. If addition is false this has no effect
//xt, yt, zt are the translation offset to apply in the x, y, and z axis
//transabs is true when this translation will be applied in relation to the current
//translation ZXY YZX XYZ
func NewTransform(x, y, z float32, rot RotationType, xt, yt, zt float32, tran TranslationType) *Transform {
return &Transform{
quat: mgl32.AnglesToQuat(mgl32.DegToRad(z), mgl32.DegToRad(y), mgl32.DegToRad(x), mgl32.ZYX),
rType: rot,
trans: mgl32.Vec3{xt, yt, zt},
tType: tran,
}
}
func (c SpritesheetFrameConfig) ToSpritesheetFrame() *SpritesheetFrame {
var (
texX = c.textureX / c.textureOriginalW
texY = c.textureY / c.textureOriginalH
texW = c.textureW / c.textureOriginalW
texH = c.textureH / c.textureOriginalH
)
var (
texMove = mgl32.Translate3D(texX, -texH-texY, 0.0)
texScale = mgl32.Scale3D(texW, texH, 1.0)
texRotate = mgl32.HomogRotate3DZ(mgl32.DegToRad(0))
texAdj = texMove.Mul4(texScale).Mul4(texRotate).Transpose()
)
var (
ptScale = mgl32.Scale3D(c.sourceW/c.pxPerUnit, c.sourceH/c.pxPerUnit, 1.0)
ptAdj = ptScale.Transpose()
)
return &SpritesheetFrame{
Frame: FrameConfig{
PointAdjustment: ptAdj,
TextureAdjustment: texAdj,
},
Width: c.sourceW / c.pxPerUnit,
Height: c.sourceH / c.pxPerUnit,
}
}
func TestStackMultiPush(t *testing.T) {
stack := NewTransformStack()
scale := mgl32.Scale3D(2, 2, 2)
rot := mgl32.HomogRotate3DY(mgl32.DegToRad(90))
trans := mgl32.Translate3D(4, 5, 6)
stack.Push(trans)
stack.Push(rot)
if !stack.Peek().ApproxEqualThreshold(trans.Mul4(rot), 1e-4) {
t.Errorf("Stack does not multiply first two pushes correctly")
}
stack.Push(scale)
if !stack.Peek().ApproxEqualThreshold(trans.Mul4(rot).Mul4(scale), 1e-4) {
t.Errorf("Stack does not multiple third push correctly")
}
stack.Unwind(2)
stack.Push(scale)
if !stack.Peek().ApproxEqualThreshold(trans.Mul4(scale), 1e-4) {
t.Errorf("Unwinding and multiplying does not work correctly")
}
}
func onStart(glctx gl.Context, sz size.Event) {
log.Printf("creating GL program")
var err error
keystate = map[touch.Sequence]int{}
program, err = glutil.CreateProgram(glctx, vertexShader, fragmentShader)
if err != nil {
log.Printf("error creating GL program: %v", err)
return
}
glctx.Enable(gl.DEPTH_TEST)
position = glctx.GetAttribLocation(program, "position")
texCordIn = glctx.GetAttribLocation(program, "texCordIn")
color = glctx.GetUniformLocation(program, "color")
drawi = glctx.GetUniformLocation(program, "drawi")
projection = glctx.GetUniformLocation(program, "projection")
camera = glctx.GetUniformLocation(program, "camera")
loadTexture(glctx)
glctx.UseProgram(program)
projectionMat := mgl32.Perspective(mgl32.DegToRad(75.0), float32(1), 0.5, 40.0)
glctx.UniformMatrix4fv(projection, projectionMat[:])
cameraMat := mgl32.LookAtV(mgl32.Vec3{0.5, 0, 1.5}, mgl32.Vec3{0, 0, 0}, mgl32.Vec3{0, 1, 0})
glctx.UniformMatrix4fv(camera, cameraMat[:])
board = NewBoard(glctx, float32(0.05), 10)
numKeys := len(board.bigKeys) + len(board.smallKeys)
InitializeSound(numKeys)
}
func renderCallback(delta float64) {
gl.Viewport(0, 0, int32(app.Width), int32(app.Height))
gl.ClearColor(0.196078, 0.6, 0.8, 1.0) // some pov-ray sky blue
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
// make the projection and view matrixes
projection := mgl.Perspective(mgl.DegToRad(60.0), float32(app.Width)/float32(app.Height), 1.0, 200.0)
view := app.CameraRotation.Mat4()
view = view.Mul4(mgl.Translate3D(-app.CameraPos[0], -app.CameraPos[1], -app.CameraPos[2]))
// draw the cube
cube.Node.Draw(projection, view)
// draw all of the bullets
for _, bullet := range bullets {
bullet.Node.Draw(projection, view)
}
// draw the backboard
backboard.Node.Draw(projection, view)
// draw the ground
ground.Draw(projection, view)
//time.Sleep(10 * time.Millisecond)
}
func makePerspective(fov, aspect, near, far float32) mgl32.Mat4 {
ymax := near * float32(math.Tan(float64(mgl32.DegToRad(fov*0.5))))
ymin := -ymax
xmin := ymin * aspect
xmax := ymax * aspect
return mgl32.Frustum(xmin, xmax, ymin, ymax, near, far)
}
// Load loads and sets up the model
func (m *Model) Load(fileName string) {
m.loadFile(fileName)
shader := sm.Shader{VertSrcFile: m.data.VertShaderFile, FragSrcFile: m.data.FragShaderFile, Name: fmt.Sprintf("%s:%s", m.data.VertShaderFile, m.data.FragShaderFile)}
program, err := m.shaders.LoadProgram(shader, false)
if err != nil {
return
}
m.currentProgram = program
gl.UseProgram(m.currentProgram)
m.projection = mgl32.Perspective(mgl32.DegToRad(45.0), float32(windowWidth)/windowHeight, 0.1, 10.0)
m.projectionUniform = gl.GetUniformLocation(m.currentProgram, gl.Str("projection\x00"))
gl.UniformMatrix4fv(m.projectionUniform, 1, false, &m.projection[0])
m.camera = mgl32.LookAtV(mgl32.Vec3{3, 3, 3}, mgl32.Vec3{0, 0, 0}, mgl32.Vec3{0, 1, 0})
m.cameraUniform = gl.GetUniformLocation(m.currentProgram, gl.Str("camera\x00"))
gl.UniformMatrix4fv(m.cameraUniform, 1, false, &m.camera[0])
m.modelUniform = gl.GetUniformLocation(m.currentProgram, gl.Str("model\x00"))
gl.UniformMatrix4fv(m.modelUniform, 1, false, &m.model[0])
m.textureUniform = gl.GetUniformLocation(m.currentProgram, gl.Str("tex\x00"))
gl.Uniform1i(m.textureUniform, 0)
gl.BindFragDataLocation(m.currentProgram, 0, gl.Str("outputColor\x00"))
// Load the texture
m.textures.LoadTexture(m.data.TextureFile, m.data.TextureFile)
// Configure the vertex data
gl.GenVertexArrays(1, &m.vao)
gl.BindVertexArray(m.vao)
var vbo uint32
gl.GenBuffers(1, &vbo)
gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
gl.BufferData(gl.ARRAY_BUFFER, len(m.data.Verts)*4, gl.Ptr(m.data.Verts), gl.STATIC_DRAW)
vertAttrib := uint32(gl.GetAttribLocation(m.currentProgram, gl.Str("vert\x00")))
gl.EnableVertexAttribArray(vertAttrib)
gl.VertexAttribPointer(vertAttrib, 3, gl.FLOAT, false, m.data.VertSize*4, gl.PtrOffset(0)) // 4:number of bytes in a float32
texCoordAttrib := uint32(gl.GetAttribLocation(m.currentProgram, gl.Str("vertTexCoord\x00")))
gl.EnableVertexAttribArray(texCoordAttrib)
gl.VertexAttribPointer(texCoordAttrib, 2, gl.FLOAT, true, m.data.VertSize*4, gl.PtrOffset(3*4)) // 4:number of bytes in a float32
if m.data.Indexed {
var indices uint32
gl.GenBuffers(1, &indices)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, indices)
gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(m.data.Indices)*4, gl.Ptr(m.data.Indices), gl.STATIC_DRAW)
}
gl.BindVertexArray(0)
}
func SetPerspective(width, height int) {
Projection := mathgl.Perspective(mathgl.DegToRad(45.0), float32(width/height), 0.1, 100.0)
viewM = mathgl.LookAt(0.0, 0.0, 20.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
projectionM = Projection
gl.Disable(gl.CULL_FACE)
gl.Enable(gl.DEPTH_TEST)
}
//TestLoop is a method that initiate the game
func EngineLoop(window *glfw.Window) {
mat := mgl32.Perspective(mgl32.DegToRad(45.0), float32(graphics.WIDTH)/graphics.HEIGHT, 0.1, 100.0).Mul4(mgl32.Translate3D(0.0, 0.0, -5.0))
shader, err := mvcShader.CreateMVCShader()
if err != nil {
panic(err)
}
mesh := cubeMesh.CreateVertexArray()
newEngine := Engine{mat: mat, shader: shader.BlankShader, mesh: mesh, BaseEngine: BaseEngine{run: true, window: window}}
mesh.SetPos(newEngine.shader)
newEngine.loop(&newEngine)
}
func (me *test) Display(c *Core) {
me.o1.Draw(c)
me.o2.Draw(c)
projection := mgl32.Perspective(mgl32.DegToRad(Fov), float32(WindowWidth)/WindowHeight, Near, Far)
view := mgl32.LookAtV(mgl32.Vec3{3, 3, 3}, mgl32.Vec3{0, 0, 0}, mgl32.Vec3{0, 1, 0})
model := mgl32.Ident4()
MVP := projection.Mul4(view).Mul4(model)
gl.UniformMatrix4fv(mvpLoc, 1, false, &MVP[0])
gl.Uniform1i(TexLoc, 0)
}
func (c *Camera) GetMouseVector(windowSize mgl32.Vec2, mouse mgl32.Vec2) mgl32.Vec3 {
v, err := mgl32.UnProject(
mgl32.Vec3{mouse.X(), windowSize.Y() - mouse.Y(), 0.5},
mgl32.LookAtV(c.Translation, c.Lookat, c.Up),
mgl32.Perspective(mgl32.DegToRad(c.Angle), windowSize.X()/windowSize.Y(), c.Near, c.Far),
0, 0, int(windowSize.X()), int(windowSize.Y()),
)
if err == nil {
return v.Sub(c.Translation).Normalize()
} else {
log.Println("Error converting camera vector: ", err)
}
return c.Lookat
}
func (i *Instance) GetModel() mgl32.Mat4 {
if i.dirty {
var model mgl32.Mat4
model = mgl32.Translate3D(
i.position.X(),
i.position.Y(),
i.position.Z(),
)
model = model.Mul4(mgl32.HomogRotate3DZ(mgl32.DegToRad(i.rotation)))
model = model.Mul4(mgl32.Scale3D(i.scale.X(), i.scale.Y(), i.scale.Z()))
i.model = model
i.dirty = false
}
return i.model
}
func CreateCamera(x, y, z, width, height, fov, near, far float32) *Camera {
cam := &Camera{
Transform: CreateTransform(x, y, z),
Width: width,
Height: height,
Ratio: float32(width) / float32(height),
Fov: fov,
Near: near,
Far: far,
Projection: mgl.Perspective(mgl.DegToRad(fov), width/height, near, far),
//Projection: mgl.Ortho(-width/2,width/2,-height/2,height/2,-100,100),
}
/* do an initial update at t=0 to initialize vectors */
cam.Update(0.0)
return cam
}
// createRenderer creates a new graphics Renderer engine and does
// any initializiation necessary.
//
// NOTE: in the future, this can create either a forward or deferred
// renderer with more advanced options.
func createRenderer(mainWindow *glfw.Window) (*GameRenderer, error) {
gr := new(GameRenderer)
gr.Shaders = make(map[string]*fizzle.RenderShader)
// create the renderer itself
windowW, windowH := mainWindow.GetFramebufferSize()
forwardRenderer := fizzle.NewForwardRenderer(mainWindow)
forwardRenderer.Init(int32(windowW), int32(windowH))
gr.Renderer = forwardRenderer
gr.MainWindow = mainWindow
// load the landscape diffuse shader
shader, err := fizzle.LoadShaderProgramFromFiles(landscapeShaderPath, nil)
if err != nil {
return nil, fmt.Errorf("Failed to compile and link the diffuse shader program!\n%v", err)
}
gr.Shaders["landscape"] = shader
// load the diffuse shader
shader, err = fizzle.LoadShaderProgramFromFiles(diffuseShaderPath, nil)
if err != nil {
return nil, fmt.Errorf("Failed to compile and link the diffuse shader program!\n%v", err)
}
gr.Shaders["diffuse"] = shader
// put a test light in the renderer
light := fizzle.NewLight()
//light.Position = mgl.Vec3{8.0, 8.0, 8.0}
light.DiffuseColor = mgl.Vec4{1.0, 1.0, 1.0, 1.0}
light.Direction = mgl.Vec3{0.1, -1.0, -0.1}
light.DiffuseIntensity = 0.6
light.AmbientIntensity = 0.4
//light.Attenuation = 1.0
forwardRenderer.ActiveLights[0] = light
// setup the camera to look at the cube
gr.camera = fizzle.NewOrbitCamera(mgl.Vec3{0.0, 0.0, 0.0}, mgl.DegToRad(35.0), 16.0, mgl.DegToRad(90.0))
// set some OpenGL flags
gl.Enable(gl.CULL_FACE)
gl.Enable(gl.DEPTH_TEST)
return gr, nil
}
func TestReseed(t *testing.T) {
stack := NewTransformStack()
scale := mgl32.Scale3D(2, 2, 2)
rot := mgl32.HomogRotate3DY(mgl32.DegToRad(90))
trans := mgl32.Translate3D(4, 5, 6)
stack.Push(trans)
stack.Push(rot)
stack.Push(scale)
trans2 := mgl32.Translate3D(1, 2, 3)
err := stack.Reseed(1, trans2)
if err != nil {
t.Fatalf("Rebase returned error when it should not %v", err)
}
if !stack.Peek().ApproxEqualThreshold(trans2.Mul4(rot).Mul4(scale), 1e-4) {
t.Fatalf("Rebase does not remultiply correctly. Got\n %v expected\n %v. (Previous state:\n %v)", stack.Peek(), trans2.Mul4(rot).Mul4(scale), trans.Mul4(rot).Mul4(scale))
}
}
func TestRebase(t *testing.T) {
stack := NewTransformStack()
stack2 := NewTransformStack()
scale := mgl32.Scale3D(2, 2, 2)
rot := mgl32.HomogRotate3DY(mgl32.DegToRad(90))
trans := mgl32.Translate3D(4, 5, 6)
trans2 := mgl32.Translate3D(1, 2, 3)
stack.Push(trans)
stack.Push(rot)
stack2.Push(trans2)
stack2.Push(scale)
out, _ := Rebase(stack2, 1, stack)
if !out.Peek().ApproxEqualThreshold(trans.Mul4(rot).Mul4(trans2).Mul4(scale), 1e-4) {
t.Log("\n", out)
t.Errorf("Rebase unsuccessful. Got\n %v, expected\n %v", out.Peek(), trans.Mul4(rot).Mul4(trans2).Mul4(scale))
}
}
func ExampleReseed() {
stack := NewTransformStack()
scale := mgl32.Scale3D(2, 2, 2)
rot := mgl32.HomogRotate3DY(mgl32.DegToRad(90))
trans := mgl32.Translate3D(4, 5, 6)
stack.Push(trans)
stack.Push(rot)
stack.Push(scale)
fmt.Println("Initial state:\n", stack.Peek())
trans2 := mgl32.Translate3D(1, 2, 3)
err := stack.Reseed(1, trans2)
if err == nil {
panic("Rebase failed")
}
fmt.Println("After rebase:\n", stack.Peek())
fmt.Println("Should be:\n", trans2.Mul4(rot).Mul4(scale))
}
func Loop() bool {
if !llgl.EventLoop() {
return false
}
ratio := llgl.ResizeViewport()
if ratio != 0 {
state.projection = mgl.Perspective(mgl.DegToRad(45.0), ratio, 0.1, 10.0)
glstate.projectionUL.SetMat4(state.projection)
}
state.angle += 0.001
state.model = mgl.HomogRotate3D(float32(state.angle), mgl.Vec3{1, 0, 0})
glstate.modelUL.SetMat4(state.model)
llgl.Clear()
for i := 0; i < 1*10; i++ {
llgl.DrawTriangleArray(0, int32(len(state.data)/5))
}
fpsCounter.TickAndLog()
llgl.SwapBuffers()
return true
}
func programLoop(window *glfw.Window) error {
// the linked shader program determines how the data will be rendered
vertShader, err := gfx.NewShaderFromFile("shaders/basic.vert", gl.VERTEX_SHADER)
if err != nil {
return err
}
fragShader, err := gfx.NewShaderFromFile("shaders/basic.frag", gl.FRAGMENT_SHADER)
if err != nil {
return err
}
program, err := gfx.NewProgram(vertShader, fragShader)
if err != nil {
return err
}
defer program.Delete()
vertices := []float32{
// position // texture position
-0.5, -0.5, -0.5, 0.0, 0.0,
0.5, -0.5, -0.5, 1.0, 0.0,
0.5, 0.5, -0.5, 1.0, 1.0,
0.5, 0.5, -0.5, 1.0, 1.0,
-0.5, 0.5, -0.5, 0.0, 1.0,
-0.5, -0.5, -0.5, 0.0, 0.0,
-0.5, -0.5, 0.5, 0.0, 0.0,
0.5, -0.5, 0.5, 1.0, 0.0,
0.5, 0.5, 0.5, 1.0, 1.0,
0.5, 0.5, 0.5, 1.0, 1.0,
-0.5, 0.5, 0.5, 0.0, 1.0,
-0.5, -0.5, 0.5, 0.0, 0.0,
-0.5, 0.5, 0.5, 1.0, 0.0,
-0.5, 0.5, -0.5, 1.0, 1.0,
-0.5, -0.5, -0.5, 0.0, 1.0,
-0.5, -0.5, -0.5, 0.0, 1.0,
-0.5, -0.5, 0.5, 0.0, 0.0,
-0.5, 0.5, 0.5, 1.0, 0.0,
0.5, 0.5, 0.5, 1.0, 0.0,
0.5, 0.5, -0.5, 1.0, 1.0,
0.5, -0.5, -0.5, 0.0, 1.0,
0.5, -0.5, -0.5, 0.0, 1.0,
0.5, -0.5, 0.5, 0.0, 0.0,
0.5, 0.5, 0.5, 1.0, 0.0,
-0.5, -0.5, -0.5, 0.0, 1.0,
0.5, -0.5, -0.5, 1.0, 1.0,
0.5, -0.5, 0.5, 1.0, 0.0,
0.5, -0.5, 0.5, 1.0, 0.0,
-0.5, -0.5, 0.5, 0.0, 0.0,
-0.5, -0.5, -0.5, 0.0, 1.0,
-0.5, 0.5, -0.5, 0.0, 1.0,
0.5, 0.5, -0.5, 1.0, 1.0,
0.5, 0.5, 0.5, 1.0, 0.0,
0.5, 0.5, 0.5, 1.0, 0.0,
-0.5, 0.5, 0.5, 0.0, 0.0,
-0.5, 0.5, -0.5, 0.0, 1.0,
}
indices := []uint32{}
VAO := createVAO(vertices, indices)
texture0, err := gfx.NewTextureFromFile("../images/RTS_Crate.png",
gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE)
if err != nil {
panic(err.Error())
}
texture1, err := gfx.NewTextureFromFile("../images/trollface-transparent.png",
gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE)
if err != nil {
panic(err.Error())
}
cubePositions := [][]float32{
[]float32{0.0, 0.0, -3.0},
[]float32{2.0, 5.0, -15.0},
[]float32{-1.5, -2.2, -2.5},
[]float32{-3.8, -2.0, -12.3},
[]float32{2.4, -0.4, -3.5},
[]float32{-1.7, 3.0, -7.5},
[]float32{1.3, -2.0, -2.5},
[]float32{1.5, 2.0, -2.5},
[]float32{1.5, 0.2, -1.5},
[]float32{-1.3, 1.0, -1.5},
}
gl.Enable(gl.DEPTH_TEST)
for !window.ShouldClose() {
// poll events and call their registered callbacks
glfw.PollEvents()
// background color
gl.ClearColor(0.2, 0.5, 0.5, 1.0)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
// draw vertices
program.Use()
// set texture0 to uniform0 in the fragment shader
texture0.Bind(gl.TEXTURE0)
texture0.SetUniform(program.GetUniformLocation("ourTexture0"))
// set texture1 to uniform1 in the fragment shader
texture1.Bind(gl.TEXTURE1)
texture1.SetUniform(program.GetUniformLocation("ourTexture1"))
// update shader transform matrices
// Create transformation matrices
rotateX := (mgl32.Rotate3DX(mgl32.DegToRad(-60 * float32(glfw.GetTime()))))
rotateY := (mgl32.Rotate3DY(mgl32.DegToRad(-60 * float32(glfw.GetTime()))))
rotateZ := (mgl32.Rotate3DZ(mgl32.DegToRad(-60 * float32(glfw.GetTime()))))
viewTransform := mgl32.Translate3D(0, 0, -3)
projectTransform := mgl32.Perspective(mgl32.DegToRad(60), windowWidth/windowHeight, 0.1, 100.0)
gl.UniformMatrix4fv(program.GetUniformLocation("view"), 1, false,
&viewTransform[0])
gl.UniformMatrix4fv(program.GetUniformLocation("project"), 1, false,
&projectTransform[0])
gl.UniformMatrix4fv(program.GetUniformLocation("worldRotateX"), 1, false,
&rotateX[0])
gl.UniformMatrix4fv(program.GetUniformLocation("worldRotateY"), 1, false,
&rotateY[0])
gl.UniformMatrix4fv(program.GetUniformLocation("worldRotateZ"), 1, false,
&rotateZ[0])
gl.BindVertexArray(VAO)
for _, pos := range cubePositions {
worldTranslate := mgl32.Translate3D(pos[0], pos[1], pos[2])
worldTransform := (worldTranslate.Mul4(rotateX.Mul3(rotateY).Mul3(rotateZ).Mat4()))
gl.UniformMatrix4fv(program.GetUniformLocation("world"), 1, false,
&worldTransform[0])
gl.DrawArrays(gl.TRIANGLES, 0, 36)
}
// gl.DrawElements(gl.TRIANGLES, 36, gl.UNSIGNED_INT, unsafe.Pointer(nil))
gl.BindVertexArray(0)
texture0.UnBind()
texture1.UnBind()
// end of draw loop
// swap in the rendered buffer
window.SwapBuffers()
}
return nil
}
func (s *Sprite) transform() mgl.Mat4 {
S := mgl.Scale2D(s.scale, s.scale).Mat4()
R := mgl.Rotate2D(mgl.DegToRad(s.rotation)).Mat4()
T := mgl.Translate3D(s.x, s.y, 0)
return T.Mul4(R).Mul4(S)
}
func (gl *GameLayer) Render() {
var (
count = int(gl.state.ObjectCount)
tiles []twodee.SpriteConfig = make([]twodee.SpriteConfig, count)
player []twodee.SpriteConfig = make([]twodee.SpriteConfig, 1)
rando []twodee.SpriteConfig
frame *twodee.SpritesheetFrame
frame1 *twodee.SpritesheetFrame = gl.sheet.GetFrame("numbered_squares_tall_07")
frame2 *twodee.SpritesheetFrame = gl.sheet.GetFrame("numbered_squares_wide_14")
coord float32
playerPt = gl.player.Pos()
)
gl.batch.Bind()
if err := gl.batch.Draw(gl.level, 0, 0, 0); err != nil {
panic(err)
}
gl.batch.Unbind()
gl.sheetTexture.Bind()
for i := 0; i < count; i++ {
frame = gl.sheet.GetFrame(fmt.Sprintf("numbered_squares_%02d", (i%16)+1))
coord = float32(i-(count/2)) / (float32(count) / 20.0)
tiles[i] = twodee.SpriteConfig{
View: twodee.ModelViewConfig{
coord, coord, 0,
mgl32.DegToRad(float32(i * 15)), 0.0, 0.0,
1.0, 1.0, 1.0,
},
Frame: frame.Frame,
}
}
frame = gl.sheet.GetFrame(fmt.Sprintf("numbered_squares_%02d", gl.player.Frame()+1))
player[0] = twodee.SpriteConfig{
View: twodee.ModelViewConfig{
playerPt.X, playerPt.Y, 0,
0, 0, 0,
1.0, 1.0, 1.0,
},
Frame: frame.Frame,
}
gl.glow.Bind()
gl.sprite.Draw(player)
gl.glow.Unbind()
rando = []twodee.SpriteConfig{
twodee.SpriteConfig{
View: twodee.ModelViewConfig{
playerPt.X - 1.0, playerPt.Y - 2.0, 0,
0, 0, 0,
1.0, 1.0, 1.0,
},
Frame: frame1.Frame,
},
twodee.SpriteConfig{
View: twodee.ModelViewConfig{
0, 0, 0,
0, 0, 0,
1.0, 1.0, 1.0,
},
Frame: frame2.Frame,
},
}
gl.sprite.Draw(tiles)
gl.sprite.Draw(rando)
gl.sprite.Draw(player)
gl.glow.Draw()
gl.sheetTexture.Unbind()
if len(gl.lineSegments) > 1 {
line := twodee.NewLineGeometry(gl.lineSegments, false)
style := &twodee.LineStyle{
Thickness: 0.2,
Color: color.RGBA{0, 0, 255, 128},
Inner: 0.0,
}
modelview := mgl32.Ident4()
gl.lines.Bind()
gl.lines.Draw(line, modelview, style)
gl.lines.Unbind()
}
}
func main() {
vertices, normals := obj.Parse(os.Args[1])
// initialize GLFW
if err := glfw.Init(); err != nil {
panic(err)
}
defer glfw.Terminate()
// set opengl core profile 3.3
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True)
window, err := glfw.CreateWindow(640, 480, "GOpenGL", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
// initialise OpenGL library
if err := gl.Init(); err != nil {
panic(err)
}
// link program from shaders
program, err := newProgram("vertex.glsl", "fragment.glsl")
if err != nil {
panic(err)
}
gl.UseProgram(program)
// vertex attribute object holds links between attributes and vbo
var vao uint32
gl.GenVertexArrays(1, &vao)
gl.BindVertexArray(vao)
// vertex buffer with per-vertex data
var vbo [2]uint32
gl.GenBuffers(2, &vbo[0])
// position data
gl.BindBuffer(gl.ARRAY_BUFFER, vbo[0])
gl.BufferData(gl.ARRAY_BUFFER, len(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW)
// set up position attribute with layout of vertices
posAttrib := uint32(gl.GetAttribLocation(program, gl.Str("position\x00")))
gl.VertexAttribPointer(posAttrib, 3, gl.FLOAT, false, 3*4, gl.PtrOffset(0))
gl.EnableVertexAttribArray(posAttrib)
// normal data
gl.BindBuffer(gl.ARRAY_BUFFER, vbo[1])
gl.BufferData(gl.ARRAY_BUFFER, len(normals)*4, gl.Ptr(normals), gl.STATIC_DRAW)
normAttrib := uint32(gl.GetAttribLocation(program, gl.Str("normal\x00")))
gl.VertexAttribPointer(normAttrib, 3, gl.FLOAT, false, 3*4, gl.PtrOffset(0))
gl.EnableVertexAttribArray(normAttrib)
uniModel := gl.GetUniformLocation(program, gl.Str("model\x00"))
uniView := gl.GetUniformLocation(program, gl.Str("view\x00"))
uniProj := gl.GetUniformLocation(program, gl.Str("proj\x00"))
matView := mgl32.LookAt(2.0, 2.0, 2.0,
0.0, 0.0, 0.0,
0.0, 0.0, 1.0)
gl.UniformMatrix4fv(uniView, 1, false, &matView[0])
matProj := mgl32.Perspective(mgl32.DegToRad(45.0), 640.0/480.0, 1.0, 10.0)
gl.UniformMatrix4fv(uniProj, 1, false, &matProj[0])
uniLightDir := gl.GetUniformLocation(program, gl.Str("lightDir\x00"))
uniLightCol := gl.GetUniformLocation(program, gl.Str("lightCol\x00"))
gl.Uniform3f(uniLightDir, -0.5, 0.0, -1.0)
gl.Uniform3f(uniLightCol, 0.0, 0.5, 0.5)
startTime := glfw.GetTime()
gl.Enable(gl.DEPTH_TEST)
gl.ClearColor(1.0, 1.0, 1.0, 1.0)
for !window.ShouldClose() {
// clear buffer
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
matRot := mgl32.HomogRotate3DZ(float32(glfw.GetTime() - startTime))
gl.UniformMatrix4fv(uniModel, 1, false, &matRot[0])
gl.DrawArrays(gl.TRIANGLES, 0, int32(len(vertices)))
window.SwapBuffers()
glfw.PollEvents()
}
}
func programLoop(window *win.Window) error {
// the linked shader program determines how the data will be rendered
vertShader, err := gfx.NewShaderFromFile("shaders/basic.vert", gl.VERTEX_SHADER)
if err != nil {
return err
}
fragShader, err := gfx.NewShaderFromFile("shaders/basic.frag", gl.FRAGMENT_SHADER)
if err != nil {
return err
}
program, err := gfx.NewProgram(vertShader, fragShader)
if err != nil {
return err
}
defer program.Delete()
VAO := createVAO(cubeVertices, nil)
texture0, err := gfx.NewTextureFromFile("../images/RTS_Crate.png",
gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE)
if err != nil {
panic(err.Error())
}
texture1, err := gfx.NewTextureFromFile("../images/trollface-transparent.png",
gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE)
if err != nil {
panic(err.Error())
}
// ensure that triangles that are "behind" others do not draw over top of them
gl.Enable(gl.DEPTH_TEST)
camera := cam.NewFpsCamera(mgl32.Vec3{0, 0, 3}, mgl32.Vec3{0, 1, 0}, -90, 0, window.InputManager())
for !window.ShouldClose() {
// swaps in last buffer, polls for window events, and generally sets up for a new render frame
window.StartFrame()
// update camera position and direction from input evevnts
camera.Update(window.SinceLastFrame())
// background color
gl.ClearColor(0.2, 0.5, 0.5, 1.0)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) // depth buffer needed for DEPTH_TEST
program.Use()
// bind textures
texture0.Bind(gl.TEXTURE0)
texture0.SetUniform(program.GetUniformLocation("ourTexture0"))
texture1.Bind(gl.TEXTURE1)
texture1.SetUniform(program.GetUniformLocation("ourTexture1"))
// cube rotation matrices
rotateX := (mgl32.Rotate3DX(mgl32.DegToRad(-60 * float32(glfw.GetTime()))))
rotateY := (mgl32.Rotate3DY(mgl32.DegToRad(-60 * float32(glfw.GetTime()))))
rotateZ := (mgl32.Rotate3DZ(mgl32.DegToRad(-60 * float32(glfw.GetTime()))))
// creates perspective
fov := float32(60.0)
projectTransform := mgl32.Perspective(mgl32.DegToRad(fov),
float32(window.Width())/float32(window.Height()),
0.1,
100.0)
camTransform := camera.GetTransform()
gl.UniformMatrix4fv(program.GetUniformLocation("camera"), 1, false, &camTransform[0])
gl.UniformMatrix4fv(program.GetUniformLocation("project"), 1, false,
&projectTransform[0])
gl.BindVertexArray(VAO)
// draw each cube after all coordinate system transforms are bound
for _, pos := range cubePositions {
worldTranslate := mgl32.Translate3D(pos[0], pos[1], pos[2])
worldTransform := (worldTranslate.Mul4(rotateX.Mul3(rotateY).Mul3(rotateZ).Mat4()))
gl.UniformMatrix4fv(program.GetUniformLocation("world"), 1, false,
&worldTransform[0])
gl.DrawArrays(gl.TRIANGLES, 0, 36)
}
gl.BindVertexArray(0)
texture0.UnBind()
texture1.UnBind()
// end of draw loop
}
return nil
}
func Main() {
err := glfw.Init()
if err != nil {
panic(err)
}
defer glfw.Terminate()
glfw.WindowHint(glfw.Resizable, glfw.False)
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 2)
glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True)
window, err := glfw.CreateWindow(WindowWidth, WindowHeight, "Cube", nil, nil)
Window = window
if err != nil {
panic(err)
}
window.MakeContextCurrent()
// Initialize Glow
if err := gl.Init(); err != nil {
panic(err)
}
version := gl.GoStr(gl.GetString(gl.VERSION))
fmt.Println("OpenGL version", version)
// Configure the vertex and fragment shaders
program, err := newProgram("SimpleVertexShader.vertexshader", "SimpleFragmentShader.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])
textureUniform := gl.GetUniformLocation(program, gl.Str("tex\x00"))
gl.Uniform1i(textureUniform, 0)
gl.BindFragDataLocation(program, 0, gl.Str("outputColor\x00"))
// Configure global settings
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
gl.ClearColor(1.0, 1.0, 1.0, 1.0)
angle := 0.0
previousTime := glfw.GetTime()
width, height := window.GetSize()
window.SetCursorPos(float64(width/2), float64(height/2))
window.SetKeyCallback(input.OnKey)
window.SetCursorPosCallback(input.OnCursor)
window.SetMouseButtonCallback(input.OnMouse)
meshes.LoadColladaCube("cube.dae")
for !player.ShouldClose {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
// Update
time := glfw.GetTime()
elapsed := time - previousTime
previousTime = time
angle += elapsed
model = mgl32.HomogRotate3D(float32(angle), mgl32.Vec3{0, 1, 0})
// Render
gl.UseProgram(program)
// gl.UniformMatrix4fv(modelUniform, 1, false, &model[0])
player.MainPlayer.Draw(program)
for _, element := range game.Universe {
(element).Draw(program)
}
// Maintenance
window.SwapBuffers()
glfw.PollEvents()
}
}
// SetPerspective set a perspective projection
func (cam *Camera) SetPerspective(angle float32, w int, h int, zDepth int) {
cam.Bounds = mgl32.Vec3{float32(w), float32(h), float32(zDepth)}
cam.projection = mgl32.Perspective(mgl32.DegToRad(angle), float32(w)/float32(h), 0.1, 10.0)
cam.update()
}
func programLoop(window *win.Window) error {
// the linked shader program determines how the data will be rendered
vertShader, err := gfx.NewShaderFromFile("shaders/phong.vert", gl.VERTEX_SHADER)
if err != nil {
return err
}
fragShader, err := gfx.NewShaderFromFile("shaders/phong.frag", gl.FRAGMENT_SHADER)
if err != nil {
return err
}
program, err := gfx.NewProgram(vertShader, fragShader)
if err != nil {
return err
}
defer program.Delete()
lightFragShader, err := gfx.NewShaderFromFile("shaders/light.frag", gl.FRAGMENT_SHADER)
if err != nil {
return err
}
// special shader program so that lights themselves are not affected by lighting
lightProgram, err := gfx.NewProgram(vertShader, lightFragShader)
if err != nil {
return err
}
VAO := createVAO(cubeVertices, nil)
lightVAO := createVAO(cubeVertices, nil)
// ensure that triangles that are "behind" others do not draw over top of them
gl.Enable(gl.DEPTH_TEST)
camera := cam.NewFpsCamera(mgl32.Vec3{0, 0, 3}, mgl32.Vec3{0, 1, 0}, -90, 0, window.InputManager())
for !window.ShouldClose() {
// swaps in last buffer, polls for window events, and generally sets up for a new render frame
window.StartFrame()
// update camera position and direction from input evevnts
camera.Update(window.SinceLastFrame())
// background color
gl.ClearColor(0, 0, 0, 1.0)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) // depth buffer needed for DEPTH_TEST
// cube rotation matrices
rotateX := (mgl32.Rotate3DX(mgl32.DegToRad(-45 * float32(glfw.GetTime()))))
rotateY := (mgl32.Rotate3DY(mgl32.DegToRad(-45 * float32(glfw.GetTime()))))
rotateZ := (mgl32.Rotate3DZ(mgl32.DegToRad(-45 * float32(glfw.GetTime()))))
// creates perspective
fov := float32(60.0)
projectTransform := mgl32.Perspective(mgl32.DegToRad(fov),
float32(window.Width())/float32(window.Height()),
0.1,
100.0)
camTransform := camera.GetTransform()
lightPos := mgl32.Vec3{0.6, 1, 0.1}
lightTransform := mgl32.Translate3D(lightPos.X(), lightPos.Y(), lightPos.Z()).Mul4(
mgl32.Scale3D(0.2, 0.2, 0.2))
program.Use()
gl.UniformMatrix4fv(program.GetUniformLocation("view"), 1, false, &camTransform[0])
gl.UniformMatrix4fv(program.GetUniformLocation("project"), 1, false,
&projectTransform[0])
gl.BindVertexArray(VAO)
// draw each cube after all coordinate system transforms are bound
// obj is colored, light is white
gl.Uniform3f(program.GetUniformLocation("material.ambient"), 1.0, 0.5, 0.31)
gl.Uniform3f(program.GetUniformLocation("material.diffuse"), 1.0, 0.5, 0.31)
gl.Uniform3f(program.GetUniformLocation("material.specular"), 0.5, 0.5, 0.5)
gl.Uniform1f(program.GetUniformLocation("material.shininess"), 32.0)
lightColor := mgl32.Vec3{
float32(math.Sin(glfw.GetTime() * 1)),
float32(math.Sin(glfw.GetTime() * 0.35)),
float32(math.Sin(glfw.GetTime() * 0.65)),
}
diffuseColor := mgl32.Vec3{
0.5 * lightColor[0],
0.5 * lightColor[1],
0.5 * lightColor[2],
}
ambientColor := mgl32.Vec3{
0.2 * lightColor[0],
0.2 * lightColor[1],
0.2 * lightColor[2],
}
gl.Uniform3f(program.GetUniformLocation("light.ambient"),
ambientColor[0], ambientColor[1], ambientColor[2])
gl.Uniform3f(program.GetUniformLocation("light.diffuse"),
diffuseColor[0], diffuseColor[1], diffuseColor[2])
gl.Uniform3f(program.GetUniformLocation("light.specular"), 1.0, 1.0, 1.0)
gl.Uniform3f(program.GetUniformLocation("light.position"), lightPos.X(), lightPos.Y(), lightPos.Z())
for _, pos := range cubePositions {
// turn the cubes into rectangular prisms for more fun
worldTranslate := mgl32.Translate3D(pos[0], pos[1], pos[2])
worldTransform := worldTranslate.Mul4(
rotateX.Mul3(rotateY).Mul3(rotateZ).Mat4(),
)
gl.UniformMatrix4fv(program.GetUniformLocation("model"), 1, false,
&worldTransform[0])
gl.DrawArrays(gl.TRIANGLES, 0, 36)
}
gl.BindVertexArray(0)
// Draw the light obj after the other boxes using its separate shader program
// this means that we must re-bind any uniforms
lightProgram.Use()
gl.BindVertexArray(lightVAO)
gl.UniformMatrix4fv(lightProgram.GetUniformLocation("model"), 1, false, &lightTransform[0])
gl.UniformMatrix4fv(lightProgram.GetUniformLocation("view"), 1, false, &camTransform[0])
gl.UniformMatrix4fv(lightProgram.GetUniformLocation("project"), 1, false, &projectTransform[0])
gl.DrawArrays(gl.TRIANGLES, 0, 36)
gl.BindVertexArray(0)
// end of draw loop
}
return nil
}
func main() {
if err := glfw.Init(); err != nil {
log.Fatalln("failed to initialize glfw:", 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)
window, err := glfw.CreateWindow(windowWidth, windowHeight, "Cube", nil, nil)
if err != nil {
panic(err)
}
window.MakeContextCurrent()
// Initialize Glow
if err := gl.Init(); err != nil {
panic(err)
}
version := gl.GoStr(gl.GetString(gl.VERSION))
fmt.Println("OpenGL version", version)
// Configure the vertex and fragment shaders
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])
textureUniform := gl.GetUniformLocation(program, gl.Str("tex\x00"))
gl.Uniform1i(textureUniform, 0)
gl.BindFragDataLocation(program, 0, gl.Str("outputColor\x00"))
// Load the texture
texture, err := newTexture("square.png")
if err != nil {
panic(err)
}
// Configure the vertex data
var vao uint32
gl.GenVertexArrays(1, &vao)
gl.BindVertexArray(vao)
var vbo uint32
gl.GenBuffers(1, &vbo)
gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
gl.BufferData(gl.ARRAY_BUFFER, len(cubeVertices)*4, gl.Ptr(cubeVertices), gl.STATIC_DRAW)
vertAttrib := uint32(gl.GetAttribLocation(program, gl.Str("vert\x00")))
gl.EnableVertexAttribArray(vertAttrib)
gl.VertexAttribPointer(vertAttrib, 3, gl.FLOAT, false, 5*4, gl.PtrOffset(0))
texCoordAttrib := uint32(gl.GetAttribLocation(program, gl.Str("vertTexCoord\x00")))
gl.EnableVertexAttribArray(texCoordAttrib)
gl.VertexAttribPointer(texCoordAttrib, 2, gl.FLOAT, false, 5*4, gl.PtrOffset(3*4))
// Configure global settings
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
gl.ClearColor(1.0, 1.0, 1.0, 1.0)
angle := 0.0
previousTime := glfw.GetTime()
for !window.ShouldClose() {
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
// Update
time := glfw.GetTime()
elapsed := time - previousTime
previousTime = time
angle += elapsed
model = mgl32.HomogRotate3D(float32(angle), mgl32.Vec3{0, 1, 0})
// Render
gl.UseProgram(program)
gl.UniformMatrix4fv(modelUniform, 1, false, &model[0])
gl.BindVertexArray(vao)
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, texture)
gl.DrawArrays(gl.TRIANGLES, 0, 6*2*3)
// Maintenance
window.SwapBuffers()
glfw.PollEvents()
}
}