Description

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.

Specifications

• Functionality:

  • Rendering:

    • Output:

      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.
      

    • Dithered Color-Index Mode:

      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
      part, nonsense.
      
      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.

    • Techniques:

      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.

    • Rasterization Algorithms:

      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.
      

  • Primitives:

    • Points
    • Lines
    • Line Strips
    • Line Loops
    • Triangles
    • Triangle Strips
    • Triangle Fans
    • Quads
    • Quad Strips

  • Texture Mapping:

    • Perspective correct UV interpolation
    • Double texturing (Multi-texturing but only with two textures)
    • Sphere environment mapping
    • Downsampling alternative to mipmapping (block filtering)
    • RGB and ARGB image formats
    • Alpha Test with ARGB textures
    • Texture Application Modes:
      • Decal
      • Add
      • Modulate
      • Mix
    • Texture Filters:
      • Nearest Index
      • Dithered
      • Bilinear

  • Buffers:

    • Color Buffer - where the renderer draws to
    • Depth Buffer - stores the depth values per pixel to allow for depth testing
    • Accumulation Buffer - used to accumulate images over time to create effects like motion blur, antialiasing, and depth of field
    • Coverage Buffer - faster, but less functional version of a stencil buffer, useful for front to back BSP rendering
    • ID Buffer - allows the user to assign numbers to pixels and retrieve the number at a given (x, y) coordinate. Useful for picking
    • Pixel Buffer - used by the deferred renderer to store pixel attributes in order to compute the final image

  • Lighting:

    • Shading Modes:
      • Flat
      • Vertex
      • Per-pixel
    • Light Color (RGB) Attributes:
      • Ambient
      • Diffuse
      • Specular
      • Emissive
    • Light Attenuation Attributes:
      • Constant
      • Linear
      • Quadratic
    • Light Spotlight Attributes:
      • Exponent
      • Cutoff
      • Direction
    • Light Model Attributes:
      • Ambient - Global ambient intensity
      • Local Viewer - whether the viewpoint is local or infinite
      • Two Sided - whether or not both sides of each polygon have lighting calculations done on them
      • RGB - whether the lighting results are in full RGB or just grayscale
    • Material Attributes:
      • Ambient
      • Diffuse
      • Specular
      • Emissive
      • Shininess
    • Separate interpolation and application of (ambient + diffuse) and specular color
    • Approximately energy conservative Blinn-Phong lighting
    • Color material functionality

• Limitations:

  • Maximum Number of Textures: 32768
  • Maximum Texture Dimension: 2048x2048
  • Maximum Number of Lights: 128
  • Maximum Number of Arbitrary Clipping Planes: 6
  • Maximum Viewport Size: 2048x2048
  • Maximum Modelview Stack Depth: 64
  • Maximum Projection Stack Depth: 16
  • Maximum Texture Stack Depth: 16
  • Maximum Double Map Texture Stack Depth: 16

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.

References

• OpenGL^®
• The Mesa 3D Graphics Library
• GLUT - The OpenGL Utility Toolkit
• Developing Games in Java by David Brackeen
• jGL - 3D Graphics Library for Java
• C/CPP DirectX Software Rendering Techniques/Engine Tutorial

Special Thanks To

• The Java-Gaming community for support and information
• TheAgentD on Java-Gaming,org for optimization tips, helping me understand some difficult topics, and supporting me in general
• David Brackeen for writing the great book Developing Games in Java which was one of the reasons why I got interested in games and graphics

Examples and Downloads

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

Primitives: prim.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

Spotlights: spot.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