Software-only 3D renderer written in #golang.
Go
Latest commit a221124 Feb 16, 2017 @fogleman fix culling

README.md

FauxGL

3D software rendering in pure Go. No OpenGL, no C extensions, no nothin'.

Dragon

About

It's like OpenGL, but it's not. It's FauxGL.

It doesn't use your graphics card, only your CPU. So it's slow and unsuitable for realtime rendering. But it's still pretty fast. It works the same way OpenGL works - rasterizing.

Features

  • STL, OBJ, PLY file formats
  • triangle rasterization
  • vertex and fragment "shaders"
  • view volume clipping
  • face culling
  • alpha blending
  • textures
  • built-in shapes
  • anti-aliasing (via supersampling)
  • voxel rendering

Performance

FauxGL uses all of your CPU cores. But none of your GPU.

Rendering the Stanford Dragon shown above (871306 triangles) at 1920x1080px takes about 150 milliseconds on my machine. With 4x4=16x supersampling, it takes about 950 milliseconds. This is the time to render a frame and does not include loading the mesh from disk.

Go Get It

go get -u github.com/fogleman/fauxgl

Go Run It

cd go/src/github.com/fogleman/fauxgl
go run examples/hello.go

Complete Example

package main

import (
    . "github.com/fogleman/fauxgl"
    "github.com/nfnt/resize"
)

const (
    scale  = 1    // optional supersampling
    width  = 1920 // output width in pixels
    height = 1080 // output height in pixels
    fovy   = 30   // vertical field of view in degrees
    near   = 1    // near clipping plane
    far    = 10   // far clipping plane
)

var (
    eye    = V(-3, 1, -0.75)               // camera position
    center = V(0, -0.07, 0)                // view center position
    up     = V(0, 1, 0)                    // up vector
    light  = V(-0.75, 1, 0.25).Normalize() // light direction
    color  = HexColor("#468966")           // object color
)

func main() {
    // load a mesh
    mesh, err := LoadOBJ("examples/dragon.obj")
    if err != nil {
        panic(err)
    }

    // fit mesh in a bi-unit cube centered at the origin
    mesh.BiUnitCube()

    // smooth the normals
    mesh.SmoothNormalsThreshold(Radians(30))

    // create a rendering context
    context := NewContext(width*scale, height*scale)
    context.ClearColorBufferWith(HexColor("#FFF8E3"))

    // create transformation matrix and light direction
    aspect := float64(width) / float64(height)
    matrix := LookAt(eye, center, up).Perspective(fovy, aspect, near, far)

    // use builtin phong shader
    shader := NewPhongShader(matrix, light, eye)
    shader.ObjectColor = color
    context.Shader = shader

    // render
    context.DrawMesh(mesh)

    // downsample image for antialiasing
    image := context.Image()
    image = resize.Resize(width, height, image, resize.Bilinear)

    // save image
    SavePNG("out.png", image)
}