Sixth 3D - Realtime 3D engine

Add Sixth 3D to your pom.xml:

<dependencies>
    <dependency>
        <groupId>eu.svjatoslav</groupId>
        <artifactId>sixth-3d</artifactId>
        <version>1.3</version>
    </dependency>
</dependencies>

<repositories>
    <repository>
        <id>svjatoslav.eu</id>
        <name>Svjatoslav repository</name>
        <url>https://www3.svjatoslav.eu/maven/</url>
    </repository>
</repositories>

Here is a minimal working example:

import eu.svjatoslav.sixth.e3d.geometry.Point3D;
import eu.svjatoslav.sixth.e3d.gui.ViewFrame;
import eu.svjatoslav.sixth.e3d.math.Transform;
import eu.svjatoslav.sixth.e3d.renderer.raster.Color;
import eu.svjatoslav.sixth.e3d.renderer.raster.ShapeCollection;
import eu.svjatoslav.sixth.e3d.renderer.raster.shapes.composite.solid.SolidPolygonRectangularBox;

public class MyFirstScene {
    public static void main(String[] args) {
        // Create the application window
        ViewFrame viewFrame = new ViewFrame();

        // Get the collection where you add 3D shapes
        ShapeCollection shapes = viewFrame.getViewPanel().getRootShapeCollection();

        // Add a red box at position (0, 0, 0)
        Transform boxTransform = new Transform(new Point3D(0, 0, 0), 0, 0);
        SolidPolygonRectangularBox box = new SolidPolygonRectangularBox(
                new Point3D(-50, -50, -50),
                new Point3D(50, 50, 50),
                Color.RED
        );
        box.setTransform(boxTransform);
        shapes.addShape(box);

        // Position your camera
        viewFrame.getViewPanel().getCamera().setLocation(new Point3D(0, -100, -300));

        // Update the screen
        viewFrame.getViewPanel().repaintDuringNextViewUpdate();
    }
}

Compile and run MyFirstScene class. New window should open that will display 3D scene with red box.

Navigating the scene:

Movement uses physics-based acceleration for smooth, natural motion. The faster you're moving, the more acceleration builds up, creating an intuitive flying experience.

A vertex is a single point in 3D space, defined by three coordinates: x, y, and z. Every 3D object is ultimately built from vertices. A vertex can also carry additional data beyond position.

• Position: (x, y, z)
• Can also store: color, texture UV, normal vector
• A triangle = 3 vertices, a cube = 8 vertices
• Vertex maps to Point3D class in Sixth 3D engine.

An edge is a straight line segment connecting two vertices. Edges define the wireframe skeleton of a 3D model. In rendering, edges themselves are rarely drawn — they exist implicitly as boundaries of faces.

• Edge = line from V₁ to V₂
• A triangle has 3 edges
• A cube has 12 edges
• Wireframe mode renders edges visibly
• Edge is related to and can be represented by the Line class in Sixth 3D engine.

A face is a flat surface enclosed by edges. In most 3D engines, the fundamental face is a triangle — defined by exactly 3 vertices. Triangles are preferred because they are always planar (flat) and trivially simple to rasterize.

• Triangle = 3 vertices + 3 edges
• Always guaranteed to be coplanar
• Quads (4 vertices) = 2 triangles
• Complex shapes = many triangles (a "mesh")
• Face maps to SolidPolygon or TexturedPolygon in Sixth 3D.

Every point in 3D space is located using three perpendicular axes originating from the origin (0, 0, 0). The X axis runs left–right, the Y axis runs up–down, and the Z axis represents depth.

• Right-handed vs left-handed systems differ in which direction +Z points
• Right-handed: +Z towards viewer (OpenGL)
• Left-handed: +Z into screen (DirectX)

A normal is a vector perpendicular to a surface. It tells the renderer which direction a face is pointing. Normals are critical for lighting — the angle between the light direction and the normal determines how bright a surface appears.

• Face normal: one normal per triangle
• Vertex normal: one normal per vertex (averaged from adjacent faces for smooth shading)
• dot(L, N) → surface brightness
• Flat shading → face normals
• Gouraud/Phong → vertex normals + interpolation

A mesh is a collection of vertices, edges, and faces that together define the shape of a 3D object. Even curved surfaces like spheres are approximated by many small triangles — more triangles means a smoother appearance.

• Mesh data = vertex array + index array
• Index array avoids duplicating shared vertices
• Cube: 8 vertices, 12 triangles
• Smooth sphere: hundreds–thousands of triangles
• vertices[] + indices[] → efficient storage
• In Sixth 3D engine:
  • AbstractCoordinateShape: base class for single shapes with vertices (triangles, lines). Use when creating one primitive.
  • AbstractCompositeShape: groups multiple shapes into one object. Use for complex models that move/rotate together.

The order in which a triangle's vertices are listed determines its winding order. Counter-clockwise (CCW) typically means front-facing. Backface culling skips rendering triangles that face away from the camera — a major performance optimization.

• CCW winding → front face (visible)
• CW winding → back face (culled)
• Saves ~50% of triangle rendering
• Normal direction derived from winding order via cross(V₂-V₁, V₃-V₁)

In Sixth 3D, backface culling is optional and disabled by default. Enable it per-shape:

• SolidPolygon.setBackfaceCulling(true)
• TexturedPolygon.setBackfaceCulling(true)
• AbstractCompositeShape.setBackfaceCulling(true) (applies to all sub-shapes)

Sixth 3D uses its own Color class (not java.awt.Color):

import eu.svjatoslav.sixth.e3d.renderer.raster.Color;

// Using predefined colors
Color red = Color.RED;
Color green = Color.GREEN;
Color blue = Color.BLUE;

// Create custom color (R, G, B, A)
Color custom = new Color(255, 128, 64, 200); // semi-transparent orange

// Or use hex string
Color hex = new Color("FF8040CC"); // same orange with alpha

• Read online JavaDoc.
• See Sixth 3D class diagrams. (Diagrams were generated by using JavaInspect utility)
• Study demo applications.

Very high-level idea description:

• This would significantly reduce RAM <-> CPU traffic.
• General algorithm description:
  • For each horizontal scanline:
    • sort polygon edges from left to right
    • while iterating and drawing pixels over screen X axis (left to right) track next appearing/disappearing polygons.
      • For each polygon edge update Z sorted active polygons list.
      • Only draw pixel from the top-most polygon.
        • Only if polygon area is transparent/half-transparent add colors from the polygons below.
• As a bonus, this would allow to track which polygons are really visible in the final scene for each frame.
  • Such information allows further optimizations:
    • Dynamic geometry simplification:
      • Dynamically detect and replace invisible objects from the scene with simplified bounding box.
      • Dynamically replace boudnig box with actual object once it becomes visible.
    • Dynamically unload unused textures from RAM.