API reference

This reference is generated from the C++ headers. It covers these namespaces:

• raisim — The RaiSim physics engine: worlds, objects, articulated systems, contacts, sensors and the visualization server.
• raisin — The rayrai renderer (the namespace is spelled raisin): render windows, cameras, materials, lights, visuals and the TCP viewer.
• Global namespace — classes that the headers declare outside any namespace.

raisim

The namespace page documents the free functions, enums, type aliases and variables of raisim.

Core

• class AlignedAllocator — Standard allocator that returns memory aligned to RSALOCATOR_ALIGNMENT bytes (e.g. for vectors of fixed-size Eigen-backed types).
• struct CoacdOptions — CoACD convex decomposition parameters for mesh collision approximation.
• struct ColorRGB — 8-bit RGB color (components 0-255).
• struct ColorRGBA — 8-bit RGBA color (components 0-255).
• class DynamicArray — Owning heap buffer of doubles; the common base of VecDyn and MatDyn.
• class MatDyn — Dynamically sized matrix of doubles, stored column-major: element (i, j) is v[i + j * rows()].
• class MaterialManager — Table of contact properties per material pair.
• struct MaterialPairProperties — Contact properties of a pair of materials.
• class noiseUtils — Internal: numeric helpers of the terrain noise generator.
• class Path — A file system path string using the platform separator.
• class PerlinNoise — 3D Perlin gradient noise with a seeded 256-entry permutation table (period 256 on each axis).
• class RaiSimMsg — Message printer behind the RSINFO / RSWARN / RSFATAL macros (raisim_message.hpp).
• class RaisimServer — Streams a raisim::World (plus server-side visual-only objects and charts) over TCP to a visualizer such as the rayrai TCP viewer, and accepts interaction / sim-control requests (pause, step,…
• class RaiSimTinyXmlWrapper — Read-only convenience wrapper around a TinyXML element, used by the RaiSim XML, URDF and MJCF loaders.
• class RaiSimTinyXmlWriter — Minimal XML document writer: add top-level elements with operator[] and write the file with saveFile().
• class RaiSimTinyXmlWriterElement — Builder for one element of an XML document written by RaiSimTinyXmlWriter (used by World::exportToXml()).
• struct Rasset — A reusable visual asset with collision shapes in the visual's local frame. .rasset files are XML; paths are relative to the descriptor, not the process.
• class RayCollisionItem — One ray hit returned by World::rayTest().
• class RayCollisionList — Hit list returned by World::rayTest().
• class ScopedRaiSimFatalCallback — Restore-on-destruction wrapper for the calling thread's fatal callback.
• class SparseJacobian — Sparse Jacobian with three rows (e.g. of a point's position or of a body's angular velocity with respect to the generalized velocity) that stores only its non-zero columns.
• class SparseJacobian1D — Single-row counterpart of SparseJacobian: v holds the non-zero entries as a 1 x size row and entry i is column idx[i] of the full 1 x dof Jacobian.
• class StopWatch — Wall-clock timer based on std::chrono::steady_clock.
• class TerrainGenerator — Generates fractal Perlin-noise height samples from TerrainProperties.
• struct TerrainProperties — Parameters of a fractal Perlin-noise terrain (see TerrainGenerator and World::addHeightMap()).
• class TimedLoop — Scope guard for fixed-rate loops: its destructor sleeps until loopTimeInUs after its construction.
• struct Transformation — Rigid transformation stored as a rotation matrix and a translation.
• class VecDyn — Dynamically sized column vector of doubles (heap storage, see DynamicArray).
• class World — The simulation world.

Objects

• class Box — A rigid box.
• class Capsule — A rigid capsule (a cylinder capped by two hemispheres) whose axis is the body z axis.
• class Compound — A rigid body composed of primitive children (BOX, CYLINDER, CAPSULE, SPHERE) with user-given mass properties.
• class Cone — A cone. Not supported by the current collision engine: the constructor raises a fatal error.
• class Cylinder — A rigid cylinder whose axis is the body z axis.
• class Mesh — A rigid body defined by a triangle mesh (create it with World::addMesh()).
• class Object — Abstract base class of everything that can be added to a raisim::World: single bodies, terrains, articulated systems, deformable objects and granular systems.
• class SingleBodyObject — Base class of rigid single-body objects (Sphere, Box, Cylinder, Capsule, Mesh, Compound, Ground, ...).
• class Sphere — A rigid sphere.

Articulated systems

• struct ActuatorCoupling — A coupling of an actuator's motor to a joint other than the one the actuator drives (see ActuatorDefinition).
• struct ActuatorDefinition — An actuator: a DC/BLDC motor with its gear.
• struct ActuatorState — The state of an actuator in the last simulation step, with the motor quantities on the motor (rotor) side of its gear.
• class ArticulatedSystem — A tree of rigid bodies connected by joints (robot), simulated in generalized coordinates.
• class ArticulatedSystemOption — Options passed to the ArticulatedSystem constructors.
• class Body — Inertial, collision and visual properties of a link, used to build an articulated system (see Child).
• class Child — Node of a kinematic tree (a body plus the joint connecting it to its parent), used to build an ArticulatedSystem programmatically.
• struct CollisionBody — Collision geometry description of a Body, used when building an articulated system (see Body::addCollisionObject()).
• struct CollisionDefinition — collision definition that is stored in Articulated System (see ArticulatedSystem::getCollisionBodies()).
• class CoordinateFrame — A coordinate frame of an articulated system, defined at every joint (including fixed joints) and at sensors.
• struct DcMotorParameters — Steady-state electrical model of the DC/BLDC motor inside an actuator, on the motor (rotor) side of the actuator's gear, in SI units.
• class Joint — Joint connecting a body to its parent; used to build an articulated system (see Child).
• struct MotorTorqueBounds — admissible motor torque interval at a given motor speed
• struct Track — A rigid track (continuous belt) of an articulated system, defined by a URDF <track> element.
• struct TrackDefinition — Internal: a <track> as read by the URDF loader, with its belt geometry already added to the link.
• struct TrackDrive — A joint that moves the belt of a track: it adds gain * (joint velocity) to the belt speed.
• struct VisObject — visualization definition created by a user or URDF

Terrain

• class DeformableTerrain — A triangulated soil surface with no particles or soil inertia.
• class Ground — A static infinite ground plane (half-space) with normal +z. Create it with World::addGround().
• class HeightMap — A static terrain defined by a regular grid of heights (create it with World::addHeightMap()).

Deformable objects

• class DeformableObject — A position-based (XPBD/PBD) deformable body made of particles connected by distance constraints (mesh edges plus optional extra edges) and, for cloth, bending constraints between adjacent triangles.

Granular media

• class GranularPoolSleepController — Opt-in approximation for a settled pool.
• class GranularSystem — A discrete-element (DEM) system of spherical particles stepped as one object (create it with World::addGranularParticles() or World::addGranularBox()).

Constraints and tendons

• class CompliantLengthConstraint — A length constraint that acts as a linear spring (created by World::addCompliantWire()).
• class Constraints — Base class of world-level constraints (see LengthConstraint). Holds the name, visualization color and a mutex.
• class CustomLengthConstraint — A length constraint that applies a user-specified tension (see setTension(); created by World::addCustomWire()).
• struct EqualityConstraintDefinition — Description of an equality constraint inside an articulated system, as parsed from URDF.
• class LengthConstraint — Base class of the legacy distance constraints ("wires") between two points on two objects.
• struct MimicConstraint — Internal: a resolved mimic constraint between two one-degree-of-freedom joints.
• struct MimicConstraintDefinition — Description of a mimic constraint, as parsed from URDF (<mimic>) or MJCF (<equality><joint>): the follower joint's position is kept at multiplier * (leader position) + offset.
• class PinConstraint — Internal: a resolved point constraint between two bodies of one articulated system.
• struct PinConstraintDefinition — Description of a pin (point-to-point) constraint inside an articulated system, as parsed from URDF/MJCF.
• class StiffLengthConstraint — A length constraint enforced as a hard limit (created by World::addStiffWire()).
• class Tendon — A scalar transmission: routed spatial length or a weighted sum of scalar joints.
• class TendonCoupling — Constrains the length of one tendon to a polynomial of another tendon's length.

Contact and collision

• struct CollisionBodyHandle — Internal: per-body collision data registered with the contact engine (shape, owner, material).
• class Contact — A contact point between two collision bodies, as stored in Object::getContacts().

Sensors

• struct CameraFisheyeDistortion — OpenCV-fisheye (Kannala-Brandt) distortion coefficients k1..k4.
• struct CameraIntrinsics — Pinhole-style camera intrinsics in pixels.
• struct CameraLensModel — Lens description of a camera sensor: projection model, intrinsics and fisheye distortion.
• class DepthCamera — Depth camera simulated by CPU ray casting against the collision geometry of the world.
• class InertialMeasurementUnit — An ideal or stochastic six-axis IMU.
• class RGBCamera — Color camera sensor.
• class Sensor — Base class of all sensors attached to an ArticulatedSystem frame (RGBCamera, DepthCamera, InertialMeasurementUnit, SpinningLidar).
• class SensorSet — A named group of sensors that belongs to one body of an ArticulatedSystem (e.g., all sensors of one physical device).
• class SpinningLidar — Spinning (rotating-head) lidar simulated by CPU ray casting.

Server and visuals

• struct ArticulatedSystemVisual — Visual-only articulated system (no physics) streamed by RaisimServer.
• class BarChart — Bar chart (histogram) with one bar per named category.
• class Chart — Base class of the charts streamed by RaisimServer (TimeSeriesGraph, BarChart).
• struct HeightMapVisual — Visual-only height map (no physics) streamed by RaisimServer.
• struct InstancedVisuals — Many visual-only instances of one shape, drawn with per-instance pose, scale and a color interpolated between color1 and color2.
• struct PointCloud — Point cloud streamed by RaisimServer.
• struct PolyLine — Visual-only polyline streamed by RaisimServer.
• class TimeSeriesGraph — Line chart of one or more named series over time.
• struct VisualMesh — Visual mesh created by RaisimServer::addVisualMesh(), either from a file or from raw arrays.
• struct Visuals — Visual-only primitive (sphere, box, cylinder, capsule, arrow or mesh) streamed by RaisimServer.

Math

• class BlockRef — Fixed-size n x m block view of a matrix, returned by Mat::segment(), Mat::head(), Mat::tail(), Mat::block() and the corner accessors.
• class ColRef — View of one column (n elements) of a matrix, returned by Mat::col().
• class CrossProduct — Lazy 3D cross product u x v of two 3x1 expressions, returned by cross() on a 3D vector.
• class DiagonalRef — Placeholder proxy for a matrix diagonal. It has no accessors and no Mat method returns it.
• class Div_SL_op — Lazy scalar / matrix element-wise expression (Div_SL_op), returned by operator/(double, MatExpr).
• class ElementRef — Proxy returned by the comma initializers (Mat::operator<<() and DynamicArray::operator=(double)); each following , value writes the next element in linear (column-major) order.
• class Mat — Fixed-size n x m matrix of doubles, stored column-major: element (i, j) is v[i + j * n].
• class MatExpr — CRTP base of all fixed-size matrix types and expression templates (Mat, the block views and the lazy arithmetic expressions).
• class Prod_op — Lazy matrix-product expression returned by operator* on two fixed-size matrix expressions.
• class Prod_op< Mat< 4, 4 >, Mat< 4, 4 > > — Specialization for the 4x4 by 4x4 product: it is evaluated eagerly (with Eigen) when constructed and stores the result.
• class RowRef — View of one row (m elements) of a matrix, returned by Mat::row().
• class SkewRef — Proxy returned by skew() on a 3D vector.
• class Sub_SL_op — Lazy scalar - matrix expression (Sub_SL_op), returned by operator-(double, MatExpr).
• class Transpose — Lazy expression for the transpose of a fixed-size matrix expression, returned by Mat::transpose().

Namespaces

• raisim::contact
  • BisectionContactSolver — RaiSim's iterative contact solver: a Gauss-Seidel-style sweep over the constraint rows in which each frictional contact is solved with a bisection method.
  • Single3DContactProblem — One constraint row (contact, joint limit, wire or pin) of the contact problem that the World solves each step; World::getContactProblem() exposes the list.
  • TerrainContactLaw — Internal, frozen material history for one mesh quadrature contact during the coupled solve. sinkage is the body's step-start depth below the rest surface; it is below plastic while the body still…
  • TerrainContactSolveState — Internal per-solve constants and normal pressure evaluations for an area contact.
• raisim::contact::rank — Values of Single3DContactProblem::rank: the kind of constraint a problem row represents.
• raisim::ControlMode — Actuation modes of an ArticulatedSystem (see ArticulatedSystem::setControlMode()).
• raisim::mesh_files
• raisim::mjcf
  • LoadFromMjcf — Internal: MJCF body parser that fills an ArticulatedSystem. Used by the MJCF world loader.
  • MjcfCompilerSetting — Internal: settings of the MJCF compiler element.
• raisim::rscene
  • Asset — An asset record: the default material of objects placed from it. It creates nothing.
  • Camera — A camera looks along its local +X axis with local +Z up.
  • CoacdSettings — CoACD convex decomposition settings for MeshCollision::Convexify (see raisim::CoacdOptions).
  • Color — An RGBA color with components in [0, 1].
  • ContactMaterial — A contact_material record: the material-pair properties of two RaiSim contact materials, passed to World::setMaterialPairProp() in this order.
  • InstancedVisual — A batch of instanced visuals (render only; no physics).
  • Light — A light (render settings, interpreted by a viewer).
  • LocalFog — A spherical volume of local fog (render settings). Only enabled volumes are loaded.
  • Material — A render material.
  • Object — A scene object (one object record).
  • Physics — Solver settings from the time_step, gravity, solver and contact_material records. applyPhysics() applies them.
  • Quat — A quaternion stored as (w, x, y, z).
  • Record — One line of the file.
  • ReflectionProbe — A reflection probe (render settings). Only enabled probes are loaded.
  • Scene — A parsed .rscene file (see load()).
  • Terrain — A sampled height-map terrain region.
  • TerrainFoliageLayer — A foliage layer scattered over a terrain by a viewer (terrain_foliage_layer).
  • TerrainSplatLayer — A per-sample weight map that blends one terrain texture layer (terrain_splat_layer).
  • TerrainTexture — A terrain texture layer (render settings, interpreted by a viewer).
  • TextureTransform — A texture's UV transform (scale, offset, rotation in radians).
  • Transform — A node transform as stored in the file.
  • Vec2 — A 2D vector (x, y).
  • Vec3 — A 3D vector (x, y, z).
  • VisualSettings — Settings of a visual a viewer draws for an object (the object record's visual* keys).
  • Wire — A distance constraint between two bodies (wire record), added with World::addSpatialTendon() as Engine 2 does.
  • WorldReport — Bodies created by addToWorld.
• raisim::server
  • BoundedWriter — Internal: write position in a bounded buffer.
  • DeserializationError — A malformed bounded wire payload.
  • ReadCursor — Internal: bounds-checked reader over an incoming wire payload.
  • SceneFileServer — Internal: serves the files of a RaiSim Engine scene to a viewer.
  • SerializationError — Internal: thrown when a server frame would overflow its BoundedWriter.
  • TendonVisualInstance — Renderer-independent transform of one tendon segment, expressed for a radius-one, length-one cylinder along Z.
• raisim::server::scene_files
  • Hasher — 64-bit content hash of a file, computed incrementally.
• raisim::Shape — Geometry shape types.
• raisim::tcp
• raisim::urdf
  • LoadFromURDF2 — Internal: URDF parser that fills an ArticulatedSystem. Users should use the ArticulatedSystem/World API instead.
  • UrdfBody — Internal: URDF visual or collision element parsed by LoadFromURDF2.
  • UrdfJoint — Internal: URDF joint element parsed by LoadFromURDF2.
  • UrdfLink — Internal: URDF link parsed by LoadFromURDF2.
  • UrdfLinkInertial — Internal: URDF inertial element parsed by LoadFromURDF2.
  • UrdfMaterial — Internal: URDF material (name and color) parsed by LoadFromURDF2.

raisin

The namespace page documents the free functions, enums, type aliases and variables of raisin.

Renderer A–L

• struct AdditionalLight — Lightweight imported or viewer light used for extra fill/rim lighting.
• struct BakedIrradianceGrid — Regular 3D grid of irradiance probes spanning an axis-aligned box.
• struct Bc7TextureStorageResult — Outcome of compressRgbTextureBc7(); all zero when the texture was left unchanged.
• class Camera — Camera for offscreen rendering and interaction.
• class CameraFrustum — Visual helper that renders camera frustum edges.
• class CloudTextures — CloudTextures owns the GPU textures used by the cloud rendering pipeline: baseTex: 3D RGBA8 Worley/Perlin noise (128^3) for the volumetric path detailTex: 3D RGBA8 Worley noise (32^3) for the…
• class CoordinateFrame — Render helper for visualizing multiple coordinate frames.
• struct DebugPassCapture — One debug view returned by RayraiWindow::captureDebugPasses() (final image, base color, normals, shadow terms, AO, fog, ...).
• struct DirectionalShadowCascade — One cascade of a DirectionalShadowCascadePlan. Distances are view distances in metres.
• struct DirectionalShadowCascadePlan — Directional-light cascade layout for a camera (RayraiWindow::planDirectionalShadowCascades()), derived from the RenderQualitySettings::directionalShadowCascade* fields.
• struct DynamicQualityRecommendation — Quality reduction suggested from measured pass timings (RayraiWindow::recommendDynamicQuality()). Never applied automatically.
• struct EnvironmentSidecarSettings — Optional environment/lighting overrides from a scene's environment sidecar JSON (<scene>.rayrai_environment.json, see RayraiWindow::loadEnvironmentSidecar()).
• struct ExposureRecommendation — Bounded exposure suggestion derived from RgbaLuminanceMetrics (RayraiWindow::recommendExposure()). Never applied automatically.
• struct FoliageGeometryAtlasOptions — Options for buildFoliageGeometryAtlasForMeshes().
• struct FoliageGeometryAtlasResult — Outcome of buildFoliageGeometryAtlasForMeshes().
• class FoliageMeshLodBaker — A textured 3D foliage LOD reconstructed from six or ten source-mesh captures.
• struct FoliageTextureAtlasOptions — Options for buildFoliageTextureAtlasForMeshes().
• struct FoliageTextureAtlasResult — Outcome of buildFoliageTextureAtlasForMeshes().
• struct GeometryRefractionDiagnostics — State of the geometry-refraction tracer after the most recent frame (RayraiWindow::geometryRefractionDiagnostics()).
• struct GeometryRefractionSamplingStatistics — Per-pixel sample statistics of the geometry-refraction history (RayraiWindow::geometryRefractionSamplingStatistics()).
• class InstancedVisuals — Many copies of one shape or mesh drawn with GPU instancing.
• struct IrradianceVolume — Oriented box that adds a constant diffuse irradiance to PBR surfaces inside it.
• class LensDropletCompositeSystem — Owns the FBO + composite texture used by the lens-droplet pass. RGBA16F target, sized to the scene viewport.
• class Light — Simple light with optional shadow map support.
• struct LightInfluenceRange — Distance window over which a local light's contribution is faded out and then culled (world units, measured from the light position).
• struct LocalFogVolume — Spherical local fog region evaluated in the post-process pass.

Renderer M–P

• class Material — A general-purpose material class supporting PBR, textured, and simple color models.
• struct MaterialTextureBudgetRecommendation — Texture-memory fallback suggestion (RayraiWindow::recommendMaterialTextureBudget()). Never applied automatically and never unloads textures.
• struct MeshPreprocessCacheStats — Process-wide counters of cache activity (see meshPreprocessCacheStatsSnapshot()).
• struct MeshPreprocessMetadata — Summary of a loaded mesh list used to skip re-scanning geometry.
• struct PbrEnvironment — Image-based lighting environment bundle.
• struct PhysicsLinkPose
• struct PhysicsMeshSnapshot — Complete dynamic mesh.
• struct PhysicsObjectSnapshot
• struct PhysicsRenderDescription
• struct PhysicsShapeSnapshot — Persistent geometry and local visual transform, shared across pose-only frames.
• struct PhysicsSnapshot — Immutable, complete frame. Hold its shared owner while publishing or consuming it.
• class PhysicsSnapshotCapture — Physics-thread capture, without GL or locks: the caller protects the World.
• struct PhysicsTendonSnapshot
• class PointCloud — Simple point cloud renderer.
• struct ProjectedDecal — Screen-space box decal blended over the opaque scene in the post-process pass.

Renderer R

• class RaisimObject — Render state of one raisim::Object, built from physics snapshots.
• class RayraiGlobalAsset — A caching asset manager for 3D models and primitive meshes.
• class RayraiWindow — Offscreen renderer and visual scene manager for raisim.
• struct ReflectionProbe — Static local reflection probe registered with RayraiWindow::addReflectionProbe().
• struct ReflectionProbeBlend — Result of RayraiWindow::selectReflectionProbeBlend() for one sample position.
• struct ReflectionProbeCaptureFrame — Camera basis used to capture one cubemap face (RayraiWindow::reflectionProbeCaptureFrame()).
• struct ReflectionProbeCaptureSettings — Explicit static reflection-probe capture settings.
• struct ReflectionProbeDebugItem — Per-probe entry of a ReflectionProbeDebugView.
• struct ReflectionProbeDebugOverlaySummary — CPU summary shown by the optional reflection-probe debug overlay (RayraiWindow::reflectionProbeDebugOverlaySummary()).
• struct ReflectionProbeDebugView — Probe selection details at one position (RayraiWindow::reflectionProbeDebugView()).
• struct ReflectionProbeFilterSettings — Explicit CPU filtering settings for captured local reflection probes.
• struct ReflectionProbePlacementSuggestion — Probe placement suggested from scene bounds (RayraiWindow::suggestReflectionProbePlacementFromSceneBounds()).
• struct ReflectionProbeSidecarProbe — One probe entry read from a scene's reflection-probe sidecar JSON (<scene>.rayrai_probes.json, see RayraiWindow::loadReflectionProbeSidecar()).
• struct ReflectionProbeSidecarSettings — Optional quality overrides from the reflection-probe sidecar's "quality" block.
• struct RenderOverrides — Override shaders and rendering toggles when using external cameras.
• struct RenderPassAccounting — Estimated per-frame render passes for the current settings (RayraiWindow::estimateRenderPassAccounting()). CPU estimate only; no GPU timing.
• struct RenderPassTiming — GPU time of one named render pass (from captureRenderPassTimings()).
• struct RenderQualitySettings — Explicit runtime quality settings for viewer rendering.
• struct RgbaCalibrationMetrics — Aggregate patch errors from RayraiWindow::analyzeRgbaCalibrationPatches(); averages are over valid patches only.
• struct RgbaCalibrationPatch — Rectangular reference patch for RayraiWindow::analyzeRgbaCalibrationPatches().
• struct RgbaCalibrationPatchResult — Measurement of one RgbaCalibrationPatch; all colors are display-space RGB in [0, 1].
• struct RgbaCalibrationRecommendation — Output transform suggested from calibration patches (RayraiWindow::recommendCalibrationOutputTransform()). Never applied automatically.
• struct RgbaLuminanceHistogram — Display-space luminance histogram of an RGBA8 image (RayraiWindow::analyzeRgbaLuminanceHistogram()).
• struct RgbaLuminanceMetrics — Display-space luminance statistics of an RGBA8 image (RayraiWindow::analyzeRgbaLuminance()).
• struct RgbaOutputTransform — CPU color transform for screenshots/reports (RayraiWindow::transformRgbaForOutput()).
• struct RsceneRenderSettings — Render settings stored in a scene's environment, weather and rayrai_render records, with RaiSim Engine 2's defaults for what the file omits.
• struct RsceneVisuals — Viewer objects created for a scene (see rsceneVisuals()).

Renderer S–T

• struct SceneImportReport — Outcome of RayraiWindow::importVisualScene() (mesh load and optional light import).
• class ScopedActiveTexture — RAII guard for glActiveTexture.
• class ScopedCapability — RAII guard that enables or disables a GL capability and restores its previous state.
• class ScopedClearColor — RAII guard for glClearColor.
• class ScopedDepthFunc — RAII guard for glDepthFunc.
• class ScopedDepthMask — RAII guard for glDepthMask.
• class ScopedDrawBuffer — RAII guard that sets a single draw buffer and restores up to eight previous draw buffers.
• class ScopedFramebuffer — RAII guard that binds a framebuffer and restores the previous binding of the same target.
• class ScopedPixelUnpackBufferZero — Binds GL_PIXEL_UNPACK_BUFFER to 0 for the guard's lifetime, restoring the previous binding on destruction.
• class ScopedReadBuffer — RAII guard for glReadBuffer.
• class ScopedTightPixelUnpack — RAII guard that sets tightly packed GL unpack state (alignment 1, no row length/skips) and restores it.
• class ScopedViewport — RAII guard for glViewport.
• class ScreenSpaceDepthCopySystem — Owns a depth-texture copy of the opaque scene depth for transparent material effects that need to compare against already-rendered geometry without sampling the active depth attachment.
• class ScreenSpaceRefractionSystem — Owns the opaque-color copy texture used by the screen-space refraction lookup. Reallocated automatically when the scene target size changes.
• struct ShaderWarmupDiagnostics — Built-in shader compile statistics (RayraiWindow::shaderWarmupDiagnostics()).
• struct ShadowAtlasPlan — Row-packed tile layout of the additional-light shadow atlas (RayraiWindow::planAdditionalShadowAtlas()).
• struct ShadowAtlasTile — One tile of a ShadowAtlasPlan. Pixel values are atlas texels.
• struct ShadowDebugOverlaySummary — CPU summary shown by the optional shadow debug overlay (RayraiWindow::shadowDebugOverlaySummary()).
• class SkyAtmosphereSystem — Owner of the Hillaire sky-atmosphere LUT pipeline (transmittance, multi-scattering, sky-view, aerial-perspective volume).
• struct SkyVisibilityGrid — Static, scalar environment visibility, x fastest, then y, then z. 1 = open environment; 0 = occluded.
• class StreamedFoliage — Owns per-cell/species batches while the viewer retains shared mesh/texture assets.
• class StreamedTerrain — A complete visual terrain cover with small patches near observers and coarse patches toward the horizon.
• struct SupersampledCapture — Result of RayraiWindow::captureSupersampledRgba(): a frame rendered at scale times the camera resolution and box-filtered back down.
• class TerrainPatch — CPU terrain geometry, sampled once at full resolution and decimated per patch.
• struct TerrainPatchLevel — One level of detail of a TerrainPatch.
• struct TerrainPatchRegion — One quadtree node of a terrain layout.
• class TextureBindingCacheView — Internal: hot-loop handle to the calling thread's texture caches.
• struct TransparentDrawDebugView — Transparent-pass state and draw order for a camera (RayraiWindow::transparentDrawDebugView()). Diagnostic only.
• struct TransparentDrawItem — One transparent draw in a TransparentDrawDebugView.

Renderer V–W

• class Visuals — Renderable visual object not owned by raisim::World.
• struct WeatherDiagnostics — Resolved weather state for the current frame (RayraiWindow::weatherDiagnostics()).
• struct WeatherSettings — Weather state applied on top of the renderer (RayraiWindow::setWeatherSettings()).
• struct WeatherSidecarSettings — Weather state read from a scene's weather sidecar JSON (<scene>.rayrai_weather.json, see RayraiWindow::loadWeatherSidecar()).
• struct WeatherSkyEnvironment — Sky cubemaps baked from the current weather (RayraiWindow::generateWeatherSkyEnvironment()).
• class WeightedOitSystem — Owns the GL resources for weighted-blended order-independent transparency (Meshkin / McGuire-Bavoil): an RGBA16F accumulation target, an R16F reveal target, an RGBA8 opaque-color target, and a…
• struct WorldCellBounds — Axis-aligned rectangle on the horizontal (x,y) plane.
• struct WorldCellKey — Integer cell coordinate; (0,0) is the cell at the world's minimum corner.
• struct WorldCellPlan — Result of WorldCells::plan().
• class WorldCells — Bounded cell residency planning, independent of rendering and physics.
• struct WorldInterest — A point that wants nearby cells resident (camera, sensor or body).

Namespaces

• raisin::assimp
  • AsyncModelLoadResult — Assimp import produced by loadModelSceneAsync(), before GL resources exist.
  • FallbackMaterial — Material read from an OBJ's sibling .mtl file, used when Assimp provides none.
  • ModelSourceFile — A file a model import read (or looked for), as it was at that point.
• raisin::color
• raisin::lidar_grid
  • RasterBounds — Angular edges of a raster whose pixel centres are the lidar sample angles.
• raisin::rayrai
• raisin::rayrai::sdl
• raisin::tcp_viewer
  • BodyFramePose — One body frame in world coordinates, independent of its visual geometry offsets.
  • BufferReader — Lightweight reader for binary message buffers.
  • BufferWriter — Lightweight writer for binary message buffers.
  • ClientRequest — A single pending client request to be flushed on the next update.
  • ContactSample — Contact sample for contact visualization.
  • DeformableMesh — Dynamic triangle mesh data for a deformable object.
  • HeightmapMeshData — CPU geometry produced for a heightmap received by the TCP viewer.
  • HeightmapPlane — Heightmap plane data for mesh updates.
  • InstancedEntry — State associated with a remote instanced visual set.
  • ObjectListItem — Entry for selectable object list UI.
  • PendingSensorUpdate — Pending sensor update to be applied on the viewer side.
  • RemotePointCloud — State associated with a remote point cloud.
  • RemoteScene — Client-side representation of a remote raisim scene.
  • RemoteSceneState — Persistent client-side state mirrored from the remote server.
  • SceneFileBlock — The scene-file block of one server response.
  • SceneFileEntry — One file of the server's scene.
  • SceneSync — Finds, downloads and loads the server's scene for one viewer connection.
  • SelectedActuatorInfo — An actuator (a motor with its gear) of a selected articulated system: what defines its motor's operating region (raisim::ActuatorDefinition) and its state over the last simulation step…
  • SelectedObjectInfo — Details about a selected object from the remote scene.
  • SensorInfo — Metadata for a remote sensor.
  • TcpClient — Cross-platform TCP client for the Rayrai/RaisimServer protocol.
  • TcpMeshBatch — Instanced mesh batch synthesized from repeated TCP visual entries.
  • ViewerCommand — A server-originated command that must be completed by the viewer application.
  • VisualEntry — State associated with a remote visual object.
  • VisualEntrySnapshot — Copy of a VisualEntry together with its object tag and body index.
• raisin::texture — Free-function texture creators decoupled from RayraiWindow.

Global namespace

• struct ExampleApp — Minimal SDL/ImGui wrapper for RayraiWindow examples.
• class OpenGLMesh — Simple OpenGL mesh with indexed geometry and optional textures.
• class Shader — Minimal GLSL shader wrapper.
• struct Texture — Texture descriptor for mesh materials.
• struct Vertex — Vertex attributes used by OpenGLMesh.