// Creates a new system using (temorarily) hard-coded constants
func NewSystem(X, Y int) System {
numStars := 1
numPlanets := rand.Int() % 12
// Make the slice of Planet
planets := make([]*data.Planet, numPlanets+1)
// TODO get rid of hard coded constants
for i := 0; i <= numPlanets; i++ {
orbitSizeX := rand.Float64()*4000 + 2000
orbitSizeY := rand.Float64()*4000 + 2000
orbitSpeed := rand.Float64() / ((orbitSizeX + orbitSizeY) / 10)
size := gl.Float(rand.Float64() * 100)
planets[i] = &data.Planet{data.GameObject{PlanetTextures[0], 0, 0, size, size, 0},
orbitSizeX, orbitSizeY, orbitSpeed, float64(X), float64(Y)}
}
// Make the slice of Stars for each system
stars := make([]*data.Star, numStars+1)
for i := 0; i <= numStars; i++ {
stars[i] = &data.Star{data.GameObject{PlanetTextures[0], gl.Float(X), gl.Float(Y), gl.Float(X + 300), gl.Float(Y + 300), 0}}
}
return System{X, Y, numStars, numPlanets, planets, stars}
}
func Cylinder(r, h gl.Float, slices int, hollow, solid bool) {
res := 2 * math.Pi / float64(slices)
mode := gl.LINE_LOOP
if solid {
mode = gl.QUADS
}
gl.Begin(gl.Enum(mode))
for a := 0.0; a < 2*math.Pi; a += res {
gl.Normal3f(gl.Float(math.Cos(a)), gl.Float(math.Sin(a)), 0)
gl.Vertex3f(r*gl.Float(math.Cos(a)), r*gl.Float(math.Sin(a)), 0)
gl.Vertex3f(r*gl.Float(math.Cos(a)), r*gl.Float(math.Sin(a)), h)
a += res
gl.Vertex3f(r*gl.Float(math.Cos(a)), r*gl.Float(math.Sin(a)), h)
gl.Vertex3f(r*gl.Float(math.Cos(a)), r*gl.Float(math.Sin(a)), 0)
}
gl.End()
if !hollow {
// X Y plane
if h < 0 {
gl.Normal3f(0, 0, 1)
} else {
gl.Normal3f(0, 0, -1)
}
Circle(r, slices, solid)
// Top (or bottom)
if h < 0 {
gl.Normal3f(0, 0, -1)
} else {
gl.Normal3f(0, 0, 1)
}
gl.Translatef(0, 0, h)
Circle(r, slices, solid)
}
}
func drawMatrix(m *[][]Point, xby, yby gl.Float) {
for x, row := range *m {
for y, p := range row {
UseColor(PointColor(p))
// fmt.Println(p, PointColor(p))
// gl.Color4f(1, 0, 0, 1)
gl.Vertex2f(gl.Float(x)*xby, gl.Float(y)*yby)
}
}
}
/* Updates o's position using its movement function.
The movemet function looks something like
(x,y) = (f(t),g(t)) where for elliptic orbits
f = Acos(t)
g = Bsin(t)
*/
func PlanetOrbit(o *data.Planet, t float64) {
A := o.OrbitParam1
B := o.OrbitParam2
C := o.OrbitParam3
x0 := o.OrbitParam4
y0 := o.OrbitParam5
o.AbsMove(gl.Float(A*math.Sin(t*C)+x0), gl.Float(B*math.Cos(t*C)+y0))
}
func SetUniform4F(shader, variable string, vs []float32) error {
prog, ok := shader_progs[shader]
if !ok {
return shaderError(fmt.Sprintf("Tried to set a uniform in an unknown shader '%s'", shader))
}
bvariable := []byte(fmt.Sprintf("%s\x00", variable))
loc := gl.GetUniformLocation(prog, (*gl.Char)(unsafe.Pointer(&bvariable[0])))
gl.Uniform4f(loc, gl.Float(vs[0]), gl.Float(vs[1]), gl.Float(vs[2]), gl.Float(vs[3]))
return nil
}
func SetUniformV2(shader, variable string, v linear.Vec2) {
prog, ok := shader_progs[shader]
if !ok {
if !warned_names[shader] {
Warn().Printf("Tried to set a uniform in an unknown shader '%s'", shader)
warned_names[shader] = true
}
return
}
bvariable := []byte(fmt.Sprintf("%s\x00", variable))
loc := gl.GetUniformLocation(prog, (*gl.Char)(unsafe.Pointer(&bvariable[0])))
gl.Uniform2f(loc, gl.Float(v.X), gl.Float(v.Y))
}
// SetVariable4f sets a specified variable to the four supplied integers to
// be passed into an effect.
func (effect *Effect) SetVariable4f(variable string, val1 float32, val2 float32, val3 float32, val4 float32) error {
var currEffect gl.Int
gl.GetIntegerv(gl.CURRENT_PROGRAM, &currEffect)
if gl.Uint(currEffect) != effect.program {
return errors.New("effect is not currently in use")
}
effect.checkUniformVariable(variable)
gl.Uniform4f(effect.uniforms[variable], gl.Float(val1), gl.Float(val2), gl.Float(val3), gl.Float(val4))
return nil
}
func Ellipse(rX, rY gl.Float, slices int, solid bool) {
mode := gl.LINE_LOOP
if solid {
mode = gl.POLYGON
}
res := 2 * math.Pi / float64(slices)
gl.Begin(gl.Enum(mode))
gl.Vertex2f(0, 0)
for a := 0.0; a < 2*math.Pi; a += res {
gl.Vertex2f(rX*gl.Float(math.Cos(a)), rY*gl.Float(math.Sin(a)))
}
gl.End()
}
func Box(x, y, z float32, solid bool) {
mode := gl.LINE_LOOP
if solid {
mode = gl.QUADS
}
X := gl.Float(x) / 2
Y := gl.Float(y) / 2
Z := gl.Float(z) / 2
gl.Begin(gl.Enum(mode))
gl.Normal3f(0, 0, 1) // Positive Z Face
gl.Vertex3f(-X, -Y, Z)
gl.Vertex3f(X, -Y, Z)
gl.Vertex3f(X, Y, Z)
gl.Vertex3f(-X, Y, Z)
gl.Normal3f(0, 0, -1) // Negative Z Face
gl.Vertex3f(-X, -Y, -Z)
gl.Vertex3f(-X, Y, -Z)
gl.Vertex3f(X, Y, -Z)
gl.Vertex3f(X, -Y, -Z)
gl.Normal3f(0, 1, 0) // Positive Y Face
gl.Vertex3f(-X, Y, -Z)
gl.Vertex3f(-X, Y, Z)
gl.Vertex3f(X, Y, Z)
gl.Vertex3f(X, Y, -Z)
gl.Normal3f(0, -1, 0) // Negative Y Face
gl.Vertex3f(-X, -Y, -Z)
gl.Vertex3f(X, -Y, -Z)
gl.Vertex3f(X, -Y, Z)
gl.Vertex3f(-X, -Y, Z)
gl.Normal3f(1, 0, 0) // Positive X Face
gl.Vertex3f(X, -Y, -Z)
gl.Vertex3f(X, Y, -Z)
gl.Vertex3f(X, Y, Z)
gl.Vertex3f(X, -Y, Z)
gl.Normal3f(-1, 0, 0) // Negative X Face
gl.Vertex3f(-X, -Y, -Z)
gl.Vertex3f(-X, -Y, Z)
gl.Vertex3f(-X, Y, Z)
gl.Vertex3f(-X, Y, -Z)
gl.End()
}
func drawScene() {
fps()
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.MatrixMode(gl.PROJECTION)
gl.LoadIdentity()
if input.Zoom > 0 {
gl.Ortho(0, gl.Double(float64(*flagSize)/input.Zoom), gl.Double(float64(*flagSize)/input.Zoom), 0, -1, 1.0)
}
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.Translatef(gl.Float(input.TransX*1), gl.Float(input.TransY*1), 0)
drawGrid()
drawCells()
}
func PointColor(p Point) Color {
n := gl.Float(float64(p.Intensity) / 10.0)
/*
if p.Color == WHITE {
return Color{1.0, 1.0, 1.0, 1}
}
if p.Color == RED {
return Color{1, 1-n, 1-n, 1}
}
if p.Color == GREEN {
return Color{1-n, 1, 1-n, 1}
}
return Color{1-n, 1-n, 1, 1}
*/
if p.Color == WHITE {
return Color{0, 0, 0, 1}
}
if p.Color == RED {
return Color{n, 0, 0, 1}
}
if p.Color == GREEN {
return Color{0, n, 0, 1}
}
return Color{0, 0, n, 1}
}
func factor(t time.Time, tc0 time.Time, tc1 time.Time) gl.Float {
num := t.Sub(tc0)
den := tc1.Sub(tc0)
res := num.Seconds() / den.Seconds()
res = math.Max(res, 0)
res = math.Min(res, 1)
return gl.Float(res)
}
func SetUniformV2Array(shader, variable string, vs []linear.Vec2) {
prog, ok := shader_progs[shader]
if !ok {
if !warned_names[shader] {
Warn().Printf("Tried to set a uniform in an unknown shader '%s'", shader)
warned_names[shader] = true
}
return
}
bvariable := []byte(fmt.Sprintf("%s\x00", variable))
loc := gl.GetUniformLocation(prog, (*gl.Char)(unsafe.Pointer(&bvariable[0])))
var fs []gl.Float
for i := range vs {
fs = append(fs, gl.Float(vs[i].X))
fs = append(fs, gl.Float(vs[i].Y))
}
gl.Uniform2fv(loc, gl.Sizei(len(vs)), (*gl.Float)(unsafe.Pointer(&fs[0])))
}
func (m *Matrix3) toGLFloat() Matrix3GLFloat {
var glm Matrix3GLFloat
for i := range m {
glm[i] = gl.Float(m[i])
}
return glm
}
func drawCells() {
if input.Zoom > 0 {
gl.PointSize(gl.Float(float64(Width) / float64(*flagSize) * input.Zoom))
}
gl.Color4f(1, 1, 1, 1)
gl.Enable(gl.POINT_SMOOTH)
gl.Begin(gl.POINTS)
for i, j := 0, 0; i < (life.Size * life.Size); i, j = i+life.Size, j+1 {
for k, v := range life.Cells[i : i+life.Size] {
if v {
gl.Vertex2f(gl.Float(k), gl.Float(j))
}
}
}
gl.End()
gl.Disable(gl.POINT_SMOOTH)
}
// Set the GL modelview matrix to match view position and orientation.
func UpdateViewpos() {
gl.MatrixMode(gl.MODELVIEW)
gl.LoadIdentity()
gl.Translatef(gl.Float(Viewpos[0]), gl.Float(Viewpos[1]), gl.Float(Viewpos[2]))
gl.Rotatef(gl.Float(Rot[0]*2), 1, 0, 0)
gl.Rotatef(gl.Float(Rot[1]*2), 0, 1, 0)
gl.Rotatef(gl.Float(Rot[2]*2), 0, 0, 1)
}
func drawGrid() {
gl.Color4f(0.2, 0.2, 0.2, 1)
gl.Begin(gl.LINES)
for i := -0.5; i < Width; i += 1 {
gl.Vertex2f(gl.Float(-0.5), gl.Float(i))
gl.Vertex2f(gl.Float(life.Size), gl.Float(i))
gl.Vertex2f(gl.Float(i), -0.5)
gl.Vertex2f(gl.Float(i), gl.Float(life.Size))
}
gl.End()
}
func drawQuad(x, y, w, h int, u, v, u2, v2 float32) {
gl.Begin(gl.QUADS)
gl.TexCoord2f(gl.Float(u), gl.Float(v))
gl.Vertex2i(gl.Int(x), gl.Int(y))
gl.TexCoord2f(gl.Float(u2), gl.Float(v))
gl.Vertex2i(gl.Int(x+w), gl.Int(y))
gl.TexCoord2f(gl.Float(u2), gl.Float(v2))
gl.Vertex2i(gl.Int(x+w), gl.Int(y+h))
gl.TexCoord2f(gl.Float(u), gl.Float(v2))
gl.Vertex2i(gl.Int(x), gl.Int(y+h))
gl.End()
}
func renderPts() {
gl.MatrixMode(gl.MODELVIEW)
for i := minPt; i <= maxPt; i++ {
if Pts[i].is == false {
continue
}
pt := &Pts[i]
gl.PopMatrix()
gl.PushMatrix()
gl.Translatef(gl.Float(pt.X), gl.Float(pt.Y), -gl.Float(pt.Z))
gl.Scalef(gl.Float(pt.R*2), gl.Float(pt.R*2), gl.Float(pt.R*2))
gl.DrawArrays(gl.QUADS, 0, 24)
}
}
func DrawStarTex(t *data.Star) {
// Find the center point of the texture to rotate around
xav := (t.X1 + t.X2) / 2
yav := (t.Y1 + t.Y2) / 2
//Translate there, rotate, translate back
gl.MatrixMode(gl.MODELVIEW)
gl.Translatef(xav, yav, 0)
gl.Rotatef(gl.Float(t.Theta), 0, 0, 1)
gl.Translatef(-xav, -yav, 0)
//Bind our texture to be drawn by id
gl.Color3f(1, 1, 1)
gl.Enable(gl.TEXTURE_2D)
gl.BindTexture(gl.TEXTURE_2D, t.TexId)
// Draw a rectangle with the texture stretched to the corners
gl.Begin(gl.QUADS)
// Stretch the texture to its 4 corners.
gl.TexCoord2d(0, 0)
gl.Vertex2f(t.X1, t.Y1)
gl.TexCoord2d(0, 1)
gl.Vertex2f(t.X1, t.Y2)
gl.TexCoord2d(1, 1)
gl.Vertex2f(t.X2, t.Y2)
gl.TexCoord2d(1, 0)
gl.Vertex2f(t.X2, t.Y1)
gl.End()
// Unbind the texture in case something else wants to draw
gl.Disable(gl.TEXTURE_2D)
// Reset the matrix
gl.LoadIdentity()
}
// Wraps gl.Normal3f
func Normal3f(x, y, z float32) {
gl.Normal3f(gl.Float(x), gl.Float(y), gl.Float(z))
}
// SetClearColor sets the color the screen will become after a call to the
// Clear function.
func SetClearColor(r uint8, g uint8, b uint8) {
gl.ClearColor(gl.Float(r)/255, gl.Float(g)/255, gl.Float(b)/255, 1.0)
}
func (mr *ModelReader) readModel(path string, m *Model) {
var num uint16
mr.readuint16(&num)
for i := 0; i < int(num); i++ {
var x, y, z float32
mr.readfloat32(&x)
mr.readfloat32(&y)
mr.readfloat32(&z)
m.vertices = append(m.vertices, gl.Float(x), gl.Float(y), gl.Float(z))
//fmt.Printf("vertices %f, %f, %f \n", x, y, z)
}
//fmt.Printf("m.vertices size %d \n", len(m.vertices))
var faces uint16
mr.readuint16(&faces)
//fmt.Println("nb faces : ", faces)
for i := 0; i < int(faces); i++ {
var x, y, z uint16
mr.readuint16(&x)
mr.readuint16(&y)
mr.readuint16(&z)
m.indices = append(m.indices, gl.Uint(x), gl.Uint(y), gl.Uint(z))
//fmt.Printf("face indices :%d, %d, %d \n", x, y, z)
}
var normals_num uint16
mr.readuint16(&normals_num)
for i := 0; i < int(normals_num); i++ {
var x, y, z float32
mr.readfloat32(&x)
mr.readfloat32(&y)
mr.readfloat32(&z)
m.normals = append(m.normals, gl.Float(x), gl.Float(y), gl.Float(z))
//fmt.Printf("normal %f, %f, %f \n", x, y, z)
}
var uvs_num uint16
mr.readuint16(&uvs_num)
//fmt.Printf("uvs num %d \n", uvs_num)
m.has_uv = uvs_num > 0
if m.has_uv {
for i := 0; i < int(uvs_num); i++ {
var x, y float32
mr.readfloat32(&x)
mr.readfloat32(&y)
m.uvs = append(m.uvs, gl.Float(x), gl.Float(y))
//fmt.Printf("uvs %f, %f \n", x, y)
}
}
}
func (w *glfwBackend) SetScreenColor(color RGB) {
r := gl.Float(float64(color.R) / 255.0)
g := gl.Float(float64(color.G) / 255.0)
b := gl.Float(float64(color.B) / 255.0)
gl.ClearColor(r, g, b, gl.Float(1.0))
}
// Wraps gl.Vertex3f
func Vertex3f(x, y, z float32) {
gl.Vertex3f(gl.Float(x), gl.Float(y), gl.Float(z))
}