Procedural AAA Game Engine Development

Organize a C++ engine, editor, and sandbox application as separate CMake targets with explicit dependencies.

Use vector addition, scaling, dot products, and cross products to solve 3D geometry problems.

Distinguish points, directions, coordinate handedness, and local, world, view, and clip spaces.

Represent translation, rotation, and scale with homogeneous matrices.

Compose parent and child transformations in the correct multiplication order.

Construct view and perspective-projection matrices for a movable 3D camera.

Use quaternions to represent orientation and interpolate between rotations.

Trace vertex data through the programmable graphics pipeline to a displayed pixel.

Initialize a Direct3D 11 device, swap chain, render target, and viewport.

Compile HLSL vertex and pixel shaders and report shader compilation errors.

Upload and draw indexed geometry using vertex buffers, index buffers, and input layouts.

Send per-frame and per-object transformation data to shaders through constant buffers.

Configure depth testing, face culling, and rasterizer state for solid 3D rendering.

Implement a free-flying camera controlled through the engine input layer.

Load a 2D image into a GPU texture and sample it from an HLSL shader.

Compute transformed surface normals correctly under non-uniform object scaling.

Implement ambient and directional diffuse lighting for a textured mesh.

Represent shader, texture, and render-state choices in a reusable material abstraction.

Sort visible draw items to reduce unnecessary material and pipeline state changes.

Compare inheritance-heavy object models with data-oriented entity-component-system design.

Represent entity identity with versioned handles that detect stale references.

Store components in cache-friendly contiguous pools and support entity removal safely.

Execute ECS systems over only the component combinations they require.

Implement a transform hierarchy that propagates dirty world transformations.

Use queued events to communicate between engine systems without direct ownership coupling.

Assign stable identifiers to source assets independently of file-system paths.

Cache shared GPU resources with explicit loading and lifetime states.

Import mesh geometry from a standard interchange format into engine vertex and index data.

Separate editable source assets from runtime-ready asset representations.

Serialize and deserialize entities and components using a versioned scene format.

Reload a changed shader or texture without restarting the sandbox application.

Integrate linear velocity and acceleration at a fixed simulation timestep.

Test intersections between spheres, axis-aligned boxes, rays, and planes.

Use a uniform spatial grid to reduce the number of potential collision pairs.

Separate broad-phase candidate generation from narrow-phase contact testing.

Resolve a basic frictionless collision using contact normals and impulses.

Implement ray-based ground detection for a simple kinematic character controller.

Embed a Lua runtime and execute a script through a controlled engine interface.

Expose selected entity components to Lua without leaking unmanaged C++ lifetimes.

Define deterministic script initialization, update, and shutdown callbacks.

Represent reusable entity configurations as data-driven prefabs.

Implement a finite-state behavior for an agent using components and scripts.

Route gameplay events between native systems and scripts while avoiding immediate re-entrant calls.

Generate reproducible pseudorandom sequences from an explicit world seed.

Sample coherent noise and combine octaves to produce controllable terrain variation.

Generate a height-field terrain mesh with consistent normals and texture coordinates.

Partition procedural terrain into addressable chunks using integer world coordinates.

Classify terrain into biomes from deterministic elevation and climate fields.

Place environmental features reproducibly while preventing placement conflicts.

Integrate an immediate-mode GUI as an engine debug and editing layer.

Display a scene hierarchy and inspect the components attached to a selected entity.

Edit component properties through metadata-driven controls.

Convert a cursor position into a world-space picking ray for scene selection.

Manipulate an entity transform with translation, rotation, and scale gizmos.

Represent an editor operation as a reversible command supporting undo and redo.

Measure CPU frame sections and GPU passes with appropriate profiling markers.

Interpret frame-time distributions rather than relying only on average frames per second.

Compare array-of-structures and structure-of-arrays layouts using a cache-sensitive benchmark.

Allocate short-lived per-frame data from a resettable linear arena.

Implement a thread-safe work queue for independent background jobs.

Load and prepare asset data in the background while creating GPU resources on the render thread.

Define measurable frame-time, memory, and world-size budgets for the vertical slice.

Stream terrain chunks around the camera without blocking the main update loop.

Spawn scripted agents deterministically from chunk-level procedural data.

Store player-authored world changes separately from seed-derived world data.

Validate that identical seeds and inputs reproduce equivalent initial world states.

Evaluate the engine's subsystem boundaries and produce a prioritized roadmap toward modern rendering, large-scale worlds, networking, and advanced simulation.