func (m *Map) Draw() {
gl.PushMatrix()
gl.PushAttrib(gl.CURRENT_BIT | gl.ENABLE_BIT | gl.LIGHTING_BIT | gl.POLYGON_BIT | gl.LINE_BIT)
gl.EnableClientState(gl.VERTEX_ARRAY)
gl.VertexPointer(3, gl.FLOAT, 0, m.vertices)
gl.EnableClientState(gl.NORMAL_ARRAY)
gl.NormalPointer(gl.FLOAT, 0, m.normals)
// gl.EnableClientState(gl.TEXTURE_COORD_ARRAY)
// gl.TexCoordPointer(2, gl.FLOAT, 0, m.texcoords)
gl.EnableClientState(gl.COLOR_ARRAY)
gl.ColorPointer(3, gl.FLOAT, 0, m.colors)
// draw solids
gl.Enable(gl.COLOR_MATERIAL)
// gl.DrawArrays(gl.TRIANGLE_STRIP, 0, len(m.vertices)/3)
gl.PolygonMode(gl.FRONT_AND_BACK, gl.LINE)
gl.LineWidth(1.0)
gl.Color4f(1, 1, 1, 1)
gl.DrawArrays(gl.TRIANGLE_STRIP, 0, len(m.vertices)/3)
gl.PopAttrib()
gl.PopMatrix()
}
func (r *RenderTarget) resetGlStates() {
// Define the default OpenGL states
gl.Disable(gl.CULL_FACE)
gl.Disable(gl.LIGHTING)
gl.Disable(gl.DEPTH_TEST)
gl.Disable(gl.ALPHA_TEST)
gl.Enable(gl.TEXTURE_2D)
gl.Enable(gl.BLEND)
gl.MatrixMode(gl.MODELVIEW)
gl.EnableClientState(gl.VERTEX_ARRAY)
gl.EnableClientState(gl.COLOR_ARRAY)
gl.EnableClientState(gl.TEXTURE_COORD_ARRAY)
r.glStatesSet = true
// Apply the default SFML states
r.applyBlendMode(BlendAlpha)
r.applyTransform(IdentityTransform())
r.applyTexture(nil)
/*if (Shader::isAvailable()){
r.applyShader(nil)
}*/
r.useVertexCache = false
// Set the default view
r.SetView(r.View())
}
func (m *Map) Draw() {
// gl.Enable(gl.PRIMITIVE_RESTART)
// gl.PrimitiveRestartIndex(PRIMITIVE_RESTART)
gl.EnableClientState(gl.VERTEX_ARRAY)
gl.Translatef(float32(m.gridSize/2), float32(m.gridSize/2), 0)
if m.renderSmooth {
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.Enable(gl.POLYGON_SMOOTH)
gl.Hint(gl.POLYGON_SMOOTH_HINT, gl.NICEST)
}
if m.renderMode == 1 {
gl.LineWidth(1)
gl.VertexPointer(2, gl.FLOAT, 0, m.gridLines)
gl.Color3f(0.2, 0.2, 0.2)
gl.DrawArrays(gl.LINES, 0, len(m.gridLines)/2)
gl.PolygonMode(gl.FRONT_AND_BACK, gl.LINE)
}
for _, vl := range m.vl {
if len(vl.vertices) > 0 {
gl.VertexPointer(2, gl.FLOAT, 0, vl.vertices)
gl.Color3f(vl.colors[0], vl.colors[1], vl.colors[2])
gl.DrawElements(gl.TRIANGLES, len(vl.indices), gl.UNSIGNED_INT, vl.indices)
}
}
}
func main() {
if !glfw.Init() {
log.Fatal("glfw failed to initialize")
}
defer glfw.Terminate()
window, err := glfw.CreateWindow(640, 480, "Deformable", nil, nil)
if err != nil {
log.Fatal(err.Error())
}
window.MakeContextCurrent()
glfw.SwapInterval(1)
window.SetMouseButtonCallback(handleMouseButton)
window.SetKeyCallback(handleKeyDown)
window.SetInputMode(glfw.Cursor, glfw.CursorHidden)
gl.Init()
initGL()
i := 16
m = GenerateMap(1600/i, 1200/i, i)
for running && !window.ShouldClose() {
x, y := window.GetCursorPosition()
if drawing != 0 {
m.Add(int(x)+int(camera[0]), int(y)+int(camera[1]), drawing, brushSizes[currentBrushSize])
}
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.LoadIdentity()
gl.PushMatrix()
gl.PushAttrib(gl.CURRENT_BIT | gl.ENABLE_BIT | gl.LIGHTING_BIT | gl.POLYGON_BIT | gl.LINE_BIT)
gl.Translatef(-camera[0], -camera[1], 0)
m.Draw()
gl.PopAttrib()
gl.PopMatrix()
gl.PushAttrib(gl.COLOR_BUFFER_BIT)
gl.LineWidth(2)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.ONE_MINUS_DST_COLOR, gl.ZERO)
// gl.Enable(gl.LINE_SMOOTH)
// gl.Hint(gl.LINE_SMOOTH_HINT, gl.NICEST)
gl.Translatef(float32(x), float32(y), 0)
gl.EnableClientState(gl.VERTEX_ARRAY)
gl.VertexPointer(2, gl.DOUBLE, 0, cursorVerts)
gl.DrawArrays(gl.LINE_LOOP, 0, 24)
gl.PopAttrib()
window.SwapBuffers()
glfw.PollEvents()
}
}
// Arrays mode uses vertex arrays which involves gl*Pointer calls and
// directly passing in the vertex data on every render pass. This is slower
// than using VBO's, because the data has to be uploaded to the GPU on every
// render pass, but it is useful for older systems where glBufferData is
// not available.
func (mb *MeshBuffer) renderArrays(mode gl.GLenum, m Mesh, pa, ca, na, ta, ia *Attr) {
ps, pc := m[mbPositionKey][0], m[mbPositionKey][1]
is, ic := m[mbIndexKey][0], m[mbIndexKey][1]
cc := m[mbColorKey][1]
nc := m[mbNormalKey][1]
tc := m[mbTexCoordKey][1]
gl.PushClientAttrib(gl.CLIENT_VERTEX_ARRAY_BIT)
defer gl.PopClientAttrib()
if pc > 0 {
gl.EnableClientState(gl.VERTEX_ARRAY)
defer gl.DisableClientState(gl.VERTEX_ARRAY)
gl.VertexPointer(pa.size, pa.typ, 0, pa.ptr(0))
}
if cc > 0 {
gl.EnableClientState(gl.COLOR_ARRAY)
defer gl.DisableClientState(gl.COLOR_ARRAY)
gl.ColorPointer(ca.size, ca.typ, 0, ca.ptr(0))
}
if nc > 0 {
gl.EnableClientState(gl.NORMAL_ARRAY)
defer gl.DisableClientState(gl.NORMAL_ARRAY)
gl.NormalPointer(na.typ, 0, na.ptr(0))
}
if tc > 0 {
gl.EnableClientState(gl.TEXTURE_COORD_ARRAY)
defer gl.DisableClientState(gl.TEXTURE_COORD_ARRAY)
gl.TexCoordPointer(ta.size, ta.typ, 0, ta.ptr(0))
}
if ic > 0 {
gl.EnableClientState(gl.INDEX_ARRAY)
defer gl.DisableClientState(gl.INDEX_ARRAY)
gl.IndexPointer(ia.typ, 0, ia.ptr(0))
gl.DrawElements(mode, ic, ia.typ, ia.ptr(is*ia.size))
} else {
gl.DrawArrays(mode, ps, pc)
}
}
// renderBuffered uses VBO's. This is the preferred mode for systems
// where shader support is not present or deemed necessary.
func (mb *MeshBuffer) renderBuffered(mode gl.GLenum, m Mesh, pa, ca, na, ta, ia *Attr) {
ps, pc := m[mbPositionKey][0], m[mbPositionKey][1]
is, ic := m[mbIndexKey][0], m[mbIndexKey][1]
cc := m[mbColorKey][1]
nc := m[mbNormalKey][1]
tc := m[mbTexCoordKey][1]
if pc > 0 {
gl.EnableClientState(gl.VERTEX_ARRAY)
defer gl.DisableClientState(gl.VERTEX_ARRAY)
pa.bind()
if pa.Invalid() {
pa.buffer()
}
gl.VertexPointer(pa.size, pa.typ, 0, uintptr(0))
pa.unbind()
}
if cc > 0 {
gl.EnableClientState(gl.COLOR_ARRAY)
defer gl.DisableClientState(gl.COLOR_ARRAY)
ca.bind()
if ca.Invalid() {
ca.buffer()
}
gl.ColorPointer(ca.size, ca.typ, 0, uintptr(0))
ca.unbind()
}
if nc > 0 {
gl.EnableClientState(gl.NORMAL_ARRAY)
defer gl.DisableClientState(gl.NORMAL_ARRAY)
na.bind()
if na.Invalid() {
na.buffer()
}
gl.NormalPointer(na.typ, 0, uintptr(0))
na.unbind()
}
if tc > 0 {
gl.EnableClientState(gl.TEXTURE_COORD_ARRAY)
defer gl.DisableClientState(gl.TEXTURE_COORD_ARRAY)
ta.bind()
if ta.Invalid() {
ta.buffer()
}
gl.TexCoordPointer(ta.size, ta.typ, 0, uintptr(0))
ta.unbind()
}
if ic > 0 {
ia.bind()
if ia.Invalid() {
ia.buffer()
}
gl.PushClientAttrib(gl.CLIENT_VERTEX_ARRAY_BIT)
gl.DrawElements(mode, ic, ia.typ, uintptr(is*ia.stride))
gl.PopClientAttrib()
ia.unbind()
} else {
pa.bind()
gl.PushClientAttrib(gl.CLIENT_VERTEX_ARRAY_BIT)
gl.DrawArrays(mode, ps, pc)
gl.PopClientAttrib()
pa.unbind()
}
}