// 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
}
func main() {
var err error
if err = glfw.Init(); err != nil { ///初始化环境
log.Fatalf("%v\n", err)
return
}
defer glfw.Terminate() /// 销毁环境
if err = glfw.OpenWindow(Width, Height, 8, 8, 8, 8, 0, 8, glfw.Windowed); err != nil { ///创建窗口
log.Fatalf("%v\n", err)
return
}
defer glfw.CloseWindow() /// 销毁窗口
glfw.SetSwapInterval(1)
glfw.SetWindowTitle(Title) ///设置标题
glfw.SetWindowSizeCallback(onResize) /// 回调窗口变化
glfw.SetKeyCallback(onKey) ///回调按键
initGL()
running = true
for running && glfw.WindowParam(glfw.Opened) == 1 {
drawScene()
}
}
// Opens a new window.
func (c *Controller) Open(win *Window) (err error) {
c.Win = win
mode := glfw.Windowed
if win.Fullscreen {
mode = glfw.Fullscreen
}
if win.Resize == false {
glfw.OpenWindowHint(glfw.WindowNoResize, 1)
}
if err = glfw.OpenWindow(win.Width, win.Height, 0, 0, 0, 0, 0, 0, mode); err != nil {
return
}
gl.Init()
gl.Enable(gl.TEXTURE_2D)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
v1, v2, v3 := glfw.GLVersion()
log.Printf("OpenGL version: %v %v %v\n", v1, v2, v3)
fb_supported := glfw.ExtensionSupported("GL_EXT_framebuffer_object")
log.Printf("Framebuffer supported: %v\n", fb_supported)
c.SetClearColor(0, 0, 0, 0)
if win.VSync == true {
glfw.SetSwapInterval(1) // Limit to refresh
}
glfw.SetWindowTitle(win.Title)
glfw.SetWindowSizeCallback(func(w, h int) {
log.Printf("Resizing window to %v, %v\n", w, h)
c.resize()
})
err = c.resize()
return
}
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 (v *Video) Init(w int, h int) {
var err error
if err = glfw.Init(); err != nil {
log.Fatal(err)
}
glfw.OpenWindowHint(glfw.WindowNoResize, gl.TRUE)
if err = glfw.OpenWindow(w, h, 8, 8, 8, 0, 24, 0, glfw.Windowed); err != nil {
log.Fatal(err)
}
if gl.Init() != 0 {
log.Fatal("ummm... hmmm")
}
glfw.SetWindowSizeCallback(resize)
gl.Enable(gl.TEXTURE_2D)
resize(w, h)
v.Texture = gl.GenTexture()
}
// 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
}
func init() {
go func() {
runtime.LockOSThread()
if err := glfw.Init(); err != nil {
log.Panic("glfw Error:", err)
}
w, h := 100, 100
err := glfw.OpenWindow(w, h, 0, 0, 0, 0, 0, 0, glfw.Windowed)
if err != nil {
log.Panic("Error:", err)
}
if gl.Init() != 0 {
log.Panic("gl error")
}
glfw.SetWindowSizeCallback(Reshape)
glfw.SwapBuffers()
for {
(<-main_thread_setup)()
glfw.SwapBuffers()
(<-main_thread_after)()
main_thread_work_done <- true
}
}()
}
func main() {
var err error
if err = glfw.Init(); err != nil {
log.Fatalf("%v\n", err)
return
}
defer glfw.Terminate()
if err = glfw.OpenWindow(Width, Height, 8, 8, 8, 8, 0, 8, glfw.Windowed); err != nil {
log.Fatalf("%v\n", err)
return
}
defer glfw.CloseWindow()
glfw.SetSwapInterval(1)
glfw.SetWindowTitle(Title)
glfw.SetWindowSizeCallback(onResize)
glfw.SetKeyCallback(onKey)
if err = initGL(); err != nil {
log.Fatalf("%v\n", err)
return
}
defer destroyGL()
running = true
for running && glfw.WindowParam(glfw.Opened) == 1 {
drawScene()
}
}
// 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 make_window(w, h int, title string) func() {
// Required to make sure that the OpenGL go-routine doesn't get switched
// to another thread (=> kerblammo)
runtime.LockOSThread()
if err := glfw.Init(); err != nil {
log.Panic("glfw Error:", err)
}
err := glfw.OpenWindow(w, h, 0, 0, 0, 0, 0, 0, glfw.Windowed)
if err != nil {
log.Panic("Error:", err)
}
if gl.Init() != 0 {
log.Panic("gl error")
}
if *vsync {
glfw.SetSwapInterval(1)
} else {
glfw.SetSwapInterval(0)
}
glfw.SetWindowTitle(title)
glfw.SetWindowSizeCallback(Reshape)
Init()
return func() {
glfw.Terminate()
glfw.CloseWindow()
log.Print("Cleanup")
}
}
func main() {
var err error
if err = glfw.Init(); err != nil {
log.Fatalf("%v\n", err)
return
}
defer glfw.Terminate()
if err = glfw.OpenWindow(640, 480, 8, 8, 8, 8, 0, 0, glfw.Windowed); err != nil {
log.Fatalf("%v\n", err)
return
}
defer glfw.CloseWindow()
glfw.SetWindowTitle("Draw")
glfw.SetSwapInterval(1)
glfw.SetKeyCallback(onKey)
glfw.SetMouseButtonCallback(onMouseBtn)
glfw.SetWindowSizeCallback(onResize)
running = true
for running && glfw.WindowParam(glfw.Opened) == 1 {
if mouse[0] != 0 {
pen.lineTo(glfw.MousePos())
} else {
pen.moveTo(glfw.MousePos())
}
glfw.SwapBuffers()
}
}
func StartEngine() {
runtime.GOMAXPROCS(runtime.NumCPU())
runtime.LockOSThread()
fmt.Println("Enginge started!")
var err error
if err = glfw.Init(); err != nil {
panic(err)
}
fmt.Println("GLFW Initialized!")
glfw.OpenWindowHint(glfw.Accelerated, 1)
if err = glfw.OpenWindow(Width, Height, 8, 8, 8, 8, 8, 8, glfw.Windowed); err != nil {
panic(err)
}
glfw.SetSwapInterval(1) //0 to disable vsync, 1 to enable it
glfw.SetWindowTitle(windowTitle)
glfw.SetWindowSizeCallback(onResize)
glfw.SetKeyCallback(input.OnKey)
glfw.SetCharCallback(input.OnChar)
glfw.SetMouseButtonCallback(input.ButtonPress)
glfw.SetMouseWheel(0)
glfw.SetMouseWheelCallback(input.MouseWheelCallback)
input.MouseWheelPosition = glfw.MouseWheel
input.MousePosition = glfw.MousePos
if err = initGL(); err != nil {
panic(err)
}
fmt.Println("Opengl Initialized!")
TextureMaterial = NewBasicMaterial(spriteVertexShader, spriteFragmentShader)
err = TextureMaterial.Load()
if err != nil {
fmt.Println(err)
}
SDFMaterial = NewBasicMaterial(sdfVertexShader, sdfFragmentShader)
err = SDFMaterial.Load()
if err != nil {
fmt.Println(err)
}
internalMaterial = NewBasicMaterial(spriteVertexShader, spriteFragmentShader)
err = internalMaterial.Load()
if err != nil {
fmt.Println(err)
}
initDefaultPlane()
glfw.SwapBuffers()
gameTime = time.Time{}
lastTime = time.Now()
dl = glfw.Time()
}
func (rw *RenderWindow) Open() error {
err := glfw.OpenWindow(int(rw.Width), int(rw.Height), 8, 8, 8, 8, 0, 0, glfw.Windowed)
if err != nil {
return err
}
glfw.SetWindowTitle(rw.Title)
glfw.SetSwapInterval(2)
glfw.SetKeyCallback(rw.onKey)
glfw.SetWindowSizeCallback(rw.onResize)
return nil
}
func main() {
var err error
if err = glfw.Init(); err != nil {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return
}
// Ensure glfw is cleanly terminated on exit.
defer glfw.Terminate()
if err = glfw.OpenWindow(256, 256, 8, 8, 8, 0, 0, 0, glfw.Windowed); err != nil {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return
}
// Ensure window is cleanly closed on exit.
defer glfw.CloseWindow()
// Enable vertical sync on cards that support it.
glfw.SetSwapInterval(1)
// Set window title
glfw.SetWindowTitle("Simple GLFW window")
// Hook some events to demonstrate use of callbacks.
// These are not necessary if you don't need them.
glfw.SetWindowSizeCallback(onResize)
glfw.SetWindowCloseCallback(onClose)
glfw.SetMouseButtonCallback(onMouseBtn)
glfw.SetMouseWheelCallback(onMouseWheel)
glfw.SetKeyCallback(onKey)
glfw.SetCharCallback(onChar)
// Start loop
running := true
for running {
// OpenGL rendering goes here.
// Swap front and back rendering buffers. This also implicitly calls
// glfw.PollEvents(), so we have valid key/mouse/joystick states after
// this. This behavior can be disabled by calling glfw.Disable with the
// argument glfw.AutoPollEvents. You must be sure to manually call
// PollEvents() or WaitEvents() in this case.
glfw.SwapBuffers()
// Break out of loop when Escape key is pressed, or window is closed.
running = glfw.Key(glfw.KeyEsc) == 0 && glfw.WindowParam(glfw.Opened) == 1
}
}
func (_ *NgUserIO) recreateWin() (err error) {
winInit := &Options.Initialization.Window
if UserIO.Window.isCreated {
glfw.CloseWindow()
}
if UserIO.Window.isCreated, err = false, glfw.OpenWindow(UserIO.Window.width, UserIO.Window.height, winInit.Rbits, winInit.Gbits, winInit.Bbits, winInit.Abits, winInit.DepthBits, winInit.StencilBits, ugo.Ifi(UserIO.Window.fullscreen, glfw.Fullscreen, glfw.Windowed)); err == nil {
UserIO.Window.width, UserIO.Window.height = glfw.WindowSize()
UserIO.Window.isCreated = true
UserIO.Window.SetTitle(UserIO.Window.title)
UserIO.Window.SetSwapInterval(UserIO.Window.swap)
glfw.SetWindowCloseCallback(glfwOnWindowClose)
glfw.SetWindowSizeCallback(glfwOnWindowResize)
// glfw.Disable(glfw.MouseCursor)
glfw.Disable(glfw.AutoPollEvents)
glfw.Disable(glfw.StickyKeys)
}
return
}
func InitGL(width, height int) {
//enable vertical sync if the card supports it
glfw.SetSwapInterval(1)
gl.ShadeModel(gl.SMOOTH)
gl.ClearColor(0.1, 0.1, 0.1, 1.0)
gl.Enable(gl.TEXTURE_2D)
gl.Enable(gl.CULL_FACE)
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LEQUAL)
gl.Hint(gl.PERSPECTIVE_CORRECTION_HINT, gl.NICEST)
SetViewport(width, height)
glfw.SetWindowSizeCallback(SetViewport)
glfw.SetKeyCallback(OnKey)
}
// initGL initializes GLFW and OpenGL.
func initGL() error {
err := glfw.Init()
if err != nil {
return err
}
glfw.OpenWindowHint(glfw.FsaaSamples, 4)
glfw.OpenWindowHint(glfw.WindowNoResize, gl.TRUE)
err = glfw.OpenWindow(512, 512, 8, 8, 8, 8, 32, 0, glfw.Windowed)
if err != nil {
glfw.Terminate()
return err
}
glfw.SetWindowTitle("Meshbuffer 3D example")
glfw.SetSwapInterval(1)
glfw.SetWindowSizeCallback(onResize)
glfw.SetKeyCallback(onKey)
gl.Init()
if err = glh.CheckGLError(); err != nil {
return err
}
gl.Enable(gl.DEPTH_TEST)
gl.Enable(gl.MULTISAMPLE)
gl.Disable(gl.LIGHTING)
//gl.ClearColor(0.2, 0.2, 0.23, 1.0)
gl.ClearColor(0, 0, 0, 1.0)
gl.ShadeModel(gl.SMOOTH)
gl.LineWidth(2)
gl.ClearDepth(1)
gl.DepthFunc(gl.LEQUAL)
gl.Hint(gl.PERSPECTIVE_CORRECTION_HINT, gl.NICEST)
gl.ColorMaterial(gl.FRONT_AND_BACK, gl.AMBIENT_AND_DIFFUSE)
return nil
}
func (s *Display) init(title string, screenSizeMultiplier int) error {
s.Name = PREFIX + "-SCREEN"
log.Printf("%s: Initialising display", s.Name)
var err error
s.ScreenSizeMultiplier = screenSizeMultiplier
log.Printf("%s: Set screen size multiplier to %dx", s.Name, s.ScreenSizeMultiplier)
glfw.OpenWindowHint(glfw.WindowNoResize, 1)
err = glfw.OpenWindow(SCREEN_WIDTH*s.ScreenSizeMultiplier, SCREEN_HEIGHT*s.ScreenSizeMultiplier, 0, 0, 0, 0, 0, 0, glfw.Windowed)
if err != nil {
return err
}
glfw.SetWindowTitle(title)
//resize function
onResize := func(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()
}
glfw.SetWindowSizeCallback(onResize)
desktopMode := glfw.DesktopMode()
glfw.SetWindowPos((desktopMode.W-SCREEN_WIDTH*s.ScreenSizeMultiplier)/2, (desktopMode.H-SCREEN_HEIGHT*s.ScreenSizeMultiplier)/2)
gl.ClearColor(0.255, 0.255, 0.255, 0)
return nil
}
func (me *window) CallbackWindowSize(f func(int, int)) {
glfw.SetWindowSizeCallback(f)
}
func main() {
var err error
if err = glfw.Init(); err != nil {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return
}
defer glfw.Terminate()
w, h := 1980, 1080
// w, h := 1280, 768
if err = glfw.OpenWindow(w, h, 8, 8, 8, 16, 0, 32, glfw.Fullscreen); err != nil {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return
}
defer glfw.CloseWindow()
glfw.SetSwapInterval(1)
glfw.SetWindowTitle("Debris")
quadric = glu.NewQuadric()
gl.Enable(gl.CULL_FACE)
gl.Enable(gl.DEPTH_TEST)
gl.DepthFunc(gl.LEQUAL)
gl.Enable(gl.NORMALIZE)
gl.Enable(gl.BLEND)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
gl.ShadeModel(gl.SMOOTH)
gl.Enable(gl.LIGHTING)
var (
ambient = []float32{0.1, 0.3, 0.6, 1}
diffuse = []float32{1, 1, 0.5, 1}
specular = []float32{0.4, 0.4, 0.4, 1}
light_position = []float32{1, 0, 0, 0}
// mat_specular []float32 = []float32{1, 1, 0.5, 1}
mat_specular = []float32{1, 1, 0.75, 1}
mat_shininess = float32(120)
// light_position []float32 = []float32{0.0, 0.0, 1.0, 0.0}
)
const (
fov = 1.1 // degrees
znear = 145
zfar = 155
camera_z_offset = -150
camera_x_rotation = 0 // degrees
// camera_x_rotation = 20 // degrees
starfield_fov = 45
faces = 1000
earth_radius = 1
)
gl.Lightfv(gl.LIGHT1, gl.AMBIENT, ambient)
gl.Lightfv(gl.LIGHT1, gl.DIFFUSE, diffuse)
gl.Lightfv(gl.LIGHT1, gl.SPECULAR, specular)
gl.Lightfv(gl.LIGHT1, gl.POSITION, light_position)
gl.Enable(gl.LIGHT1)
mat_emission := []float32{0, 0, 0.1, 1}
gl.Materialfv(gl.FRONT_AND_BACK, gl.EMISSION, mat_emission)
gl.Materialfv(gl.FRONT_AND_BACK, gl.SPECULAR, mat_specular)
gl.Materialf(gl.FRONT_AND_BACK, gl.SHININESS, mat_shininess)
gl.ClearColor(0.02, 0.02, 0.02, 1)
gl.ClearDepth(1)
gl.ClearStencil(0)
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
b := createBuffer()
planetoids := []*Planetoid{}
for i := 0; i < 1000; i++ {
p := &Planetoid{
apogee: 1.2 + rand.Float64()*0.7,
perigee: 1.5,
// inclination: 45,
inclination: rand.Float64()*20 - 10,
// inclination: 0,
phase0: rand.Float64() * 360,
rising_node: rand.Float64() * 10,
phase: 0,
// radius: rand.Float32()*0.05 + 0.01, //float32(r),
radius: rand.Float32()*0.0125 + 0.005, //float32(r),
// quadric: glu.NewQuadric(),
circle: b,
}
planetoids = append(planetoids, p)
}
// Initial projection matrix:
var aspect float64
glfw.SetWindowSizeCallback(func(w, h int) {
gl.Viewport(0, 0, w, h)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
aspect = float64(w) / float64(h)
glu.Perspective(fov, aspect, znear, zfar)
})
d := float64(0)
wireframe := false
atmosphere := false
polar := false
rotating := false
front := false
earth := true
cone := true
shadowing := true
tilt := false
running := true
glfw.SetKeyCallback(func(key, state int) {
if state != glfw.KeyPress {
// Don't act on key coming up
return
}
switch key {
case 'A':
atmosphere = !atmosphere
case 'C':
cone = !cone
case 'E':
earth = !earth
case 'R':
rotating = !rotating
case 'F':
front = !front
if front {
gl.FrontFace(gl.CW)
} else {
gl.FrontFace(gl.CCW)
}
case 'S':
shadowing = !shadowing
case 'T':
tilt = !tilt
case 'W':
wireframe = !wireframe
method := gl.GLenum(gl.FILL)
if wireframe {
method = gl.LINE
}
gl.PolygonMode(gl.FRONT_AND_BACK, method)
case glfw.KeyF2:
println("Screenshot captured")
// glh.CaptureToPng("screenshot.png")
w, h := glh.GetViewportWH()
im := image.NewRGBA(image.Rect(0, 0, w, h))
glh.ClearAlpha(1)
gl.Flush()
glh.CaptureRGBA(im)
go func() {
fd, err := os.Create("screenshot.png")
if err != nil {
panic("Unable to open file")
}
defer fd.Close()
png.Encode(fd, im)
}()
case 'Q', glfw.KeyEsc:
running = !running
case glfw.KeySpace:
polar = !polar
}
})
_ = rand.Float64
stars := glh.NewMeshBuffer(
glh.RenderArrays,
glh.NewPositionAttr(3, gl.DOUBLE, gl.STATIC_DRAW),
glh.NewColorAttr(3, gl.DOUBLE, gl.STATIC_DRAW))
const Nstars = 50000
points := make([]float64, 3*Nstars)
colors := make([]float64, 3*Nstars)
for i := 0; i < Nstars; i++ {
const R = 1
phi := rand.Float64() * 2 * math.Pi
z := R * (2*rand.Float64() - 1)
theta := math.Asin(z / R)
points[i*3+0] = R * math.Cos(theta) * math.Cos(phi)
points[i*3+1] = R * math.Cos(theta) * math.Sin(phi)
points[i*3+2] = z
const r = 0.8
v := rand.Float64()*r + (1 - r)
colors[i*3+0] = v
colors[i*3+1] = v
colors[i*3+2] = v
}
stars.Add(points, colors)
render_stars := func() {
glh.With(glh.Attrib{gl.DEPTH_BUFFER_BIT | gl.ENABLE_BIT}, func() {
gl.Disable(gl.LIGHTING)
gl.PointSize(1)
gl.Color4f(1, 1, 1, 1)
gl.Disable(gl.DEPTH_TEST)
gl.DepthMask(false)
stars.Render(gl.POINTS)
})
}
render_scene := func() {
// Update light position (sensitive to current modelview matrix)
gl.Lightfv(gl.LIGHT1, gl.POSITION, light_position)
gl.Lightfv(gl.LIGHT2, gl.POSITION, light_position)
if earth {
Sphere(earth_radius, faces)
}
unlit_points := glh.Compound(glh.Disable(gl.LIGHTING), glh.Primitive{gl.POINTS})
glh.With(unlit_points, func() {
gl.Vertex3d(1, 0, 0)
})
for _, p := range planetoids {
const dt = 0.1 // TODO: Frame update
p.Render(dt)
}
glh.With(glh.Disable(gl.LIGHTING), func() {
// Atmosphere
gl.Color4f(0.25, 0.25, 1, 0.1)
if atmosphere && earth {
Sphere(earth_radius*1.025, 100)
}
gl.PointSize(10)
glh.With(glh.Primitive{gl.POINTS}, func() {
gl.Color4f(1.75, 0.75, 0.75, 1)
gl.Vertex3d(-1.04, 0, 0)
})
})
}
render_shadow_volume := func() {
glh.With(glh.Attrib{
gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.ENABLE_BIT |
gl.POLYGON_BIT | gl.STENCIL_BUFFER_BIT,
}, func() {
gl.Disable(gl.LIGHTING)
if shadowing {
// gl.Disable(gl.DEPTH_TEST)
gl.DepthMask(false)
gl.DepthFunc(gl.LEQUAL)
gl.Enable(gl.STENCIL_TEST)
gl.ColorMask(false, false, false, false)
gl.StencilFunc(gl.ALWAYS, 1, 0xffffffff)
}
shadow_volume := func() {
const sv_length = 2
const sv_granularity = 100
const sv_radius = earth_radius * 1.001
// Shadow cone
glh.With(glh.Matrix{gl.MODELVIEW}, func() {
gl.Rotatef(90, 1, 0, 0)
gl.Rotatef(90, 0, -1, 0)
gl.Color4f(0.5, 0.5, 0.5, 1)
glu.Cylinder(quadric, sv_radius, sv_radius*1.05,
sv_length, sv_granularity, 1)
glu.Disk(quadric, 0, sv_radius, sv_granularity, 1)
glh.With(glh.Matrix{gl.MODELVIEW}, func() {
gl.Translated(0, 0, sv_length)
glu.Disk(quadric, 0, sv_radius*1.05, sv_granularity, 1)
})
})
for _, p := range planetoids {
p.RenderShadowVolume()
}
}
if cone {
gl.FrontFace(gl.CCW)
gl.StencilOp(gl.KEEP, gl.KEEP, gl.INCR)
shadow_volume()
gl.FrontFace(gl.CW)
gl.StencilOp(gl.KEEP, gl.KEEP, gl.DECR)
shadow_volume()
}
if shadowing {
gl.StencilFunc(gl.NOTEQUAL, 0, 0xffffffff)
gl.StencilOp(gl.KEEP, gl.KEEP, gl.KEEP)
gl.ColorMask(true, true, true, true)
// gl.Disable(gl.STENCIL_TEST)
gl.Disable(gl.DEPTH_TEST)
gl.FrontFace(gl.CCW)
// gl.Color4f(1, 0, 0, 0.75)
gl.Color4f(0, 0, 0, 0.75)
// gl.Color4f(1, 1, 1, 0.75)
gl.LoadIdentity()
gl.Translated(0, 0, camera_z_offset)
// TODO: Figure out why this doesn't draw over the whole screen
glh.With(glh.Disable(gl.LIGHTING), func() {
glh.DrawQuadd(-10, -10, 20, 20)
})
// gl.FrontFace(gl.CW)
// gl.Enable(gl.LIGHTING)
// gl.Disable(gl.LIGHT1)
// render_scene()
// gl.Enable(gl.LIGHT1)
}
})
}
_ = render_stars
for running {
running = glfw.WindowParam(glfw.Opened) == 1
glfw.SwapBuffers()
gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT)
rotation := func() {
if tilt {
gl.Rotated(20, 1, 0, 0)
}
if polar {
gl.Rotated(90, 1, 0, 0)
}
gl.Rotated(d, 0, -1, 0)
}
// Star field
glh.With(glh.Matrix{gl.PROJECTION}, func() {
gl.LoadIdentity()
glu.Perspective(starfield_fov, aspect, 0, 1)
glh.With(glh.Matrix{gl.MODELVIEW}, func() {
gl.LoadIdentity()
rotation()
render_stars()
})
})
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.Translated(0, 0, camera_z_offset)
rotation()
if rotating {
d += 0.2
}
_ = render_scene
render_scene()
_ = render_shadow_volume
render_shadow_volume()
}
}
func New(width int, height int, title string) *Window {
var err error
window := &Window{width: width, height: height, title: title}
// initialize logger
logf, err := os.OpenFile("window.log", os.O_WRONLY|os.O_CREATE, 0640)
logger := log.New(logf, "", log.Ldate|log.Ltime)
if err = glfw.Init(); err != nil {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return nil
}
// width, hieght, r,g,b,a (color depth bits), depth, stencil, mode
if err = glfw.OpenWindow(window.width, window.height, 8, 8, 8, 0, 0, 0, glfw.Windowed); err != nil {
fmt.Fprintf(os.Stderr, "[e] %v\n", err)
return nil
}
onResize := func(w, h int) {
logger.Printf("resized: %dx%d\n", w, h)
}
onClose := func() int {
logger.Println("window closed\n")
return 1 // return 0 to keep window open.
}
// list callback generators
createBtnList := func(btnNext func() interface{}, device string) func(button, state int) {
btnList := list.New()
btnNext = func() interface{} { return btnList.Remove(btnList.Back()) }
return func(button, state int) {
btnList.PushFront(btnEvent{button: button, state: state})
logger.Printf("%s button: %d, %d\n", device, button, state)
}
}
createPosList := func(posNext func() interface{}, device string) func(x, y int) {
posList := list.New()
posNext = func() interface{} { return posList.Remove(posList.Back()) }
return func(x, y int) {
posList.PushFront(posEvent{x: x, y: y})
logger.Printf("%s pos: %d, %d\n", device, x, y)
}
}
createDeltaList := func(deltaNext func() interface{}, device string) func(delta int) {
deltaList := list.New()
deltaNext = func() interface{} { return deltaList.Remove(deltaList.Back()) }
return func(delta int) {
deltaList.PushFront(deltaEvent{delta: delta})
logger.Printf("%s delta: %d\n", device, delta)
}
}
glfw.SetSwapInterval(1)
glfw.SetWindowTitle(title)
glfw.SetWindowSizeCallback(onResize)
glfw.SetWindowCloseCallback(onClose)
glfw.SetMousePosCallback(createPosList(window.MousePos, "mouse pos"))
glfw.SetMouseButtonCallback(createBtnList(window.MouseBtn, "mouse"))
glfw.SetMouseWheelCallback(createDeltaList(window.MouseWheel, "mouse wheel"))
glfw.SetKeyCallback(createBtnList(window.KeyEvt, "keyboard"))
glfw.SetCharCallback(createBtnList(window.CharEvt, "char"))
window.Start = func() {
defer glfw.Terminate()
defer glfw.CloseWindow()
running := true
for running {
window.Render()
glfw.SwapBuffers()
// Break out of loop when Escape key is pressed, or window is closed.
running = glfw.Key(glfw.KeyEsc) == 0 && glfw.WindowParam(glfw.Opened) == 1
}
}
return window
}
