Skip to main content

Understanding ORE Core

In a 3D rendering engine, the core modules determine the functionality and performance of the engine. The core modules of ORE are designed and abstracted efficiently, providing flexible and powerful features that help developers quickly build complex rendering scenes. The core modules provide the following features:

  • Scene Tree Organization: Organize and manage objects in the scene with dynamic updates.
  • Rendering Resource Management: Efficiently load and manage rendering resources while optimizing memory and performance.
  • Low-Level Graphics API Abstraction: Simplify interactions between developers and low-level graphics APIs.
  • Rendering Context Management: Manage graphics devices and rendering states, supporting multi-threaded rendering.
  • Mathematical Operations: Define data types in the scene and provide efficient tools for geometric transformations and graphical calculations.

Core Module Features​

Below is a brief description of the features provided by the Core module. You can explore detailed tutorials later to learn how to use these features.

Scene Tree Organization​

The scene tree module is used to organize and manage all objects in a 3D scene. It represents various rendering elements and their parent-child relationships in the scene through a tree structure, including geometric data, spatial transformations, material information, or camera details. The scene tree supports dynamic operations, such as adding, deleting, or modifying objects, and provides efficient traversal functionality for updating and rendering the entire scene.

Low-Level Graphics API Abstraction​

The core module implements an abstraction over graphics APIs like OpenGL (with Vulkan, DirectX, etc., to be added in future development), providing a unified interface to simplify interactions with low-level graphics APIs.

  • Encapsulates low-level rendering operations, such as drawing, state settings, and texture binding.
  • Provides abstract rendering objects, including buffers, shaders, textures, materials, cameras, etc.
  • Supports cross-platform development by offering a unified rendering interface, hiding differences between various graphics APIs.

Rendering Context Management​

The core module manages graphics devices and rendering states, including window initialization, context creation, state settings, and support for multi-threaded rendering.

Mathematical Operations​

Mathematical operations are the foundation of 3D rendering engines, used to handle geometric transformations, ray casting, intersection tests, and more. The core module provides efficient mathematical tools to support various computations in 3D space. Key features include:

  • Data Types: Offers mathematical representations of 3D rendering elements, such as buffer arrays, bounding volumes, rotation quaternions, planes, etc.
  • Vector Operations: Includes operations like addition, subtraction, dot product, cross product, and normalization, used for calculating vertex positions, lighting directions, viewing angles, etc.
  • Matrix Operations: Provides matrix multiplication, transposition, inverse computation, and more, enabling model transformations (scaling, rotation, translation), view transformations, and projection transformations.

Rendering Resource Management​

The rendering resource management module is responsible for loading, allocating, and optimizing rendering resources (such as textures, vertex data, shaders, etc.). Core features include:

  • Resource Loading: Supports asynchronous loading to reduce main thread blocking.
  • Memory Optimization: Reduces memory usage through resource reuse and garbage collection mechanisms.
  • Performance Optimization: Implements techniques like batching and instanced rendering to enhance performance.

Declarative API​

ORE simplifies the graphics programming process by encapsulating complex WebGL instructions into an object-oriented declarative API. This allows users to work at a higher level of abstraction. Developers can easily define and manage vertex data, construct geometric shapes, configure colors and lighting effects, and set rendering states, enabling them to focus on business logic without diving into the implementation details of the underlying graphics engine.

For example, the following code demonstrates how the ORE interface vertices is used to create and manage a vertex buffer. Users only need to define vertex data, organize it into geometry, and pass it into the rendering context.

// Define geometry
const geometry: JGeometry = {
    vertices: {
        positions: Vertices([-0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, 0.5]),
    },
    indices: Triangles([0, 1, 2, 0, 2, 3])
};

In later tutorials, you will see many such interfaces that allow you to declaratively define the objects needed for rendering.

// Define material
const material = phongMaterial({
    appearance: color,
    lightPosition,
    opacity: ore.float(0.4),
});

// Declare rendering node
const node: JNode = {
    mesh: {
        primitives: [{ geometry, material }]
    }
};

// Declare camera
const camera = Camera();

// Declare rendering pass
const pass: JPass = Pass({
    background: background,
    camera: camera,
    node: {
        children: [node],
    }
});

// Declare rendering scene
const scene: JScene = {
    name: 'scene',
    passes: [pass],
};

Summary​

The core modules of ORE provide comprehensive support, from scene organization to rendering execution, through efficient design and abstraction. Whether it’s the encapsulation of low-level graphics APIs or the use of high-level declarative APIs, ORE demonstrates its flexibility and high performance. By learning the core modules, you can quickly master how to build complex 3D rendering scenes and apply them to real-world projects.