|
 |
---
## High‑level flowchart
```
Start
│
├─► 1) Read CLI / INI options
│ (input file, libs, image size, AA, output type, etc.)
│
├─► 2) Load scene sources
│ (main .pov + #include files via library paths)
│
├─► 3) Parse SDL
│ a) Scan & tokenize
│ b) Parse syntax → build scene data
│ c) Evaluate expressions/macros/functions
│
├─► 4) Build render structures
│ (materials, textures, lights, camera, objects,
│ bounding/acceleration, symbol tables)
│
├─► 5) Prepasses (optional)
│ a) Radiosity pretrace
│ b) Photon shooting/sorting
│ c) Media setup
│
├─► 6) Render view (multi-threaded)
│ a) Partition image into rectangles/tiles
│ b) For each pixel: primary ray(s)
│ c) Intersections, shading, secondary rays
│ d) AA sampling & filtering
│
├─► 7) Post & output
│ (gamma/display; write PNG/TGA/BMP/PPM; alpha/bit depth)
│
└─► End
```
---
## Expanded outline (what each stage does and where to look)
### 1) Read command‑line / INI options
- POV‑Ray merges options from the command‑line and `.ini` files:
input file (`+I`), library paths (`+L`), image size (`+W`, `+H`), display
depth, alpha, partial regions, and more. These options drive both parsing and
rendering behavior.
### 2) Load scene sources
- The main scene file is opened, and any `#include` files are resolved using the
current working directory and configured library paths. Parsing options also
honor version switches affecting language compatibility.
### 3) Parse SDL into an internal scene
**Lexing & tokenization**
- **Scanner** reads raw characters (handles encoding, whitespace, comments) and
emits lexemes.
- **Tokenizer** converts lexemes into tokens (identifiers, numbers, strings,
keywords, operators).
**Syntax & semantic parsing**
- The **Parser** consumes tokens and constructs the in‑memory scene:
objects, CSG, transforms, textures/pigments/finishes, lights, cameras, media,
and control structures (`#declare`, `#local`, `#macro`, conditionals, loops). It
manages symbol tables and evaluates expressions; user‑defined functions
are compiled to an internal representation for evaluation.
> Where to look in the tree: `source/parser/*` for scanner/tokenizer/parser;
`reservedwords.*` for language tokens. The
### 4) Build render‑time structures
- Parsed scene data are organized into runtime structures used by the renderer
(scene graph, object instances, materials). Spatial data structures and bounding
information are prepared to accelerate intersection tests; views and task queues
are initialized for multi‑threaded rendering. (See the rendering engine
overview and scene/view/task classes.)
### 5) Optional prepasses: global illumination & volumetrics
- **Radiosity** pretrace: samples indirect diffuse lighting and populates a
cache before (and during) final rendering. Controlled via `global_settings {
save/load data).
- **Photon mapping**: shoots photons from light sources, stores them
(surface/media photon maps), then sorts/builds lookup structures used during
shading for caustics and volumetric effects.
- **Media setup**: configures participating media (scattering/absorption) for
volumetric lighting and fog during the ray march in the render stage. (General
capability references via integration docs and engine overview.)
### 6) Rendering the image (core ray tracing loop)
**Block/rectangle scheduling (multi‑threaded)**
- The renderer splits the image into rectangles (tiles). Worker threads pull
utilization and cache behavior.
**Per‑pixel workflow**
1. Generate primary camera ray(s) through the pixel.
2. Traverse acceleration/bounding to find the nearest intersection.
3. Shade the hit point:
- Direct lighting (light sampling, shadows/attenuation).
- **Radiosity** (indirect diffuse) lookup/update if enabled.
- **Photon map** estimates for caustics/volumetrics if enabled.
- Reflections/refractions, fresnel, dispersion, normal/bump mapping,
procedural/textured pigments, media marching, etc.
4. Spawn secondary rays as needed (reflection/refraction/shadow/GI) with
recursion limits.
5. **Anti‑aliasing**: Depending on method, adaptively supersample pixels
when contrast exceeds threshold; recursive subdivision for `+AM2` vs.
non‑recursive `+AM1`. Jittering is optional.
### 7) Post‑processing & file output
- Apply display/gamma handling as configured; update interactive preview if
enabled. Output is then encoded in the requested format (e.g., PNG, TGA,
BMP/SYS, PPM) with chosen bit depth and optional alpha, controlled by
`Output_File_Type`, `Bits_Per_Color`, `Output_Alpha`, and `Output_to_File`.
Partial‑region rendering and resume/abort are also supported through
options.
---
## Quick cross‑reference (docs & source)
- **Official documentation hub** (3.7/3.6): tables of all runtime options &
language features.
- **Parsing options** (input file, includes, versioning):
- **Output file options** (formats, bit depth, alpha):
- **Display/preview & gamma**:
- **Anti‑aliasing** (threshold, methods, jitter):
- **Radiosity** (reference/how‑to):
- **Photon mapping** (implementation overview):
- **Rendering engine internals** (view, tiles, threads, trace pixel):
- **Repo root / status**:
---
Post a reply to this message
|
|
