func render() {
modelMatrix = trig.MatrixMult(trig.RotateY(math.Pi/360), modelMatrix)
gl.Viewport(0, 0, 768, 768)
gl.ClearColor(0.0, 0.0, 0, 0)
gl.Enable(gl.DEPTH_TEST)
raytraceProgram.Use()
mInput.UniformMatrix4f(false, (*[16]float32)(modelMatrix))
vInput.UniformMatrix4f(false, (*[16]float32)(viewMatrix))
pInput.UniformMatrix4f(false, (*[16]float32)(projMatrix))
glh.With(framebuffer, func() {
framebuffer.UpdateTextures()
gl.DrawBuffer(gl.COLOR_ATTACHMENT0)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.DepthFunc(gl.GREATER)
gl.CullFace(gl.BACK)
cube.Render(gl.TRIANGLES, raytraceProgram)
gl.DrawBuffer(gl.COLOR_ATTACHMENT1)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.DepthFunc(gl.LESS)
gl.CullFace(gl.FRONT)
cube.Render(gl.TRIANGLES, raytraceProgram)
})
}
// initGL initializes GLFW and OpenGL.
func initGL() error {
err := glfw.Init()
if err != nil {
return err
}
glfw.OpenWindowHint(glfw.FsaaSamples, 4)
err = glfw.OpenWindow(512, 512, 8, 8, 8, 8, 0, 0, glfw.Windowed)
if err != nil {
glfw.Terminate()
return err
}
glfw.SetWindowTitle("Meshbuffer 2D example")
glfw.SetSwapInterval(1)
glfw.SetWindowSizeCallback(onResize)
glfw.SetKeyCallback(onKey)
gl.Init()
if err = glh.CheckGLError(); err != nil {
return err
}
gl.Disable(gl.DEPTH_TEST)
gl.Enable(gl.MULTISAMPLE)
gl.Disable(gl.LIGHTING)
gl.Enable(gl.COLOR_MATERIAL)
gl.ClearColor(0.2, 0.2, 0.23, 1.0)
return nil
}
// NewRenderer creates a new Renderer with the given window size and title.
func NewRenderer(window *Window) (*Renderer, error) {
logger.Debug("Initializing GLEW")
// Init glew
if gl.Init() != 0 {
return nil, errors.New("Could not initialise glew.")
}
gl.GetError()
if window.Settings.ClearColor != nil {
color := window.Settings.ClearColor
gl.ClearColor(
gl.GLclampf(color.R()),
gl.GLclampf(color.G()),
gl.GLclampf(color.B()),
0.,
)
}
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
gl.Enable(gl.CULL_FACE)
// Vertex buffers
vertexArray := gl.GenVertexArray()
vertexArray.Bind()
renderer := Renderer{
vertexArray: vertexArray,
window: window,
}
return &renderer, nil
}
func main() {
if err := glfw.Init(); err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err.Error())
return
}
defer glfw.Terminate()
glfw.OpenWindowHint(glfw.FsaaSamples, 4)
glfw.OpenWindowHint(glfw.OpenGLVersionMajor, 3)
glfw.OpenWindowHint(glfw.OpenGLVersionMinor, 3)
glfw.OpenWindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
if err := glfw.OpenWindow(1024, 768, 0, 0, 0, 0, 32, 0, glfw.Windowed); err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err.Error())
return
}
gl.Init()
gl.GetError() // Ignore error
glfw.SetWindowTitle("Tutorial 01")
glfw.Enable(glfw.StickyKeys)
gl.ClearColor(0., 0., 0.4, 0.)
// Equivalent to a do... while
for ok := true; ok; ok = (glfw.Key(glfw.KeyEsc) != glfw.KeyPress && glfw.WindowParam(glfw.Opened) == gl.TRUE) {
glfw.SwapBuffers()
}
}
func initScene() (err error) {
gl.Enable(gl.TEXTURE_2D)
gl.Enable(gl.DEPTH_TEST)
gl.Enable(gl.LIGHTING)
gl.ClearColor(0.5, 0.5, 0.5, 0.0)
gl.ClearDepth(1)
gl.DepthFunc(gl.LEQUAL)
gl.Lightfv(gl.LIGHT0, gl.AMBIENT, ambient)
gl.Lightfv(gl.LIGHT0, gl.DIFFUSE, diffuse)
gl.Lightfv(gl.LIGHT0, gl.POSITION, lightpos)
gl.Enable(gl.LIGHT0)
gl.Viewport(0, 0, Width, Height)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Frustum(-1, 1, -1, 1, 1.0, 10.0)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
goph, err := os.Open("../../data/gopher.png")
if err != nil {
panic(err)
}
defer goph.Close()
texture, err = createTexture(goph)
return
}
func initGL() (err error) {
if err = loadTextures(); err != nil {
return
}
gl.ShadeModel(gl.SMOOTH)
gl.ClearColor(0, 0, 0, 0)
gl.ClearDepth(1)
gl.DepthFunc(gl.LEQUAL)
gl.Hint(gl.PERSPECTIVE_CORRECTION_HINT, gl.NICEST)
gl.Enable(gl.TEXTURE_2D)
gl.Enable(gl.DEPTH_TEST)
//alpha通道的值为 0.0意味着物体材质是完全透明的。1.0 则意味着完全不透明
//以全亮度绘制此物体，并对其进行50%的alpha混合(半透明)。
//当混合选项打开时，此物体将会产生50%的透明效果
gl.Color4f(1, 1, 1, 0.5) //全亮度， 50% Alpha 混合
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE) //基于源象素alpha通道值的半透明混合函数
gl.Lightfv(gl.LIGHT1, gl.AMBIENT, ambient)
gl.Lightfv(gl.LIGHT1, gl.AMBIENT, diffuse)
gl.Lightfv(gl.LIGHT1, gl.POSITION, lightpos)
gl.Enable(gl.LIGHT1)
return
}
// initGL initializes GLFW and OpenGL.
func initGL() error {
err := glfw.Init()
if err != nil {
return err
}
err = glfw.OpenWindow(640, 480, 8, 8, 8, 8, 0, 0, glfw.Windowed)
if err != nil {
glfw.Terminate()
return err
}
glfw.SetWindowTitle("go-gl/gltext: Bitmap font example")
glfw.SetSwapInterval(1)
glfw.SetWindowSizeCallback(onResize)
glfw.SetKeyCallback(onKey)
errno := gl.Init()
if errno != gl.NO_ERROR {
str, err := glu.ErrorString(errno)
if err != nil {
return fmt.Errorf("Unknown openGL error: %d", errno)
}
return fmt.Errorf(str)
}
gl.Disable(gl.DEPTH_TEST)
gl.Disable(gl.LIGHTING)
gl.ClearColor(0.2, 0.2, 0.23, 0.0)
return nil
}
// initGL initializes GLFW and OpenGL.
func initGL() error {
err := glfw.Init()
if err != nil {
return err
}
err = glfw.OpenWindow(AtlasSize, AtlasSize, 8, 8, 8, 8, 0, 0, glfw.Windowed)
if err != nil {
glfw.Terminate()
return err
}
glfw.SetWindowTitle("Texture atlas example")
glfw.SetSwapInterval(1)
glfw.SetWindowSizeCallback(onResize)
glfw.SetKeyCallback(onKey)
gl.Init()
if err = glh.CheckGLError(); err != nil {
return err
}
gl.Disable(gl.DEPTH_TEST)
gl.Disable(gl.LIGHTING)
gl.Enable(gl.TEXTURE_2D)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.ClearColor(0.2, 0.2, 0.23, 1.0)
return nil
}
func initGL() (err error) {
if err = loadTextures(); err != nil {
return
}
gl.ShadeModel(gl.SMOOTH) /// 启用阴影平滑,设置平滑着色,阴影平滑通过多边形精细的混合色彩，并对外部光进行平滑
/*
色彩值的范围从0.0f到1.0f。0.0f代表最黑的情况，1.0f就是最亮的情况。
glClearColor 后的第一个参数是Red Intensity(红色分量),第二个是绿色，第三个是蓝色。最大值也是1.0f，代表特定颜色分量的最亮情况。
最后一个参数是Alpha值。当它用来清除屏幕的时候，我们不用关心第四个数字。现在让它为0.0f.
*/
gl.ClearColor(0, 0, 0, 0) ///设置清除屏幕时所用的颜色,黑色背景
/*
接下来的三行必须做的是关于depth buffer(深度缓存)的。将深度缓存设想为屏幕后面的层。
深度缓存不断的对物体进入屏幕内部有多深进行跟踪。
本程序其实没有真正使用深度缓存，但几乎所有在屏幕上显示3D场景OpenGL程序都使用深度缓存。
它的排序决定那个物体先画。这样您就不会将一个圆形后面的正方形画到圆形上来。深度缓存是OpenGL十分重要的部分。
*/
gl.ClearDepth(1) ///设置深度缓存
gl.DepthFunc(gl.LEQUAL) ///所作深度测试的类型
gl.Hint(gl.PERSPECTIVE_CORRECTION_HINT, gl.NICEST) ///告诉系统对透视进行修正,这会十分轻微的影响性能。但使得透视图看起来好一点
gl.Enable(gl.DEPTH_TEST) ///启用深度测试
gl.Enable(gl.TEXTURE_2D) ///启用纹理映射
return
}
func main() {
runtime.LockOSThread()
if !glfw.Init() {
fmt.Fprintf(os.Stderr, "Can't open GLFW")
return
}
defer glfw.Terminate()
glfw.WindowHint(glfw.Samples, 4)
glfw.WindowHint(glfw.ContextVersionMajor, 3)
glfw.WindowHint(glfw.ContextVersionMinor, 3)
glfw.WindowHint(glfw.OpenglProfile, glfw.OpenglCoreProfile)
glfw.WindowHint(glfw.OpenglForwardCompatible, glfw.True) // needed for macs
window, err := glfw.CreateWindow(1024, 768, "Tutorial 1", nil, nil)
if err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
return
}
window.MakeContextCurrent()
gl.Init()
gl.GetError() // Ignore error
window.SetInputMode(glfw.StickyKeys, 1)
gl.ClearColor(0., 0., 0.4, 0.)
// Equivalent to a do... while
for ok := true; ok; ok = (window.GetKey(glfw.KeyEscape) != glfw.Press && !window.ShouldClose()) {
window.SwapBuffers()
glfw.PollEvents()
}
}
func Init() {
runtime.LockOSThread()
// Initialize GLFW
var err error
if err = glfw.Init(); err != nil {
log.Fatalf("%v\n", err)
return
}
err = glfw.OpenWindow(SCREEN_WIDTH, SCREEN_HEIGHT,
0, 0, 0, 0, 0, 0, glfw.Windowed)
if err != nil {
log.Fatalf("%v\n", err)
return
}
glfw.SetWindowTitle("Mandelbrot")
glfw.SetSwapInterval(1)
glfw.SetWindowSizeCallback(onResize)
glfw.SetWindowCloseCallback(onClose)
glfw.SetMouseButtonCallback(onMouseBtn)
glfw.SetMouseWheelCallback(onMouseWheel)
glfw.SetKeyCallback(onKey)
glfw.SetCharCallback(onChar)
// Initialize OpenGL
gl.Disable(gl.DEPTH_TEST)
gl.ClearColor(0, 0, 0, 0)
}
func initGL() (err error) {
goph, err := os.Open(texturefiles[0])
if err != nil {
panic(err)
}
defer goph.Close()
texture, err = createTexture(goph)
gl.ShadeModel(gl.SMOOTH)
gl.ClearColor(0, 0, 0, 0.5)
gl.ClearDepth(1)
gl.Hint(gl.PERSPECTIVE_CORRECTION_HINT, gl.NICEST)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE) // 设置混色函数取得半透明效果
gl.Enable(gl.BLEND)
gl.Enable(gl.TEXTURE_2D)
rand.Seed(time.Now().Unix())
for loop = 0; loop < num; loop++ {
star[loop].angle = 0.0
star[loop].dist = float32(loop) / num * 5
//fmt.Println(loop, star[loop].dist)
star[loop].r = uint8(rand.Int() % 256)
star[loop].g = uint8(rand.Int() % 256)
star[loop].b = uint8(rand.Int() % 256)
}
return
}
// initGL initializes GLFW and OpenGL.
func initGL(c *cpu.CPU, width, height int) error {
err := glfw.Init()
if err != nil {
return err
}
glfw.OpenWindowHint(glfw.WindowNoResize, 1)
err = glfw.OpenWindow(width, height, 8, 8, 8, 8, 8, 0, glfw.Windowed)
if err != nil {
glfw.Terminate()
return err
}
glfw.SetWindowTitle("DCPU")
glfw.SetSwapInterval(1)
glfw.SetWindowSizeCallback(onResize)
gl.Init()
err = glh.CheckGLError()
if err != nil {
return err
}
gl.Disable(gl.LIGHTING)
gl.Disable(gl.DEPTH_TEST)
gl.Enable(gl.TEXTURE_2D)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.ClearColor(0, 0, 0, 1)
return err
}
// Clear the alpha channel in the color buffer
func ClearAlpha(alpha_value gl.GLclampf) {
With(Attrib{gl.COLOR_BUFFER_BIT}, func() {
gl.ColorMask(false, false, false, true)
gl.ClearColor(0, 0, 0, alpha_value)
gl.Clear(gl.COLOR_BUFFER_BIT)
})
}
// Initialize the window. Returns an error if glfw or glew throws one.
func InitWindow(width, height int) error {
Width, Height = width, height
err := glfw.Init()
if err != nil {
return err
}
err = glfw.OpenWindow(Width, Height, 0, 0, 0, 32, 32, 32, glfw.Windowed)
if err != nil {
return err
}
WindowOpened = true
glfw.SetWindowTitle("Goliath")
glfw.Enable(glfw.KeyRepeat)
if ret := gl.Init(); ret != 0 {
return fmt.Errorf("failed to initialize GLEW: %d", ret)
}
// Set GL states
gl.ClearColor(0.0, 0.0, 0.0, 1.0)
gl.Enable(gl.CULL_FACE)
gl.CullFace(gl.BACK)
gl.FrontFace(gl.CCW)
err = InitShaders()
if err != nil {
return err
}
InitCamera(Width, Height)
return nil
}
// program & OpenGL initialization
func Init() {
gl.ShadeModel(gl.SMOOTH) // 启用阴影平滑
gl.ClearColor(0.0, 0.0, 0.0, 0.0) // 黑色背景
gl.ClearDepth(1.0) // 设置深度缓存
gl.Enable(gl.DEPTH_TEST) // 启用深度测试
gl.DepthFunc(gl.LEQUAL) // 所作深度测试的类型
gl.Hint(gl.PERSPECTIVE_CORRECTION_HINT, gl.NICEST) // 告诉系统对透视进行修正
}
func initGL() {
gl.ShadeModel(gl.SMOOTH)
gl.ClearColor(0, 0, 0, 0)
gl.ClearDepth(1)
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LEQUAL)
gl.Hint(gl.PERSPECTIVE_CORRECTION_HINT, gl.NICEST)
}
func main() {
if err := glfw.Init(); err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err.Error())
return
}
defer glfw.Terminate()
glfw.OpenWindowHint(glfw.FsaaSamples, 4)
glfw.OpenWindowHint(glfw.OpenGLVersionMajor, 3)
glfw.OpenWindowHint(glfw.OpenGLVersionMinor, 3)
glfw.OpenWindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
if err := glfw.OpenWindow(1024, 768, 0, 0, 0, 0, 32, 0, glfw.Windowed); err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err.Error())
return
}
gl.Init() // Can't find gl.GLEW_OK or any variation, not sure how to check if this worked
gl.GetError() // Ignore error
glfw.SetWindowTitle("Tutorial 02")
glfw.Enable(glfw.StickyKeys)
gl.ClearColor(0., 0., 0.4, 0.)
prog := helper.MakeProgram("SimpleVertexShader.vertexshader", "SimpleFragmentShader.fragmentshader")
vBufferData := [...]float32{
-1., -1., 0.,
1., -1., 0.,
0., 1., 0.}
vertexArray := gl.GenVertexArray()
vertexArray.Bind()
buffer := gl.GenBuffer()
buffer.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(vBufferData)*4, &vBufferData, gl.STATIC_DRAW)
// Equivalent to a do... while
for ok := true; ok; ok = (glfw.Key(glfw.KeyEsc) != glfw.KeyPress && glfw.WindowParam(glfw.Opened) == gl.TRUE) {
gl.Clear(gl.COLOR_BUFFER_BIT)
prog.Use()
attribLoc := gl.AttribLocation(0)
attribLoc.EnableArray()
buffer.Bind(gl.ARRAY_BUFFER)
attribLoc.AttribPointer(3, gl.FLOAT, false, 0, nil)
gl.DrawArrays(gl.TRIANGLES, 0, 3)
attribLoc.DisableArray()
glfw.SwapBuffers()
}
}
func (s *System) Run(ctx *scene.Context) {
s.init(ctx)
defer s.finish()
// TODO: take active camera node
w := float32(s.Width)
h := float32(s.Height)
projM := mathgl.Ortho(0, w, h, 0, -30, 30)
viewM := mathgl.Translate3D(0, 0, 0)
worldM := mathgl.Translate3D(0, 0, 0)
var rect struct {
WVP mathgl.Mat4f `uniform:"WorldViewProjectionM"`
Diffuse *gfx.Sampler2D `uniform:"Diffuse"`
geomobj gfx.Geometry
geom gfx.GeometryLayout
}
rect.WVP = projM.Mul4(viewM).Mul4(worldM)
s.cmds <- func() {
quadbuffer := geometry.NewBuilder(s.shader.VertexFormat())
quadbuffer.Clear()
quadbuffer.P(0, 0, 0).UV(-1, -1).Cf(1, 1, 1, 1)
quadbuffer.P(w/3, 0, 0).UV(-1, -1)
quadbuffer.P(w/3, h/3, 0).UV(-1, -1)
quadbuffer.P(0, h/3, 0).UV(-1, -1)
quadbuffer.Indices(0, 1, 2, 2, 0, 3)
rect.geomobj.Alloc(gfx.StaticDraw)
err := rect.geomobj.CopyFrom(quadbuffer)
if err != nil {
panic(err)
}
s.shader.Use()
rect.geom.Layout(&s.shader, &rect.geomobj)
/*
err = rect.geomobj.CopyFrom(quadbuffer)
if err != nil {
panic(err)
}
*/
whiteImg := image.NewNRGBA(image.Rect(0, 0, 1, 1))
whiteImg.Set(0, 0, color.White)
white, err := gfx.Image(whiteImg)
if err != nil {
panic(err)
}
rect.Diffuse = white
}
for ctx.Step() {
s.cmds <- func() {
gl.Viewport(0, 0, s.Width, s.Height)
gl.ClearColor(0, 0, 0, 1.0)
gl.ClearDepth(1)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
}
s.meshes.update(s.cmds, &s.shader)
s.draw()
s.sync()
}
}
func (r *Renderer) Initialize() {
r.vertices = []mapVertex{
{200, 200, 0, 1, 1, 1, 1, 0, 0},
{218, 200, 0, 1, 0, 0, 1, 0, 0},
}
vs, err := LoadShader(vertexShader, gl.VERTEX_SHADER)
if err != nil {
panic(err)
}
gs, err := LoadShader(geometryShader, gl.GEOMETRY_SHADER)
if err != nil {
panic(err)
}
fs, err := LoadShader(fragmentShader, gl.FRAGMENT_SHADER)
if err != nil {
panic(err)
}
gl.ClearColor(0, 1, 0, 0)
// Create the VAO
// GL 3+ allows us to store the vertex layout in a vertex array object (VAO).
r.vao = gl.GenVertexArray()
r.vao.Bind()
// Create VBO
r.vbo = gl.GenBuffer()
r.vbo.Bind(gl.ARRAY_BUFFER)
gl.BufferData(gl.ARRAY_BUFFER, len(r.vertices)*4*9, r.vertices, gl.DYNAMIC_DRAW)
prog, err := LoadProgram(vs, gs, fs)
if err != nil {
panic(err)
}
prog.Use()
r.prog = prog
r.mvmLocation = r.prog.GetUniformLocation("modelview_matrix")
pos := r.prog.GetAttribLocation("in_position")
color := r.prog.GetAttribLocation("in_color")
texcoord := r.prog.GetAttribLocation("in_texcoord")
// FIXME: size math
pos.AttribPointer(3, gl.FLOAT, false, 9*4, nil)
color.AttribPointer(4, gl.FLOAT, false, 9*4, uintptr(3*4))
texcoord.AttribPointer(2, gl.FLOAT, false, 9*4, uintptr(7*4))
pos.EnableArray()
color.EnableArray()
texcoord.EnableArray()
}
func initGL() {
gl.ShadeModel(gl.SMOOTH) /// 设置平滑着色?(是默认的)
//gl.ShadeModel(gl.FLAT); /// 即单色,使用最后一个点所用的颜色
gl.ClearColor(0, 0, 0, 0)
gl.ClearDepth(1)
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LEQUAL)
gl.Hint(gl.PERSPECTIVE_CORRECTION_HINT, gl.NICEST)
}
func initGL() {
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Viewport(0, 0, 800, 600)
gl.Ortho(0, 800, 600, 0, -1.0, 1.0)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.ClearColor(0.1, 0.05, 0.0, 1.0)
}
func main() {
_ = fmt.Sprint()
if !glfw.Init() {
panic("Can't init glfw!")
}
defer glfw.Terminate()
// antialiasing
//glfw.WindowHint(glfw.Samples, 4)
window, err = glfw.CreateWindow(WindowWidth, WindowHeight, "Mozaik", nil, nil)
if err != nil {
panic(err)
}
defer window.Destroy()
// Ensure thread context
window.MakeContextCurrent()
//glfw.SwapInterval(1)
window.SetKeyCallback(keyCb)
window.SetMouseButtonCallback(mouseCb)
gl.Init()
gl.ClearColor(0.9, 0.85, 0.46, 0.0)
// useless in 2D
gl.Disable(gl.DEPTH_TEST)
// antialiasing
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.Enable(gl.LINE_SMOOTH)
for i := int32(32); i < 72; i++ {
font := loadFonts(i)
defer font.Release()
fonts = append(fonts, font)
}
// Compute window radius
windowRadius = math.Sqrt(math.Pow(WindowHeight, 2) + math.Pow(WindowWidth, 2))
// Use window coordinates
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, WindowWidth, WindowHeight, 0, 0, 1)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
g = NewGame()
g.Start()
go eventLoop(g)
go renderLoop(g)
Main()
g.Stop()
}
func copiedInit() {
gl.ClearColor(0, 0, 0, 0)
gl.ShadeModel(gl.FLAT)
gl.Enable(gl.CULL_FACE)
gl.Viewport(320, 240, 640, 480)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Frustum(-1, 1, -1, 1, 1.5, 20)
gl.MatrixMode(gl.MODELVIEW)
}
// TODO Dynamically fetch size and render accordingly.
func onResize(w, h int) {
gl.Viewport(0, 0, w, h)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, float64(w), float64(h), 0, -1, 1)
gl.ClearColor(0.255, 0.255, 0.255, 0)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
// log.Printf("resized: %dx%d\n", w, h)
}
// onResize sets up a simple 2d ortho context based on the window size
func onResize(window *glfw.Window, w, h int) {
w, h = window.GetSize() // query window to get screen pixels
width, height := window.GetFramebufferSize()
gl.Viewport(0, 0, width, height)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, float64(w), 0, float64(h), -1, 1)
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.ClearColor(1, 1, 1, 1)
}
func main() {
glut.InitDisplayMode(glut.SINGLE | glut.RGB)
glut.InitWindowSize(465, 250)
glut.CreateWindow("GLUT bitmap & stroke font example")
gl.ClearColor(1.0, 1.0, 1.0, 1.0)
gl.Color3f(0, 0, 0)
gl.LineWidth(3.0)
glut.DisplayFunc(display)
glut.ReshapeFunc(reshape)
glut.MainLoop()
}
func (self *OpenGLRenderer) BeginRender() {
gl.ClearColor(0, 0, 0, 0)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
// gl.PolygonMode(gl.FRONT_AND_BACK, gl.LINE)
//
// gl.Enable(gl.CULL_FACE)
// gl.CullFace(gl.BACK)
//
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LESS)
}
func DrawRTri(Red float64) {
gl.ClearColor(0.2, 0.2, 0.2, 1)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
gl.Color3d(game.Red, 0, 0)
gl.Begin(gl.TRIANGLES)
gl.Vertex3d(0, 0, 0)
gl.Vertex3d(0, 1, 0)
gl.Vertex3d(1, 1, 0)
gl.Vertex3d(1, 0, 0)
gl.End()
}
func setupGL(w, h int) {
gl.Viewport(0, 0, w, h)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
gl.Ortho(0, float64(w), float64(h), 0, 0, 1)
gl.ShadeModel(gl.SMOOTH)
gl.ClearColor(1, 1, 1, 0)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.Disable(gl.DEPTH_TEST)
gl.Hint(gl.LINE_SMOOTH_HINT|gl.LINE_SMOOTH_HINT, gl.NICEST)
}
