FFP (Fixed-Function Pipeline) is a software 2D/3D graphics engine written in pure Java.
The engine provides a large number of features and some of the fastest accurate software rendering available for Java.
All rendering is done to an image buffer supplied by the user.
This image buffer is expected to be in 32-bit A8_R8_G8_B8 format
and is written to as such.
The engine supports dithered indexed color.
The colormap can be user defined or created automatically by the engine.
It is highly recommended that the user avoids defining the colormap by themselves
because the order that the colors appear in the colormap are important. If colors in
the colormap are not defined in the correct order, the color output will be, for the most
If the user does wish to define their own colormap but has no knowledge
of the correct color order, the engine provides a function to retrieve the
current colormap. This allows the user to see the correct order so that
they can model their own colormap properly.
Deferred AND forward rendering.
The user can freely switch between either rendering technique provided that
they (the user) are not in the process of defining a primitive.
A useful piece of information to remember is that deferred rendering
is most effective for scenes with a lot of potential overdraw,
unlike forward rendering.
A deferred renderer runs at a much more constant frame rate than a
forward renderer. This means that deferred rendering will most likely
not provide extremely high frame rates, but it is also less likely to
produce extremely low frame rates.
Filled polygon rasterization is achieved using a simple scan-line algorithm.
Lines are rasterized using the DDA line algorithm.
Points are rasterized as a square.
Click here to see the OpenGL® functions that FFP supports as well as the functions that only FFP has.
Click here to see a list of symbolic constants in FFP along with their numerical value and a short description of what each does and where each is used.
Feel free to contact me at email@example.com
Download a ZIP archive of version 1.0.4 of the FFP Graphics Engine here: ffp_1_0_4.zip
Download a ZIP archive of all of the following examples here: ffp_examples.zip
Documentation for the engine is found here: FFP Documentation
All of the following example applications extend this class: DemoBase.java
Some of the following example applications implement this interface: jitter_h.java
Antialiasing using the accumulation buffer with an orthographic projection: accanti.java
Antialiasing using the accumulation buffer with a perspective projection: accpersp.java
Basic 2D Graphics: basic2d.java
A form of downsampling called "block filtering" which is best described as a poor man's mipmapping.: blockfilter.java
Chaos demonstrated using Feigenbaum's constant: chaos.java
Texture mapping and texture filters: checker.java
Clipping a sphere with two arbitrary clipping planes: clip.java
Cloth Simulation : cloth.java
A Color Cube: colorcube.java
Demonstration of color material mode: colormat.java
Simple 3D cube: cube.java
Dithering to a palette: dither.java
Double mapping (multi-texturing) example: dmtex.java
Depth of field with the accumulation buffer: dof.java
Exponential fog: fog.java
Gamma testing: gamma.java
Gears program, taken from the Mesa 3D demos: gears.java
3D Function Graphing. Some functions are taken from https://www.benjoffe.com/code/tools/functions3d/examples: graph3d.java
Picking by using the ID buffer: idbuf.java
Line Stippling: lines.java
The Mandelbrot Set: mandelbrot.java
Grid of Different Materials: material.java
Modeling Transformations: model.java
Motion blur using the accumulation buffer: motionblur.java
Moving a light source around a torus: movelight.java
Moving multiple colored light sources around a torus: movelights.java
Parametric graphing: parametric.java
Polar graphing: polar.java
Polyhedra routines in FFPAUX: polyhedra.java
Polygon offset to draw wireframes without z-fighting: polyoff.java
Polygon stippling: polys.java
Advanced demonstration of the FFPAUX quadric routines: quad.java
Quadric routines: quadric.java
Rendering to a texture by copying the frame buffer into a texture: render2tex.java
Robot arm showing composite modeling transformations: robot.java
Image rotation: rotate.java
Simple scene with lighting: scene.java
Screendoor transparency: screendoor.java
Cube with a shadow projected onto two planes: scube.java
Shadows created by lightmapping: shadow.java
Shadows created by shadow mapping: shadowmap.java
Sierpinski triangle created using a simple algorithm: sierpinski.java
Smooth vertex color interpolation: smooth.java
Phong shaded torus: smoothtorus.java
Sphere mapping with lighting and double texturing: spheremap.java
Grid of spheres with semi-realistic materials: spheres.java
3D Starfield: star.java
Steam engine converted from https://www.opengl.org/archives/resources/code/samples/glut_examples/contrib/steam.c: steam.java
Replacing a part of a texture: texsub.java
Clipping three tori with an arbitrary clipping plane: torusclip.java
Post render image filters: vidfilter.java
Returning depth information to the screen: vrd.java
Water surface created from perlin noise and trig functions. This is a highly modified version of this program: http://www.lousodrome.net/opengl/#water: watersurf.java
Stored frame-by-frame animation of a wave: wave.java
Demonstrating why proper depth ordering is needed for scene realism: zbuf.java
DISCLAIMER: Some code examples were written by other authors
This website was last updated on Thursday July 6, 2017
© 2017 MIREMADI