CHAPTER ONE

INTRODUCTION

1.1 Background to the Study

Procedural Content Generation (PCG) is a technique used in computing to automatically create

data and assets using algorithms, rather than building them by hand. One of its most important
applications is Procedural Terrain Generation (PTG), which has been used in games since the
1980s as a way to create large, varied game worlds without requiring enormous amounts of
manually created data or storage space.

In modern game development, particularly for large open-world experiences, PTG has become
essential. Designing vast virtual worlds by hand is expensive and time-consuming. PTG
addresses this by using mathematical functions, such as noise functions, to generate structured
yet seemingly natural landscapes. Because these algorithms are deterministic, the same input
value (called a "seed") will always produce the same world. This means the terrain can be
recreated on demand without storing the full data, which is a critical advantage for memory-
limited systems.

Despite these advantages, PTG introduces its own technical challenge: generating and rendering
complex 3D terrain in real-time is computationally expensive. On devices with limited hardware,
this cost can make applications unplayable. The challenge therefore is not just to generate terrain
procedurally, but to do so in a way that is efficient enough to run smoothly on resource-
constrained hardware.

This project addresses that challenge directly by designing and developing a PTG system that
uses established optimisation techniques specifically Level of Detail (LOD), chunk-based
rendering, and spatial partitioning via a Quadtree structure within the Unity Game Engine using
C#. The goal is to demonstrate that high-quality, infinite procedural terrain can be achieved and
maintained at acceptable performance levels even on low-specification hardware.

1.2 Statement of the Problem

Video games are played on a wide range of devices, including low-specification personal
computers with limited CPU, GPU, and memory resources. At the same time, modern games
increasingly demand large, detailed open-world environments that are expensive to render. This
creates a fundamental tension: the richer the virtual world, the heavier the computational cost,
and the less accessible the game becomes on lower-end hardware.

Procedural terrain generation, while cost-effective during development, does not automatically
solve the performance problem. Generating and rendering large terrain as a single mesh places a
heavy load on both the CPU and GPU. Without targeted optimisation, this approach quickly
produces unacceptable frame rates often dropping below 15 frames per second on resource-
constrained devices, making the application unplayable.

The problem, therefore, is the persistent difficulty in balancing the demand for visually
compelling, large-scale procedural terrain with the strict performance and memory requirements
of resource-constrained hardware. Existing general-purpose procedural generation approaches
often fail to maintain a stable frame rate and operational stability on low-specification devices. A
specialised system design that aggressively optimises the generation and rendering pipeline
without sacrificing the quality of the virtual environment is therefore needed.

1.3 Aim and Objectives of the Study

The main aim of this study is the design and development of an optimised procedural terrain
generation system specifically engineered for resource-constrained hardware.

The following objectives are set to achieve this aim:

I. To implement and integrate core procedural algorithms, specifically Perlin Noise with
fractional Brownian motion, to generate diverse and natural-looking terrain topology.

II. To incorporate Level of Detail (LOD) techniques and a chunk-based rendering

architecture to optimise rendering performance and memory management.

III. To implement a Quadtree spatial partitioning structure to efficiently manage terrain

chunks and LOD assignments at runtime.

IV. To develop the full system within the Unity Game Engine using C#, providing a robust
and reproducible framework suitable for deployment on resource-constrained platforms.

V. To evaluate the performance of the developed system against an unoptimised baseline,

measuring metrics including frame rate, draw call count, triangle count, and memory
consumption using Unity's built-in profiling tools.

1.4 Scope of the Study

The scope of this study is focused on the core technical implementation of procedural terrain
generation and performance optimisation within a clearly defined framework.

I. The system is developed using the Unity Game Engine and the C# programming language,
concentrating exclusively on the generation and rendering of a 3D terrain mesh.

II. Terrain generation uses Perlin Noise as the primary noise function to produce a
heightmap that determines terrain elevation. Multiple octaves of noise are layered using
fractional Brownian motion to produce varied, natural-looking terrain.

III. Optimisation is achieved through Level of Detail (LOD), chunk-based rendering, and a
Quadtree spatial partitioning structure that dynamically manages terrain complexity
based on the player's position.

IV. Performance is evaluated using Unity's built-in profiling tools specifically the Stats
window and the Unity Profiler to measure frame rate, draw calls, triangle count, and
memory usage. These results are compared against a non-optimised baseline to quantify
the improvement achieved.

V. The study does not extend to resource-heavy features such as advanced hydraulic or
thermal erosion modelling, detailed land-cover classification, or the generation of non-
terrain assets such as buildings, vegetation, or water bodies, as these fall outside the core
optimisation focus.

1.5 Significance of the Study

This research makes a practical contribution to the fields of computer graphics and game
development, particularly for independent developers and small studios working without large
budgets or teams.

I. It provides a working, tested framework that allows indie game developers to create large,
procedurally generated worlds that run efficiently on low-specification hardware, without
requiring the resources of a large studio.

II. The system demonstrates that high visual quality and high performance are not mutually
exclusive on resource-constrained devices, provided the right optimisation architecture is
used. This has direct implications for expanding the accessibility of 3D open-world
games to a broader audience.

III. The project provides measurable, empirical data on the performance gains achieved
 through the integration of LOD, chunk-based rendering, and Quadtree spatial partitioning
in a Unity PTG pipeline. This data can inform future development decisions in
performance-critical applications.

IV. The system serves as a reproducible, documented reference implementation that other
developers and researchers can study, build upon, or adapt for their own projects.

1.6 Limitation of the Study

The project is subject to the following limitations:

I. The generated terrain, while structured and varied, may show a degree of visual uniformity
due to the primary reliance on Perlin Noise as the core generation function. More
complex geological features would require additional noise functions or erosion
algorithms, which are beyond the scope of this project.

II. The optimisation strategy necessarily involves trade-offs. Achieving stable performance
on resource-constrained hardware requires limiting the complexity of geometric detail
and excluding computationally intensive features such as physically-based simulations.

III. Performance evaluation is limited to a specific set of hardware specifications

representing the target resource-constrained environment. Results may vary on other
devices not tested during this study.

IV. The system does not implement advanced LOD transition techniques such as
geomorphing, which means that rapid changes in detail level may occasionally be visible
as the player moves through the terrain.

1.7 Methodology and Organisation of Chapters

This study adopts a Design-Based Research approach, which involves the iterative design,
implementation, and evaluation of a technical solution to a real-world problem. The system is
developed in two increments first building a functional baseline terrain system, then adding the
full optimisation layer allowing performance to be measured and compared at each stage.

The project report is organised into five chapters:

I. Chapter One (Introduction): Outlines the background to the study, the problem being
addressed, the aim and objectives, the scope, significance, and limitations of the project.

II. Chapter Two (Literature Review): Presents a review of existing procedural generation
 techniques, theoretical frameworks, and related works, followed by a gap analysis
identifying the specific contribution of this research.

III. Chapter Three (Methodology): Details the systematic approach, software development
model, system architecture, tools used, and the procedures followed to design and
implement the optimised system.

IV. Chapter Four (System Design, Implementation and Testing): Describes the practical
implementation of the chosen algorithms, the deployment of the system in Unity, and the
results from performance testing and evaluation using Unity's profiling tools.

V. Chapter Five (Summary, Conclusion and Recommendation): Summarises the entire

project, draws conclusions from the findings, and provides recommendations for future
research and improvement.

1.8 Definition of Terms

Procedural Terrain Generation (PTG): The automated process of creating virtual 3D

landscapes using mathematical algorithms, rather than designing them by hand. The
primary advantages are reduced storage requirements and the ability to generate terrain
on demand from a single seed value.

Resource-Constrained Hardware: Computing devices such as low-end PCs or laptops

with integrated graphics that have significant limitations in their CPU processing power,
GPU capabilities, and available memory (RAM).

Level of Detail (LOD): A rendering technique that dynamically substitutes a complex

mesh model with a simpler, lower-polygon version as the object's distance from the
camera increases. This significantly reduces GPU workload without a noticeable drop in
visual quality from the player's perspective.

. Perlin Noise: A type of gradient noise function widely used in procedural generation to
produce natural-looking, continuous, and structured random patterns, making it well-
suited for generating terrain heightmaps.

. Heightmap: A 2D data array where the value of each point corresponds to the elevation of
the corresponding point in the 3D terrain mesh. The heightmap is the primary output of
the noise generation stage and the primary input to the mesh construction stage.

Chunk-Based Rendering: A technique where a large virtual world is divided into smaller,
manageable sections called chunks. Only the chunks within a defined distance from the
 player are loaded and rendered at any given time, significantly reducing memory usage
and improving real-time performance.

Quadtree: A tree data structure in which each node has exactly four child nodes. In terrain
management, a Quadtree is used to recursively divide the terrain plane into quadrants,
enabling efficient spatial queries and LOD assignments based on the player's proximity to
each region.

Fractional Brownian Motion (fBm): A technique for combining multiple layers (octaves)
of noise at different frequencies and amplitudes. The result mimics the fractal, self-
similar nature of real-world terrain, producing features at multiple scales from large
mountains down to small rocky details.