// ff demonstrates flow field path finding by having a bunch of chasers and
// a goal. The goal is randomly reset once all the chasers have reached it.
// Restarting the example will create a different random grid.
func ff() {
ff := &fftag{}
if err := vu.New(ff, "Flow Field", 400, 100, 750, 750); err != nil {
log.Printf("ff: error starting engine %s", err)
}
defer catchErrors()
}
// rl, random levels, tests higher level graphics functionality.
// This includes:
// • vu culling/reducing the total objects rendered based on distance.
// • vu 2D overlay scene, in this case a minimap.
// • vu grid generation. Try numbers 0-9.
// • vu engine statistics.
// rl also tests camera movement that includes holding multiple movement keys
// at the same time. The example does not have collision detection so you can
// literally run through the maze.
func rl() {
rl := &rltag{}
if err := vu.New(rl, "Random Levels", 400, 100, 800, 600); err != nil {
log.Printf("rl: error starting engine %s", err)
}
defer catchErrors()
}
// sg tests the scene graph by building up a movable character that has multiple
// layers of sub-parts. The scene graph is demonstrated by changing the top level
// location, orientation and having it affect the sub-parts. Sg also tests adding
// and removing parts from a scene graph. Note that transparency sorting is
// handled by the engine.
//
// This example has a bit more code due to playing around with what can best
// be described as merging and splitting voxels.
func sg() {
sg := &sgtag{}
if err := vu.New(sg, "Scene Graph", 400, 100, 800, 600); err != nil {
log.Printf("sg: error starting engine %s", err)
}
defer catchErrors()
}
// ps demonstrates a CPU-based particle system and a GPU-based (shader only)
// particle system with support provided by vu/Effect.
func ps() {
ps := &pstag{}
if err := vu.New(ps, "Particle System", 400, 100, 800, 600); err != nil {
log.Printf("ps: error starting engine %s", err)
}
defer catchErrors()
}
// tm demonstrates creating, texturing, and rendering a dynamic terrain map
// from a generated height map. The intent is to mimic a surface/land map.
func tm() {
tm := &tmtag{}
if err := vu.New(tm, "Terrain Map", 400, 100, 800, 600); err != nil {
log.Printf("tm: error starting engine %s", err)
}
defer catchErrors()
}
// bb tests the engines handling of billboards and banners as well
// as combining multiple textures using shaders.
func bb() {
bb := &bbtag{}
if err := vu.New(bb, "Billboarding & Banners", 400, 100, 800, 600); err != nil {
log.Printf("bb: error starting engine %s", err)
}
defer catchErrors()
}
// lt tests the engines handling of some of the engine lighting shaders.
// It also checks the conversion of light position and normal vectors
// needed for proper lighting.
func lt() {
lt := <tag{}
if err := vu.New(lt, "Lighting", 400, 100, 800, 600); err != nil {
log.Printf("lt: error starting engine %s", err)
}
defer catchErrors()
}
// kc explores treating the keyboard as a controller.
// It assigns each keyboard key a unique symbol.
func kc() {
kc := &kctag{}
if err := vu.New(kc, "Keyboard Controller", 200, 200, 900, 400); err != nil {
log.Printf("kc: error starting engine %s", err)
}
defer catchErrors()
}
// ma, model animation, is an example of loading and animating a model using
// skeletel animation. It is based on the example data provided in the IQM
// Development kit from http://sauerbraten.org/iqm.
func ma() {
ma := &matag{}
if err := vu.New(ma, "Model Animation", 400, 100, 800, 600); err != nil {
log.Printf("ma: error starting engine %s", err)
}
defer catchErrors()
}
// fm demos and tests the vu/form package by visualizing grid layouts
// created from string based layout plans. Overall this is an experiment
// in trying to provide some application GUI support.
func fm() {
fm := &fmtag{}
if err := vu.New(fm, "Form Layout", 400, 100, 800, 600); err != nil {
log.Printf("fm: error starting engine %s", err)
}
defer catchErrors()
}
// rc demonstrates ray-casting and mouse-picking. In this example the plane
// is centered at the origin and the camera is tilted 45 degrees around X.
func rc() {
rc := &rctag{}
if err := vu.New(rc, "Ray Cast", 400, 100, 800, 600); err != nil {
log.Printf("rc: error starting engine %s", err)
}
defer catchErrors()
}
// cr, collision resolution, demonstrates simulated physics by having balls bounce
// on a floor. The neat thing is that after the initial locations have been set
// the physics simulation (vu/move) handles all subsequent position updates.
func cr() {
cr := &crtag{}
if err := vu.New(cr, "Collision Resolution", 400, 100, 800, 600); err != nil {
log.Printf("cr: error initializing engine %s", err)
}
defer catchErrors()
}
// tt demonstrates rendering to a scene to a texture, and then
// displaying the scene on a quad. Background info at:
// http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-14-render-to-texture/
// http://processors.wiki.ti.com/index.php/Render_to_Texture_with_OpenGL_ES
// http://in2gpu.com/2014/09/24/render-to-texture-in-opengl/
// http://www.lighthouse3d.com/tutorials/opengl_framebuffer_objects/
func tt() {
tt := &totex{}
if err := vu.New(tt, "Render to Texture", 400, 100, 800, 600); err != nil {
log.Printf("tt: error starting engine %s", err)
}
defer catchErrors()
}
// sm, shadow map, tests the engines handling of shadow maps
// and multipass rendering. These are hard shadows.
// FUTURE: upgrade shader to PCSS ie:
// http://developer.download.nvidia.com/whitepapers/2008/PCSS_Integration.pdf
func sm() {
sm := &smtag{}
if err := vu.New(sm, "Shadow Map", 400, 100, 800, 600); err != nil {
log.Printf("sm: error starting engine %s", err)
}
defer catchErrors()
}
// main recovers saved preferences and initializes the game.
func main() {
mp := &bampf{}
var err error
var x, y int
x, y, mp.ww, mp.wh, mp.mute = mp.prefs()
mp.setLogger(mp)
if err = vu.New(mp, "Bampf", x, y, mp.ww, mp.wh); err != nil {
logf("Failed to initialize engine %s", err)
return
}
defer catchErrors()
}
