| ►NTgl | [AI] Namespace containing all classes related to the 3D graphics abstraction/rendering engine |
| CCamera | [AI] Represents a viewpoint in the 3D scene |
| CDevice | [AI] Represents a rendering device/context for the Tgl renderer |
| CDeviceDirect3DCreateData | [AI] Contains Direct3D-specific data needed to create a rendering device |
| CDeviceDirectDrawCreateData | [AI] Contains DirectDraw-specific params for creating a rendering device |
| CGroup | [AI] Scene graph node for parental transforms/color/material/texture; can hold meshes or other groups |
| CLight | [AI] Represents a source of lighting in the 3D scene |
| CMesh | [AI] Represents a renderable 3D mesh |
| CMeshBuilder | [AI] Builder class for assembling mesh data and extracting mesh objects |
| CObject | [AI] Utility for mesh data construction and conversion. [AI] |
| CPaletteEntry | [AI] Represents a single color entry in a palette |
| CRenderer | [AI] Main interface/factory for rendering resources and scene graphs |
| CTexture | [AI] Represents a GPU or system memory texture for use in rendering |
| CView | [AI] Represents a rendering viewport and drawing context |
| ►NTglImpl | [AI] Forward declaration for Direct3DRMTexture interface [AI] |
| CCameraImpl | [AI] Implementation of Tgl::Camera, wraps a Direct3DRMFrame2 and provides transformation management [AI] |
| CDeviceImpl | [AI] Implements the Tgl::Device interface, encapsulates Direct3DRMDevice2 and provides rendering device operations |
| CGroupImpl | [AI] Implementation of Tgl::Group, wraps a Direct3DRMFrame2 and provides scene graph and transformation features [AI] |
| CLightImpl | [AI] Implementation of Tgl::Light, wraps a Direct3DRMFrame2 and color data [AI] |
| CMeshBuilderImpl | [AI] Implements Tgl::MeshBuilder, manages mesh construction and provides the interface for creating geometry buffers [AI] |
| ►CMeshImpl | [AI] Implementation of Tgl::Mesh, manages a mesh object and geometry data with group index [AI] |
| CMeshData | [AI] Holds D3DRMMesh pointer and group index for referencing geometry [AI] |
| CRendererImpl | [AI] Implements Tgl::MeshBuilder; facilitates mesh construction [AI] |
| CTextureImpl | [AI] Implements Tgl::Texture using a Direct3DRMTexture; provides upload and palette control [AI] |
| CTglD3DRMIMAGE | [AI] Simple wrapper for D3DRMIMAGE; manages pixel buffer and palette for Direct3DRM textures [AI] |
| CViewImpl | [AI] Implementation of Tgl::View backed by Direct3DRMViewport, handles scene rendering, picking, and camera control |
| C_D3DBRANCH | |
| C_D3DCLIPSTATUS | |
| C_D3DCOLORVALUE | |
| C_D3DDeviceDesc | |
| C_D3DExecuteBufferDesc | |
| C_D3DEXECUTEDATA | |
| C_D3DFINDDEVICERESULT | |
| C_D3DFINDDEVICESEARCH | |
| C_D3DHVERTEX | |
| C_D3DINSTRUCTION | |
| C_D3DLIGHT | |
| C_D3DLIGHT2 | |
| C_D3DLIGHTDATA | |
| C_D3DLIGHTINGCAPS | |
| C_D3DLIGHTINGELEMENT | |
| C_D3DLINE | |
| C_D3DLINEPATTERN | |
| C_D3DLVERTEX | |
| C_D3DMATERIAL | |
| C_D3DMATRIX | |
| C_D3DMATRIXLOAD | |
| C_D3DMATRIXMULTIPLY | |
| C_D3DPICKRECORD | |
| C_D3DPOINT | |
| C_D3DPrimCaps | |
| C_D3DPROCESSVERTICES | |
| C_D3DRECT | |
| C_D3DRMBOX | |
| C_D3DRMIMAGE | |
| C_D3DRMLOADMEMORY | |
| C_D3DRMLOADRESOURCE | |
| C_D3DRMPALETTEENTRY | |
| C_D3DRMPICKDESC | |
| C_D3DRMPICKDESC2 | |
| C_D3DRMPMESHLOADSTATUS | |
| C_D3DRMQUATERNION | |
| C_D3DRMRAY | |
| C_D3DRMVECTOR4D | |
| C_D3DRMVERTEX | |
| C_D3DSPAN | |
| C_D3DSTATE | |
| C_D3DSTATS | |
| C_D3DSTATUS | |
| C_D3DTEXTURELOAD | |
| C_D3DTLVERTEX | |
| C_D3DTRANSFORMCAPS | |
| C_D3DTRANSFORMDATA | |
| C_D3DTRIANGLE | |
| C_D3DVECTOR | |
| C_D3DVERTEX | |
| C_D3DVIEWPORT | |
| C_D3DVIEWPORT2 | |
| C_DDBLTBATCH | |
| C_DDBLTFX | |
| C_DDCAPS | |
| C_DDCAPS_DX3 | |
| C_DDCOLORCONTROL | |
| C_DDCOLORKEY | |
| C_DDOVERLAYFX | |
| C_DDPIXELFORMAT | |
| C_DDSCAPS | |
| C_DDSURFACEDESC | |
| C_DDVIDEOPORTBANDWIDTH | |
| C_DDVIDEOPORTCAPS | |
| C_DDVIDEOPORTCONNECT | |
| C_DDVIDEOPORTDESC | |
| C_DDVIDEOPORTINFO | |
| C_DDVIDEOPORTSTATUS | |
| C_DIDATAFORMAT | |
| C_DIMOUSESTATE | |
| C_DIOBJECTDATAFORMAT | |
| C_DPADDRESS | |
| C_DPCOMPORTADDRESS | |
| C_DPLDATA_PLAYERGUID | |
| C_DPLDATA_PLAYERSCORE | |
| C_DPLMSG_GENERIC | |
| C_DPLMSG_GETPROPERTY | |
| C_DPLMSG_GETPROPERTYRESPONSE | |
| C_DPLMSG_SETPROPERTY | |
| C_DPLMSG_SETPROPERTYRESPONSE | |
| C_DS3DBUFFER | |
| C_DS3DLISTENER | |
| C_DSBCAPS | |
| C_DSBPOSITIONNOTIFY | |
| C_DSBUFFERDESC | |
| C_DSCAPS | |
| C_DSCBCAPS | |
| C_DSCBUFFERDESC | |
| C_DSCCAPS | |
| C_DSETUP_CB_FILECOPYERROR | |
| C_DSETUP_CB_UPGRADEINFO | |
| CAct1State | [AI] Holds state and transient gameplay data for the first act on Lego Island |
| ►CAct2Actor | [AI] Act2 mission-specific actor class, with custom state and animation handling for Act 2 of the story mode |
| CLocation | [AI] Encapsulates the positional and directional data for potential target locations in the Act 2 sequence |
| CAct2Brick | [AI] Represents a special 'brick' object in the LEGO Island "Act 2" sequence, derived from LegoPathActor |
| CAct2GenActor | [AI] An actor that extends LegoPathActor with special collision logic for "Act2Gen" scene logic |
| CAct2PoliceStation | [AI] Represents the Act 2 Police Station entity in LEGO Island |
| CAct3 | [AI] Controls all main logic and progression of Act 3 in LEGO Island, including objects, cutscenes, enemy and player actors, and event scheduling |
| CAct3Actor | [AI] Represents a generic animatable actor in Act 3, supporting path following and custom animation triggers |
| CAct3Ammo | Represents an ammo object (pizza or donut) used in Act 3 gameplay sequence |
| CAct3Brickster | [AI] Represents the Brickster actor in Act 3, with AI and scene logic for stealing pizzas and causing endgame actions |
| ►CAct3Cop | [AI] Represents a police officer actor in Act 3, supporting specific cop AI actions, path findings, and collision logic |
| CAct3CopDest | [AI] Structure containing cop destination information for patrol paths, boundaries, and navigation points |
| CAct3List | [AI] A custom intrusive list for handling state machine or scheduled actions/events during Act 3 sequences |
| CAct3ListElement | [AI] Represents an element in a custom list for activity scripting and audio/animation event queueing in Act 3 |
| CAct3Shark | [AI] Represents the shark actor for Act 3 of the LEGO Island game |
| CAct3State | [AI] Holds persistent state and status variables for Act 3 mission, saved between world reloads and possibly serialized |
| CAmbulance | Main game logic and control entity for the Ambulance gameplay activity |
| CAmbulanceMissionState | Holds state and scoring information for the Ambulance mission |
| CAnimInfo | [AI] Describes a specific animation, containing animation parameters, model list, and related metadata used by the animation system |
| CAnimState | [AI] Persistent serializable animation state for resuming animations and restoring global animation progress |
| CBeachHouseEntity | [AI] Entity for the Beach House building in LEGO Island |
| CBike | [AI] Represents the player's bicycle vehicle in LEGO Island, allowing for in-world interactions such as riding, honking the horn, and displaying dashboard UI |
| CBoundingBox | [AI] Represents an axis-aligned bounding box in 3D space, using minimum and maximum points |
| CBoundingSphere | [AI] Represents a bounding sphere in 3D space with center and radius |
| CBuildingEntity | [AI] Represents an entity corresponding to a building within the LEGO Island game world |
| CBumpBouy | [AI] Represents a bumpable buoy in the world that handles user interactions, specifically the Jetski click event in LEGO Island's race sequence |
| CCAboutDialog | [AI] Dialog for the application's About box |
| CCameraLocationVariable | [AI] Variable for updating camera location and POV (field of view/frustum settings) for navigation and scene rendering |
| CCarRace | Implements the LEGO Island car race game mode |
| CCarRaceState | The state object used for the car race mini-game |
| CCaveEntity | [AI] Entity for the Cave building in LEGO Island |
| CCConfigApp | |
| CCConfigCommandLineInfo | [AI] Specialized command line parser for the configuration application |
| CCMainDialog | The main dialog window for the LEGO Island configuration program (config.exe) |
| CColorStringStruct | Key-value pair tying a ROI color key name to a LEGO color string |
| CCoreSetCompare | Comparison functor for MxCore* pointers used by MxCoreSet to ensure a consistent ordering |
| CCursorVariable | [AI] Variable to represent game cursor (pointer) state |
| CCustomizeAnimFileVariable | [AI] MxVariable subclass used to represent and propagate changes to the character customization animation file |
| CDeque | [AI] Custom wrapper around std::deque providing consistent allocator usage and swap semantics |
| ►CDeviceModesInfo | [AI] Contains detailed information about a Direct3D device's supported display modes and capabilities |
| CMode | [AI] Represents a specific display mode supported by the device (width, height, bits per pixel) |
| CDICONDITION | |
| CDICONSTANTFORCE | |
| CDICUSTOMFORCE | |
| CDIDEVCAPS | |
| CDIDEVCAPS_DX3 | |
| CDIDEVICEINSTANCE_DX3A | |
| CDIDEVICEINSTANCE_DX3W | |
| CDIDEVICEINSTANCEA | |
| CDIDEVICEINSTANCEW | |
| CDIDEVICEOBJECTDATA | |
| CDIDEVICEOBJECTINSTANCE_DX3A | |
| CDIDEVICEOBJECTINSTANCE_DX3W | |
| CDIDEVICEOBJECTINSTANCEA | |
| CDIDEVICEOBJECTINSTANCEW | |
| CDIEFFECT | |
| CDIEFFECTINFOA | |
| CDIEFFECTINFOW | |
| CDIEFFESCAPE | |
| CDIENVELOPE | |
| CDIJOYSTATE | |
| CDIJOYSTATE2 | |
| CDIPERIODIC | |
| CDIPROPDWORD | |
| CDIPROPHEADER | |
| CDIPROPRANGE | |
| CDIRAMPFORCE | |
| CDirect3DDeviceInfo | [AI] Encapsulates Direct3D device enumeration information and capability structures |
| CDoors | [AI] Represents a special LegoPathActor controlling the animation and logic of a pair of doors, including opening and closing transitions |
| CDPACCOUNTDESC | |
| CDPCAPS | |
| CDPCHAT | |
| CDPCOMPOUNDADDRESSELEMENT | |
| CDPCREDENTIALS | |
| CDPLAPPINFO | |
| CDPLCONNECTION | |
| CDPMSG_ADDGROUPTOGROUP | |
| CDPMSG_ADDPLAYER | |
| CDPMSG_ADDPLAYERTOGROUP | |
| CDPMSG_CHAT | |
| CDPMSG_CREATEPLAYERORGROUP | |
| CDPMSG_DELETEPLAYER | |
| CDPMSG_DESTROYPLAYERORGROUP | |
| CDPMSG_GENERIC | |
| CDPMSG_GROUPADD | |
| CDPMSG_SECUREMESSAGE | |
| CDPMSG_SETPLAYERORGROUPDATA | |
| CDPMSG_SETPLAYERORGROUPNAME | |
| CDPMSG_SETSESSIONDESC | |
| CDPMSG_STARTSESSION | |
| CDPNAME | |
| CDPSECURITYDESC | |
| CDPSESSIONDESC | |
| CDPSESSIONDESC2 | |
| CDuneBuggy | [AI] Represents the player-controllable dune buggy vehicle in LEGO Island, inheriting movement and interaction logic from IslePathActor |
| CEdgeReference | [AI] Associates a named edge (string) to a LegoPathBoundary, used within skeleton kick phases to assign kick behavior to boundaries |
| CElevatorBottom | [AI] This class represents the "Elevator Bottom" area in the LEGO Island game |
| CExtra | [AI] Items related to the Extra string of key-value pairs found in MxOb |
| CFlagBitfield | [AI] Union that provides a convenient bit field view of a byte for flag manipulation |
| CFLIC_CHUNK | [AI] Represents a generic chunk header in a FLIC animation file |
| CFLIC_FRAME | [AI] Structure describing the header of a FLIC animation frame, used to organize frame subchunks and per-frame metadata |
| CFLIC_HEADER | [AI] Structure for the main header of a FLIC animation file |
| CGasStation | The in-game gas station (garage) area/world logic controller, handling all interactive gameplay, state transitions, and actors [AI] |
| CGasStationEntity | [AI] Entity for the Gas Station building in LEGO Island |
| CGasStationState | Maintains persistent, serializable state information for the gas station/garage area, including actor animation choice tracking [AI] |
| CHelicopter | [AI] Represents the flyable helicopter vehicle/path actor in the game, handling all in-game behaviors |
| CHelicopterState | [AI] Game state entity specialized for tracking Helicopter-related state during gameplay |
| CHistoryBook | [AI] The HistoryBook class represents the "History Book" world/scene shown in LEGO Island, displaying name, letter and score history |
| CHospital | [AI] Implements the main 3D area and logic flow for the Hospital location/scene in LEGO Island |
| CHospitalEntity | [AI] Entity for the Hospital building in LEGO Island |
| CHospitalState | [AI] State-holding class for the hospital area; persists area-specific progress and variables between game sessions |
| CInfocenter | [AI] Manages Infocenter world logic, UI, cutscenes, dialogue, and area transitions |
| CInfocenterDoor | [AI] Represents the door world for the information center, handling control, transitions and area switching when the player interacts with infocenter exits and arrows |
| CInfoCenterEntity | [AI] Entity for the Information Center building in LEGO Island |
| CInfocenterMapEntry | [AI] Maps a UI region in the Infocenter to a destination presenter for glow effects |
| CInfocenterState | [AI] Represents the state of the Infocenter area, storing scripts, dialogue playlists and UI letter presenters |
| CIsle | [AI] Represents the main overworld (LEGO Island) in the game, acting as the central hub and state machine for act transitions, minigames, elevators, mouse input, and audio/trigger/dialogue management |
| CIsleActor | [AI] Represents an actor instance specifically used within LEGO Island, extending LegoActor with notification and action-related behaviors |
| CIsleApp | [AI] Main application class for LEGO Island |
| ►CIslePathActor | Derived path actor type for handling player transitions and activities on LEGO Island |
| CSpawnLocation | Information for each player spawn location on LEGO Island |
| CJailEntity | [AI] Entity for the Jail building in LEGO Island |
| CJetski | [AI] Represents the jetski vehicle placed in the 3D world of LEGO Island |
| CJetskiRace | [AI] LEGO Island's "Jetski" racing game logic and presenter class, derived from LegoRace |
| CJetskiRaceState | [AI] Per-race state data and logic holder for JetskiRace, used for tracking player and AI standings, lap progress, and results |
| CJukeBox | [AI] Represents the Jukebox world environment in the game—handles display, state, notifications, player interaction, and control logic for the Jukebox area [AI] |
| CJukeBoxEntity | [AI] Represents the jukebox interactive entity in LEGO Island, handling click events, background music control, and script-driven animations for the jukebox object |
| CJukeBoxState | [AI] Represents the music selection state for the Jukebox in the game |
| ►CLego3DManager | [AI] Central class managing the LEGO Island 3D rendering subsystem |
| CCreateStruct | [AI] Construction parameters for initializing the 3D system |
| CLego3DSound | [AI] Implements 3D positional sound logic for LEGO Island using DirectSound 3D buffers |
| CLego3DView | [AI] Represents a 3D view for rendering and managing LEGO game objects in a 3D scene |
| CLego3DWavePresenter | [AI] Handles the presentation of 3D positional audio using DirectSound buffers within the LEGO Island engine |
| CLegoAct2 | Implements the world and game logic for Act 2 |
| CLegoAct2State | Represents the state object for Act 2 of the game |
| CLegoActionControlPresenter | [AI] Presenter for controlling action logic (e.g., invoking named actions such as "RUN", "EXIT") through parsed SI script extra data |
| CLegoActor | [AI] Represents an actor (character) entity in the LEGO Island 3D world, providing specific actor logic, such as sound, camera, and identity |
| ►CLegoActorInfo | [AI] Contains information about a single LEGO actor/character, including its name, head/part types, color/texture indices, and runtime pointers to objects |
| CPart | [AI] Describes a part/slot of a LEGO actor (e.g |
| CLegoActorLOD | [AI] Describes a single Level-of-Detail (LOD) variant for an actor part, including bounds and orientation info |
| CLegoActorPresenter | [AI] Handles presentation logic specific to LegoActor entities, such as their instantiation, animation tickling, state-managed updates, and parsing script-based actions |
| CLegoAnim | [AI] Root class for all node-based animation blending/structure |
| CLegoAnimActor | [AI] Path-based actor which supports skeletal/mesh animation via an animation tree and multiple animation to mesh mappings |
| CLegoAnimActorEntry | [AI] Describes a single actor or model referenced by an animation |
| CLegoAnimActorStruct | [AI] Holds per-animation instance data for a LegoAnimActor |
| ►CLegoAnimationManager | [AI] Animation manager handling all world and character animation state, loading, and logic for extras and transitions |
| CCharacter | [AI] Static definition of a character, its animation settings, flags, and world identity |
| CExtra | [AI] Tracks a currently active extra (non-player) actor in the world, with associated parameters |
| CVehicle | [AI] Static definition of a vehicle, including its name and state flags |
| CLegoAnimKey | [AI] Represents a single generic animation keyframe, containing timing and per-keyframe flags |
| CLegoAnimMMPresenter | [AI] Composite presenter class that manages a multi-media animation sequence |
| CLegoAnimNodeData | [AI] Holds per-node animation data for a model's animation tree |
| CLegoAnimPresenter | [AI] Handles playback and synchronization of animated LEGO objects, including variable substitution, ROI mapping, and direct control over animation tick cycle |
| CLegoAnimPresenterSetCompare | [AI] Comparison functor used to order LegoAnimPresenter pointers for set containers, using their pointer value |
| CLegoAnimScene | [AI] Represents an animation scene; possibly used for camera motion or global transforms |
| CLegoAnimStruct | [AI] Maps an ROI and index for animation nodes/actors |
| CLegoAnimStructComparator | [AI] Comparator for anim struct maps using string (char*) keys |
| CLegoAnimSubstComparator | [AI] Comparator for substition map lookups using string (char*) keys |
| CLegoBackgroundColor | Variable controlling the sky background color (HSV) and related light color in the game |
| CLegoBEWithFloat | [AI] Represents a path edge with extra float data and potential linkage (single-linked) |
| CLegoBEWithFloatComparator | [AI] Function object for comparing LegoBEWithFloat pointers by their floating-point annotation |
| CLegoBoundaryEdge | [AI] Represents an edge within a path boundary, used for path following and geometric computations |
| CLegoBox | [AI] Represents an axis-aligned 3D bounding box, defined by minimum and maximum corners |
| CLegoBuildingInfo | [AI] Describes the state, configuration, and world placement of a single LEGO building entity, including its animation, sound, mood, and boundary location properties |
| ►CLegoBuildingManager | [AI] Manages LEGO buildings in the world, including their state, animation, switching, saving/loading, and scheduling of animations |
| CAnimEntry | [AI] Tracks and schedules a single animation entry for a building with sound and timer information, for use with the tickling/animation update system |
| CLegoCacheSound | Sound cache object managing DirectSound buffers and 3D positioning for preloaded sound data |
| CLegoCacheSoundEntry | [AI] Represents a single entry in the cached sound system, linking a sound pointer with its identifying name |
| CLegoCacheSoundList | [AI] Specialized pointer list for managing a collection of LegoCacheSound objects, providing comparison and list management |
| CLegoCacheSoundListCursor | [AI] Cursor/iterator class for traversing a LegoCacheSoundList |
| CLegoCacheSoundManager | [AI] Manages caching, reuse, and playback of LegoCacheSound objects |
| CLegoCameraController | Camera controller for 3D scenes, handles interactive camera manipulation and view transformation |
| ►CLegoCarBuild | [AI] World implementation for the LEGO vehicle builder (Racecar, Copter, Dune Car, Jetski), handling UI, input, 3D vehicle assembly, part placement, and all vehicle-specific interactions |
| CLookupTableActions | [AI] Lookup table for animation/action IDs for vehicle types |
| ►CLegoCarBuildAnimPresenter | [AI] Handles the logic and animation presentation for the LEGO Island car-building activity, providing the main interface for coordinating the step-wise assembly of cars using animated 3D parts |
| CUnknownListEntry | [AI] Represents a single entry in the car assembly sequence ("part list"), providing mapping between display name, internal "wired" 3D representation, and an object id used to identify the animated node in the 3D scene |
| CLegoCarRaceActor | [AI] Specialized actor class for car-based racing in LEGO Island racing sequences. Supports additional logic for acceleration, handling, and boundary switching during a race. [AI] |
| CLegoCharacter | [AI] Holds a LegoROI pointer and reference count for a character instance managed by LegoCharacterManager |
| CLegoCharacterComparator | [AI] Comparator for character names, performing case-insensitive comparison using strcmpi |
| CLegoCharacterManager | [AI] Manages reference-counted characters and provides character creation, switching, and property update functionality |
| CLegoColor | LEGO color representation with 8-bit RGB channels |
| CLegoContainer | Template container associating string names with object pointers, optional lifetime management |
| CLegoContainerInfo | Template alias for a map from C-string keys to object pointers, using LegoContainerInfoComparator for ordering |
| CLegoContainerInfoComparator | Comparator used to order keys in LegoContainerInfo maps; compares C-strings lexicographically |
| CLegoControlManager | [AI] Manages control presenters and dispatches notifications for control/input events within the LEGO Island engine |
| CLegoControlManagerNotificationParam | [AI] Notification parameter for the LegoControlManager, used to propagate information about control events (like clicks) to listeners |
| CLegoDeviceEnumerate | [AI] Enumerates and manages Direct3D devices and drivers for the LEGO Island engine |
| CLegoEdge | [AI] Represents an edge in the LEGO world geometry graph |
| CLegoEndAnimNotificationParam | Notification parameter for signaling the end of an animation in the LEGO Island engine |
| CLegoEntity | [AI] Represents an entity that can be placed and managed in the LEGO Island world |
| CLegoEntityList | [AI] A strongly typed list for holding LegoEntity pointers |
| CLegoEntityListCursor | [AI] Cursor class for iterating through a LegoEntityList |
| CLegoEntityPresenter | [AI] Presenter responsible for managing the lifecycle, location, and logic for a LegoEntity instance as part of a presenter-based media action, typically managing the appearance and animation of an in-game actor |
| CLegoEventNotificationParam | Notification parameter class for LEGO event notifications such as mouse events and modifier keys |
| CLegoEventQueue | [AI] Event queue for processing Lego input (mouse/keyboard/joystick) events.[AI] Queue of input events. [AI] |
| CLegoExtraActor | Represents a special actor in the world with additional animation state machines and complex interactions |
| CLegoFile | Implementation of LegoStorage for file-backed storage using stdio FILE* |
| CLegoFlcTexturePresenter | [AI] Presenter for rendering FLC animation frames as textures in the LEGO engine |
| CLegoFullScreenMovie | Variable controlling full screen movie playback in the video manager |
| ►CLegoGameState | Comprehensive persistent game state manager: handles save/load, player selection, area switching, and score history |
| CHistory | Collection of best scores for all recent plays/players (high score table) |
| CScoreItem | Single score record for a player, including high score grids for all major games |
| CUsername | Player "username", stored as 7 short integers (character codes) |
| CLegoHideAnimPresenter | [AI] Presenter class responsible for controlling animations that hide or show actors based on animation nodes |
| CLegoHideAnimStruct | [AI] Structure associating a path boundary with an index |
| CLegoHideAnimStructComparator | [AI] Comparator for string keys in map for use with LegoHideAnimStruct |
| CLegoImage | [AI] Class representing an 8-bit palettized image with up to 256 palette entries and indexed pixel data |
| CLegoInputManager | [AI] Handles keyboard, mouse, and joystick input for the game |
| CLegoJetski | [AI] Represents a Jetski actor in the race, combining behavior from LegoJetskiRaceActor and LegoRaceMap |
| CLegoJetskiRaceActor | [AI] A racing actor subclass representing jetski (water-based) vehicles. Modifies car parameters and control logic for water-based racing. [AI] |
| CLegoLoadCacheSoundPresenter | Derived presenter class used for loading and creating cached sound objects from streamed audio data |
| ►CLegoLocation | Data structure representing a named spatial location and orientation in the LEGO Island world, with associated boundaries for source/destination triggers and some custom flags |
| CBoundary | Defines a logical boundary associated with a location for things such as triggers, teleportation areas, or view control |
| CLegoLocomotionAnimPresenter | [AI] Specialized presenter class for handling locomotion animation playback and state in the LEGO Island game engine |
| ►CLegoLOD | [AI] Level-Of-Detail (LOD) object used for rendering and managing polygonal mesh data with LOD switching |
| CMesh | [AI] Structure representing a sub-mesh and its texturization flag |
| CLegoLODList | [AI] Manages a list of LOD (Level-of-Detail) objects used for efficient 3D rendering by trading detail for performance |
| CLegoLODListCursor | [AI] Cursor class for traversing a LegoLODList |
| CLegoLoopingAnimPresenter | [AI] Presenter for looping animated sequences in the LEGO Island engine |
| CLegoMemory | Implementation of LegoStorage for memory-backed buffers |
| CLegoMesh | [AI] Represents the rendering attributes and state of a LEGO mesh, including color, transparency, shading mode, texture, and material |
| CLegoMeshUnkComponent | [AI] Unknown mesh sub-component structure possibly used for materials or textures |
| CLegoMeterPresenter | Presenter class for displaying and updating a graphical meter element, such as a progress bar or health bar, with support for different fill directions and variable-driven values |
| CLegoModelPresenter | [AI] Presenter class for managing 3D model (ROI) presentation and their relationship with entities in the world |
| CLegoMorphKey | [AI] Animation key for morphing states or mesh morphing |
| CLegoMouseController | [AI] Handles mouse input relevant to camera or entity control |
| CLegoNamedPart | [AI] Encapsulates a named part within a LEGO object that contains a list of LODs (Levels of Detail) |
| CLegoNamedPartList | [AI] A list container for storing pointers to LegoNamedPart objects |
| CLegoNamedPartListCursor | [AI] Cursor/iterator for traversing a LegoNamedPartList |
| CLegoNamedPlane | [AI] Represents a named 3D plane with orientation and position, used to describe places or camera targets in LEGO Island's world |
| CLegoNamedTexture | [AI] Associates a named string with a LegoTexture instance, allowing textures to be referenced symbolically (by name) |
| CLegoNamedTextureList | [AI] A list class that manages a collection of pointers to LegoNamedTexture objects |
| CLegoNamedTextureListCursor | [AI] Cursor/iterator for traversing a LegoNamedTextureList |
| CLegoNavController | [AI] Handles user navigation input (keyboard and joystick) and determines avatar movement and direction in the world |
| CLegoNotifyList | [AI] A list of notification targets (MxCore*) interested in input events (primarily keyboard) |
| CLegoNotifyListCursor | [AI] Cursor (iterator) for traversing a LegoNotifyList. Used to find or detach notification targets. [AI] |
| CLegoObjectFactory | [AI] Object factory for the LEGO Island game, responsible for instantiating all game-specific entities and presenters via name-based lookup |
| ►CLegoOmni | [AI] Central hub singleton for the LEGO Island game engine, managing all core game systems, state, world switching, and providing high-level access to all major engine subsystems |
| CWorldContainer | [AI] Associates a world enum, key, and AtomId for dynamic world lookup, Atom-based registry, and key-string identification |
| CLegoPaletteEntry | [AI] Represents a single entry in an 8-bit RGB palette with red, green, and blue components |
| CLegoPalettePresenter | Class responsible for presenting and handling palettes for video sequences that require palette management [AI] |
| CLegoPartPresenter | [AI] Presents and loads Lego part definitions from SI chunks and manages their installation in ViewLODListManager |
| CLegoPathActor | [AI] An actor that moves along a predefined path, supporting boundary transitions, navigation and collisions |
| CLegoPathActorSetCompare | [AI] Comparison functor used to order LegoPathActor pointers for set containers, using their pointer value |
| CLegoPathBoundary | [AI] Represents a path segment or boundary in the navigation network for actors (vehicles, NPCs) |
| ►CLegoPathController | [AI] Manager for controlling actors' movement along predefined geometric paths |
| CCtrlBoundary | [AI] Helper structure for rapid lookups of controller-boundary pairs, often used for global or indexed access patterns across controllers |
| CCtrlEdge | [AI] Helper structure pairing controllers with edge references for global or fast access |
| CLegoPathControllerList | Class representing a list of pointers to LegoPathController objects, with optional ownership semantics |
| CLegoPathControllerListCursor | Cursor/iterator for traversing a LegoPathControllerList |
| CLegoPathCtrlEdge | [AI] Controller-specific edge used in path navigation |
| CLegoPathCtrlEdgeCompare | [AI] Comparator functor for LegoPathCtrlEdge pointer sets |
| CLegoPathEdgeContainer | [AI] Container for path boundary edges, also stores position, direction, and flags |
| CLegoPathPresenter | [AI] Presenter class for loading and managing path data from scripts/actions, used for actor pathing in the LEGO Island engine |
| CLegoPathStruct | [AI] Represents a trigger/control element in the LEGO world's path system, linked logically to the world and supporting complex event logic via triggers |
| CLegoPathStructBase | [AI] Abstract base describing named, flag-based elements of the LEGO world path system |
| CLegoPathStructNotificationParam | [AI] Specialized notification parameter used for path structure related events in LEGO Island |
| CLegoPhoneme | [AI] Represents a single phoneme (mouth shape) used for character lip-sync and speech animation |
| CLegoPhonemeList | Specialized list class for managing LegoPhoneme objects |
| CLegoPhonemeListCursor | Cursor class for iterating over LegoPhonemeList |
| CLegoPhonemePresenter | Class responsible for presenting lip-synced ("phoneme") mouth animations on LEGO character head textures using FLC animations |
| CLegoPlantInfo | [AI] Struct representing a single plant's static configuration on LEGO Island, including placement, type, physical attributes, and references to world geometry |
| ►CLegoPlantManager | [AI] Manages the lifecycle, state, and properties for all plant objects (flowers, trees, bushes, palms) on LEGO Island |
| CAnimEntry | [AI] Structure for scheduling plant ROI/entity animations (i.e |
| CLegoPointOfViewController | [AI] Controller that links mouse actions to manipulation of the user's point of view in the 3D scene |
| CLegoRace | [AI] Base class for all race-type LegoWorlds |
| CLegoRaceActor | [AI] Represents an actor that participates in races (usually vehicles or racers) on LEGO Island |
| CLegoRaceCar | [AI] Represents a Race Car actor in the game, combining advanced pathing, skeleton kick logic, event and animation handling |
| CLegoRaceMap | [AI] Represents the world-space to screen-space mapping and rendering handler for the interactive race minimap |
| CLegoROI | [AI] Represents a Real-time Object Instance enriched with LEGO-specific functionality |
| CLegoROIList | [AI] A specialized pointer list for managing LegoROI instances |
| CLegoROIListCursor | [AI] A typed list cursor for iterating over a LegoROIList |
| CLegoROIMapList | [AI] Specialized pointer list that manages collections of LegoROI pointers, for ROI map management in the LEGO Island engine |
| CLegoRotationKey | [AI] Animation key class for rotations (axis-angle format) |
| CLegoScaleKey | [AI] Animation key class for scaling transformations |
| CLegoSoundManager | [AI] Manages 3D sound effects and music playback for LEGO Island, integrating with DirectSound and providing caching |
| CLegoSphere | [AI] Represents a sphere in 3D space, used for bounding volume calculations and spatial queries |
| ►CLegoState | [AI] Base class for game state blocks which encapsulate serializable and/or resettable aspects of the game's state |
| CPlaylist | [AI] Playlist structure representing an indexed list of object IDs with next-item selection strategies (loop, once, random etc) |
| CLegoStorage | Abstract base class providing an interface for file-like storage with binary and text read/write operations |
| CLegoTexture | [AI] Represents a texture which wraps a LegoImage and provides loading/saving functionality |
| CLegoTextureContainer | Specialized LegoContainer handling LegoTextureInfo objects and their DirectDraw/Direct3D caching |
| CLegoTextureInfo | [AI] Contains DirectDraw and Direct3DRM handles and metadata for a texture used in the LEGO Island rendering system |
| CLegoTexturePresenter | [AI] Manages the loading, storage, and management of named textures for the LEGO Island engine |
| CLegoTranInfo | [AI] Holds transformation and animation information for a LEGO object/ROI, especially in the context of animation presentation |
| CLegoTranInfoList | [AI] List container holding pointers to LegoTranInfo objects for use in transfer/pathfinding/ROIs |
| CLegoTranInfoListCursor | [AI] Cursor/iterator for traversing a LegoTranInfoList |
| CLegoTranslationKey | [AI] Animation key class for translations (vector 3D positions) |
| CLegoTree | [AI] Represents an N-ary tree of LegoTreeNode objects, with support for recursive reading and writing of tree structures |
| CLegoTreeNode | [AI] Represents a node within a general, N-ary tree structure |
| CLegoTreeNodeData | [AI] Abstract base class for storing data payloads inside nodes of a tree structure, forming the data content of each tree node |
| CLegoUnknown | Opaque Bezier curve utility used for actor or path position interpolation |
| CLegoUnknown100db7f4 | [AI] Represents an advanced edge in the LEGO Island geometry system, with direction, flags, and geometric query utilities |
| CLegoUnknownKey | [AI] Animation key of unknown type, used internally by camera/track animation |
| CLegoVehicleBuildState | [AI] Represents the persistent state of the LEGO vehicle build world, tracking animation and part placement state |
| CLegoVertex | [AI] Represents a 3D vertex with floating point coordinates |
| CLegoVideoManager | [AI] Extends the functionality of MxVideoManager to provide LEGO Island–specific video and 3D graphics management, including interface with DirectDraw/Direct3D, 3D scene composition, custom resource and palette/sky color handling, and in-engine FPS/cursor overlays |
| CLegoView | [AI] Represents a 3D rendering surface holding the main scene group and camera for rendering |
| CLegoView1 | [AI] 3D view that supports advanced lighting for scene rendering |
| CLegoWEEdge | [AI] Represents a face (polygon) composed of a list of edges in the LEGO Island world engine |
| CLegoWEGEdge | [AI] Represents a "geometry edge" in the LEGO Island world polygon/path system |
| CLegoWorld | Represents the active 3D world, holding all entity, animation, sound, path, and ROI objects |
| CLegoWorldList | A specialized list for managing pointers to LegoWorld instances |
| CLegoWorldListCursor | Provides iteration access to a LegoWorldList |
| CLegoWorldPresenter | [AI] Presenter for the entire LEGO world, responsible for loading, parsing, and managing world entities, geometry, and environmental data for a world |
| CList | [AI] Custom wrapper around std::list providing consistent allocator usage and swap semantics |
| CLODList | [AI] Type-safe extension of LODListBase, templated for any LODObject-derived type |
| CLODListBase | [AI] Abstract base class for an ordered list of LODObject pointers, where each entry represents an increasing level of geometric detail |
| CLODObject | [AI] Abstract base class for a Level-of-Detail (LOD) variant of a geometric object |
| CMap | [AI] Custom wrapper for std::map with consistent allocator and customizable comparator |
| CMatrix4 | 4x4 Matrix class with virtual interface for manipulation and transformation |
| CModelDbModel | [AI] Represents a 3D model entry in a model database, including metadata and spatial transform info |
| CModelDbPart | [AI] Represents a single part within a 3D model database entry, including its name and data offsets in a file |
| CModelDbPartList | [AI] Collection class representing a list of ModelDbPart pointers with custom comparison logic |
| CModelDbPartListCursor | [AI] Iterator for traversing ModelDbPartList contents (ModelDbPart pointers) |
| CModelDbWorld | [AI] Represents a world/scene in the model database, containing its parts and models |
| CModelInfo | [AI] Contains information about a model used in an animation, including name and orientation |
| CMotocycle | Motocycle is an IslePathActor representing the motorcycle vehicle the user can drive in LEGO Island |
| CMultimap | [AI] Custom multimap supporting multiple values per key with custom allocator and comparator |
| CMultiset | [AI] Multiset wrapper for storing ordered collections of non-unique elements with a custom allocator |
| CMx3DPointFloat | [AI] Represents a 3D point with floating-point precision, inheriting from Vector3 |
| CMx4DPointFloat | [AI] 4D point class for floating point values |
| CMxActionNotificationParam | [AI] Notification parameter class that contains information about an MxDSAction, used for inter-object notifications related to dynamic script (SI) actions |
| CMxAssignedDevice | [AI] Holds assignment and description details for a Direct3D rendering device in use |
| CMxAtom | [AI] Key-value pair representing a unique string (atom) and its reference count |
| CMxAtomCompare | [AI] Functor for comparing two MxAtom pointers based on their keys (strings) |
| CMxAtomId | [AI] Atomized (unique) string identifier, managed by reference counting |
| CMxAtomSet | [AI] Set of unique atom pointers, managed with custom comparison for atomization and fast lookup |
| CMxAudioManager | [AI] Audio subsystem manager for the LEGO Island engine, responsible for managing audio playback and audio resources |
| CMxAudioPresenter | [AI] Presents (plays/streams) audio (WAV, MID, etc.) as part of the Omni engine's media handler system |
| CMxAutoLock | [AI] Provides automatic RAII-style locking and unlocking for a critical section |
| CMxBackgroundAudioManager | [AI] Background music manager that handles playback, volume, state transitions, and notifications for background audio tracks in the game |
| CMxBitmap | [AI] Represents an 8bpp or high color device-independent bitmap (DIB) and provides operations for bitmap loading, manipulation, and palette management |
| CMxBITMAPINFO | [AI] Represents a bitmap information header plus a 256-color palette, matching the layout for 8-bit DIBs used in the game engine |
| ►CMxBitset | Templated fixed-size bitset for bit manipulation |
| CReference | Proxy class to reference a single bit within the MxBitset |
| CMxCollection | [AI] Template class for a generic collection, providing fundamental storage and comparison facilities, in addition to customized destruction policies |
| CMxCompositeMediaPresenter | Composite presenter for handling multiple synchronized media actions |
| CMxCompositePresenter | [AI] Composite presenter that manages a collection of child presenters, orchestrating their actions and notifications as a group |
| CMxCompositePresenterList | [AI] STL list of MxPresenter pointers, used to manage multiple child presenters under composite control |
| CMxControlPresenter | [AI] Presenter for UI controls, supporting toggles, grids, and "map" style controls with multiple interactive regions |
| CMxCore | [AI] Base virtual class for all Mindscape engine (Mx) objects |
| CMxCriticalSection | [AI] Provides a critical section object for mutual exclusion with optional use of OS mutex |
| ►CMxDeviceEnumerate | [AI] Enumerates DirectDraw/Direct3D drivers, devices, and display modes on the system |
| CGUID4 | [AI] Utility structure for GUID comparison |
| CMxDirect3D | [AI] MxDirect3D provides Direct3D (D3D) rendering capabilities layered on top of MxDirectDraw, managing device selection, initialization, and drawing contexts for LEGO Island's 3D rendering |
| CMxDirectDraw | Class responsible for interfacing with DirectDraw to manage rendering surfaces, palettes, and fullscreen/windowed device modes |
| CMxDiskStreamController | [AI] Controller for streaming from disk-based SI resources, manages buffers and streaming actions |
| CMxDiskStreamProvider | [AI] Disk-based stream provider for resource loading using background streaming and multithreading |
| CMxDiskStreamProviderThread | [AI] Thread to handle disk-based streaming for MxDiskStreamProvider, running as a worker for disk streaming actions |
| CMxDisplayMode | [AI] Represents a display mode with specific resolution and color depth |
| CMxDisplaySurface | Provides a DirectDraw-based drawing surface for blitting bitmaps, managing palette, and screen updates |
| CMxDriver | [AI] Holds data about a DirectDraw driver including devices and supported display modes |
| CMxDSAction | [AI] Represents an action deserialized from SI chunks, holding key animation or script parameters such as location, duration, and extra action-specific data |
| CMxDSActionList | [AI] A list (collection) of pointers to MxDSAction objects, supporting comparison, destruction, and list management |
| CMxDSActionListCursor | [AI] Convenience cursor class for iterating over an MxDSActionList |
| CMxDSAnim | Derived class representing an animation action extracted from SI files |
| CMxDSBuffer | [AI] Buffer for managing streamed DS (Data Stream) chunks and actions |
| CMxDSChunk | [AI] Represents a chunk of data extracted from a stream (typically from a Mindscape/Mx SI file or streaming media resource) |
| CMxDSEvent | [AI] Represents an event media action (a discrete event) parsed from script/scene data (SI files) |
| ►CMxDSFile | [AI] Represents a source file handler for SI (Streamer Interface) files, providing buffered access for reading SI file data and managing chunks |
| CChunkHeader | [AI] Represents the SI file stream's header chunk, containing versioning and SI buffer info |
| CMxDSMediaAction | MxDSMediaAction extends MxDSAction to add media-specific playback properties and management |
| CMxDSMultiAction | [AI] Represents a container for multiple MxDSAction objects, facilitating the grouping and management of several actions as a single entity |
| CMxDSObject | [AI] Base class for any object deserialized from an SI (script/data) file in the LEGO Island engine |
| CMxDSObjectAction | [AI] Represents an extracted SI file action of type "ObjectAction" |
| CMxDSObjectList | [AI] Utility list for managing dynamic sequence (DS) objects, provides search and removal by pointer and state |
| CMxDSParallelAction | [AI] Represents an action that can play multiple MxDSActions in parallel |
| CMxDSSelectAction | [AI] Represents a "select" action within a DS (Script/Scene) file, deserialized from SI files to select from a set of available actions at runtime based on a variable or random value |
| CMxDSSerialAction | [AI] Represents a serial (sequential) action group for data-driven sequence execution in LEGO Island |
| CMxDSSound | [AI] Represents a sound action extracted from an SI script and used in the data-driven action system |
| CMxDSSource | [AI] Abstract base class representing a source of streamable data, providing an interface for reading, seeking, and buffer management used for audio/video/other resource streaming in the LEGO Island engine |
| CMxDSStill | [AI] Represents a "still" media action in the LEGO Island SI script system |
| CMxDSStreamingAction | [AI] Represents an action that streams data from a buffer within a DirectScript (DS) media timeline |
| CMxDSSubscriber | [AI] Handles the receipt, queuing, and batch management of data chunks streamed by a MxStreamController |
| CMxDSSubscriberList | [AI] List container for pointers to MxDSSubscriber objects, with utility methods |
| CMxEndActionNotificationParam | [AI] Notification parameter marking the end of an action, specialization of MxActionNotificationParam |
| CMxEntity | MxEntity is a base class for game entities which are uniquely identified by an integer ID and an AtomId |
| CMxEventManager | MxEventManager is a subclass of MxMediaManager responsible for managing timed event delivery, either via cooperative thread or tickle-based mechanism |
| CMxEventPresenter | [AI] Presenter for handling "Event" stream data, typically parsed from event actions in SI files |
| CMxFlcPresenter | Implements playback and presentation of Autodesk FLIC (FLC) video streams |
| CMxFrequencyMeter | Utility for measuring the frequency (operations per second) of a repeated operation |
| CMxHashTable | [AI] Generic hash table collection implementing chained (bucketed) hashing, used for efficient lookup and storage of objects by key or value |
| CMxHashTableCursor | [AI] Non-intrusive search-and-edit cursor for navigating, querying, or deleting a specific entry in an MxHashTable |
| CMxHashTableNode | [AI] Node used within the MxHashTable to store an individual object and associated hash, for organizing elements in a bucketed linked list |
| CMxIdList | [AI] List of object IDs used to track registered notification listeners |
| CMXIOINFO | [AI] A wrapper for low-level file I/O, abstracting MMIOINFO functionality, and providing additional buffer and chunk management geared toward wave and RIFF file manipulation |
| CMxList | [AI] Forward declaration for MxList |
| CMxListCursor | [AI] Forward declaration for MxListCursor |
| CMxListEntry | [AI] |
| CMxLoopingFlcPresenter | [AI] Presents a looping FLC (Autodesk Animator FLIC) animation, extending the core FLC presenter to support frame looping behavior |
| CMxLoopingMIDIPresenter | [AI] Handles playback and management of looping MIDI actions, extending MIDI presentation functionality for repeated/looped music in the game |
| CMxLoopingSmkPresenter | [AI] Presenter for looping Smacker video resources |
| CMxMatrix | [AI] Represents a 4x4 transformation matrix, specialized for the LEGO Island engine and derived from Matrix4 |
| CMxMediaManager | [AI] Central class for managing the lifecycle and thread-safety of MxPresenter objects for audio/video playback |
| CMxMediaPresenter | [AI] Abstract base class for presenters that play back continuous media streams such as video or audio |
| CMxMemoryPool | [AI] Fixed-size memory pool template for fast allocation and deallocation |
| CMxMIDIPresenter | MIDI presenter class responsible for handling playback of MIDI music streams |
| CMxMusicManager | Manages MIDI music playback with Win32 MIDI streaming for the LEGO Island engine |
| CMxMusicPresenter | [AI] Presenter class that handles playback and management of music (streamed or MIDI) in LEGO Island |
| CMxNextActionDataStart | [AI] Contains data for scheduling the next action in a process, storing an object id, a parameter, and an associated data value |
| CMxNextActionDataStartList | [AI] List class specialized for storing MxNextActionDataStart pointers, managing streaming action start data |
| CMxNotification | [AI] Carries a notification to be sent to a target MxCore object |
| CMxNotificationManager | [AI] Central registry and dispatcher of asynchronous notifications between MxCore objects |
| CMxNotificationParam | [AI] Parameter object representing a single notification or event, carrying an identifier and sender pointer |
| CMxNotificationPtrList | [AI] List of notification pointers used to queue notifications for delivery |
| CMxObjectFactory | [AI] Forward declaration for the factory responsible for constructing core objects from atom or type ids |
| CMxOmni | [AI] Central subsystem coordinator and singleton of the LEGO Island engine |
| CMxOmniCreateFlags | [AI] Stores creation flags for initializing core LEGO Island engine subsystems |
| CMxOmniCreateParam | [AI] Encapsulates parameters required to initialize the core Omni engine |
| CMxPalette | [AI] Encapsulates a DirectDraw 8-bit (256 color) palette for use with DirectX rendering |
| CMxParam | [AI] MxParam serves as a polymorphic base class for parameter passing in event and notification systems throughout the LEGO Island engine |
| CMxPoint | [AI] 2D point class templated on its coordinate type |
| CMxPoint16 | [AI] 2D point with 16-bit signed integer coordinates |
| CMxPoint16List | [AI] List class for pointers to MxPoint16 |
| CMxPoint16ListCursor | [AI] Cursor for iterating MxPoint16List |
| CMxPoint32 | [AI] 2D point with 32-bit signed integer coordinates |
| CMxPoint32List | [AI] List class for pointers to MxPoint32 |
| CMxPoint32ListCursor | [AI] Cursor for iterating MxPoint32List |
| CMxPresenter | [AI] Abstract base class for all presenter types in the LEGO Island engine, responsible for managing the lifecycle of the presentation of actions and their corresponding tickle (update) state |
| CMxPresenterList | [AI] List to hold pointers to MxPresenter objects with optional ownership semantics |
| CMxPresenterListCursor | [AI] Cursor/iterator for traversing an MxPresenterList |
| CMxPtrList | [AI] |
| CMxPtrListCursor | [AI] |
| CMxQuaternionTransformer | Quaternion interpolation utility for 4D transformations, supporting quaternion start/end points and spherical interpolation |
| CMxQueue | Template class implementing a queue, derived from MxList |
| CMxRAMStreamController | Derived stream controller that manages media streaming from memory buffers as opposed to disk |
| CMxRAMStreamProvider | [AI] Provides RAM-backed stream data access |
| CMxRect | [AI] 2D rectangle class templated on its value type |
| CMxRect16 | [AI] Rectangle using 16-bit signed integer coordinates |
| CMxRect16List | [AI] List for pointers to MxRect16 rectangles |
| CMxRect16ListCursor | [AI] Cursor for iterating lists of MxRect16 pointers |
| CMxRect32 | [AI] Rectangle using 32-bit signed integer coordinates |
| CMxRect32List | [AI] List for pointers to MxRect32 rectangles |
| CMxRect32ListCursor | [AI] Cursor for iterating lists of MxRect32 pointers |
| CMxRegion | [AI] Represents a 2D region as a set of vertical spans each containing one or more horizontal segments |
| CMxRegionCursor | [AI] Cursor object suitable for traversing all rectangles covered by an MxRegion |
| CMxScheduler | [AI] Singleton class for managing and starting multitasking functionality in the system |
| CMxSegment | [AI] Represents a 1D segment defined by a minimum and maximum integer value |
| CMxSegmentList | [AI] List container for segments; stores pointers to MxSegment objects and may take ownership depending on construction |
| CMxSegmentListCursor | [AI] Cursor for traversing an MxSegmentList; allows sequential access through the segments |
| CMxSemaphore | Implements a lightweight wrapper for Windows semaphores, allowing safe synchronization between threads |
| CMxSize | [AI] 2D size class templated on its value type |
| CMxSize16 | [AI] Size with 16-bit signed integer width and height |
| CMxSize16List | [AI] List class for pointers to MxSize16 |
| CMxSize16ListCursor | [AI] Cursor for iterating MxSize16List |
| CMxSize32 | [AI] Size with 32-bit signed integer width and height |
| CMxSize32List | [AI] List class for pointers to MxSize32 |
| CMxSize32ListCursor | [AI] Cursor for iterating MxSize32List |
| CMxSmk | [AI] The MxSmk struct encapsulates all data required to decode and display a Smacker (SMK) video stream |
| CMxSmkPresenter | [AI] Presenter for rendering .SMK (Smacker) video media within the game engine |
| CMxSoundManager | [AI] Manages DirectSound-based sound playback, implementing volume, resource, and device management |
| CMxSoundPresenter | [AI] Concrete presenter for sound playback and control within the LEGO Island engine |
| CMxSpan | [AI] Represents a vertical span—a 1D range plus a set of contained horizontal segments, used as a row (span) of contiguous horizontal regions |
| CMxSpanList | [AI] List container for spans; holds MxSpan pointers and may automatically destroy them |
| CMxSpanListCursor | [AI] Cursor for traversing an MxSpanList, to sequentially access all spans in the list |
| CMxStartActionNotificationParam | [AI] Notification parameter marking the start of an action, specialization of MxActionNotificationParam |
| CMxStillPresenter | [AI] Presenter for single still image/bitmap media sources in the game |
| CMxStopWatch | Measures elapsed wall clock time using high resolution performance counters |
| CMxStreamChunk | [AI] Represents a streamable chunk of data, typically sourced from a media buffer and designed for notification and streaming within Lego Island's resource system |
| CMxStreamChunkList | [AI] A list for managing collections of pointers to MxStreamChunk objects, used for organizing and managing the chunks of a data stream within the engine |
| CMxStreamChunkListCursor | [AI] Cursor for iterating over a MxStreamChunkList |
| CMxStreamController | [AI] Controller for streaming and managing multimedia resources and actions during gameplay |
| CMxStreamer | Streams and manages media data, handles memory pools for RAM/disk streaming [AI] |
| CMxStreamerNotification | Streamer notification param for streaming events in MxStreamer [AI] |
| CMxStreamProvider | [AI] Abstract base class for stream resource providers in the LEGO Island engine |
| CMxString | Mindscape custom string class for managing dynamic C-strings within the game engine |
| CMxStringList | [AI] Specialized list class for storing MxString objects |
| CMxStringListCursor | [AI] Cursor class for traversing an MxStringList |
| CMxThread | [AI] Abstract thread class providing a platform-independent interface for thread management |
| CMxTickleClient | [AI] Associates an MxCore object with tickle timing/interval information |
| CMxTickleManager | [AI] Manages ticking ("tickling") a set of MxCore objects at specified intervals |
| CMxTickleThread | MxTickleThread periodically calls Tickle() on a target MxCore object in a separate thread |
| CMxTimer | Timer class for measuring elapsed time or frame time |
| CMxTransitionManager | [AI] Handles screen transitions and animations (such as dissolve, mosaic, wipe, etc.) between scenes or active states |
| CMxType4NotificationParam | [AI] Specialized notification parameter, used for notification type 4, extending MxActionNotificationParam with a presenter pointer |
| CMxUtilityList | [AI] A utility list extending the STL list<T>, providing simplified PushBack, Remove, and a PopFront operation |
| CMxVariable | [AI] Represents a key-value variable as used in the variable table for the LEGO Island engine |
| CMxVariableTable | MxVariableTable is a specialized hash table for storing key/value string variables used by the LEGO Island engine |
| CMxVideoManager | [AI] Video subsystem manager for DirectDraw/Direct3D video rendering and presenter control |
| CMxVideoParam | [AI] Video parameter configuration for display and rendering, encapsulates resolution, palette, backbuffers, display flags, and device identifier |
| CMxVideoParamFlags | [AI] Manages video parameter flags, providing an abstraction for various video settings such as fullscreen, buffer flipping, color depth, and view angle controls |
| ►CMxVideoPresenter | Derived video presenter responsible for displaying video frames using DirectDraw surfaces |
| CAlphaMask | Opaque mask used for efficient hit testing against video transparency |
| ►CMxWavePresenter | [AI] Presenter for streaming and managing PCM waveform audio via DirectSound buffer |
| CWaveFormat | [AI] Holds WAVE PCM format info for DirectSound buffer creation and streaming |
| COrientableROI | [AI] Represents an ROI (Real-time Object Instance) that can be oriented in world space, supporting local-to-world transformations and hierarchical parenting of orientation |
| CPathWithTrigger | [AI] Represents a path segment with an associated trigger in LEGO Island pathing logic |
| CPizza | Interactive pizza entity actor; manages the in-game pizza delivery sequence and reacts to mission triggers |
| ►CPizzaMissionState | Pizza mission state for the pizza delivery minigame and related characters |
| CMission | Holds all data for a single pizza mission for a specific actor |
| CPizzeria | [AI] Actor representing the pizzeria (Pizza Shop) as an interactive entity in the LEGO Island world |
| CPizzeriaState | [AI] Stores all state information for the pizzeria (Pizza Shop) minigame |
| CPolice | [AI] Main world object for the Police Station area in LEGO Island |
| CPoliceEntity | [AI] Entity for the Police building in LEGO Island |
| CPoliceState | [AI] Represents the state information specific to the Police area of the game |
| CPriority_queue | [AI] Customized priority queue for use with game-specific containers and allocators |
| CQueue | [AI] Customized queue for compatibility with the engine's allocator requirements |
| CRaceCar | [AI] Represents the drivable race car entity in the LEGO Island world |
| CRaceSkel | [AI] Specialized skeleton animation actor for LEGO Island car racing sequences |
| CRaceStandsEntity | [AI] Entity for the Race Stands (grandstands) building in LEGO Island |
| ►CRaceState | [AI] Maintains persistent information about race progress, results, and high scores for up to five races |
| CEntry | [AI] Entry for an individual race event/state, holding its identifier, unknown field, and score |
| CRadio | [AI] High-level manager for the in-game radio, handling notifications, playing/stopping, and state synchronization |
| CRadioState | [AI] Handles and stores state for the in-game radio, including track playlists, cycling, and active status |
| CRealtimeView | [AI] Handles global view and level-of-detail (LOD) settings for real-time rendering |
| CRegistrationBook | Derived world for handling the user registration book/infocenter name entry interface |
| CROI | [AI] Abstract base class for Real-time Object Instances (ROI) in the world |
| CROIColorAlias | |
| CROINameComparator | [AI] Comparator for ROIName (C-style strings) to be used as keys in maps, using strcmp for sorting |
| CScore | [AI] Implements the InfoScore/High Score game world/area, including score table display and handling user actions to transition to other areas |
| CScoreState | [AI] State object used to track the status of the Score/High Score area, particularly whether the educational "cube" tutorial should be shown to the player |
| CSet | [AI] Set wrapper utilizing a custom allocator and comparator |
| CSet100d6b4cComparator | [AI] Comparator used in the sound cache sound entry set (Set100d6b4c) |
| CSkateBoard | [AI] Represents the skateboard vehicle actor used in the minigame and cutscenes |
| CSkeletonKickPhase | [AI] Represents a phase of the skeleton kick animation/action, delimiting animation intervals along a boundary |
| CSmackSumTag | |
| CSmackTag | |
| CStack | [AI] Customized stack for compatibility with the engine's allocator and usage patterns |
| ►CTglSurface | [AI] Encapsulates a rendering surface, its associated hardware device, renderer, and view |
| CCreateStruct | [AI] Contains initialization parameters for creating a TglSurface and its underlying DDraw/D3D resources |
| CTimeROI | [AI] An extension of LegoROI that adds support for keeping and applying a base time reference (used for time-based animation/control) |
| CTowTrack | [AI] 3D world actor for the Tow Track mini-game; manages Tow Track mission logic, scene activation and input events |
| CTowTrackMissionState | [AI] State class for the TowTrack mini-game, storing scores by character and handling their serialization |
| CUnknownMatrixType | Matrix-like wrapper of 4x4 float array, with no methods |
| CVector | [AI] Custom vector supporting allocator and custom swap semantics |
| CVector2 | [AI] Represents a 2D mathematical vector with floating-point coordinates |
| CVector3 | [AI] 3D vector class, providing vector and cross-product operations in 3D space |
| CVector4 | [AI] A four-dimensional vector, supporting operations relevant for matrix and quaternion math (homogeneous coordinates) |
| CViewLOD | [AI] Represents a Level of Detail (LOD) object for rendering, implemented with a mesh builder and supporting bitwise flag operations |
| CViewLODList | [AI] Reference-counted list of Level-of-Detail (LOD) objects associated with a single ROI (Realtime Object Instance), shared by all instances of the same ROI |
| CViewLODListManager | [AI] Manages the lifecycle, lookup, and sharing of ViewLODList instances for different ROI names |
| CViewManager | [AI] Manages all ViewROI objects that are rendered in a given scene, handles frustum culling, LOD management, and visibility determination for 3D ROI objects |
| CViewportAppData | |
| CViewROI | [AI] ViewROI objects represent viewable and placeable objects in the scene, each holding their own transformation and geometry group for rendering |
| CVisibilityVariable | [AI] Variable to trigger show/hide operations on in-game 3D objects (ROIs) by parsing visibility commands |
| CWhoAmIVariable | [AI] Variable representing the current player's character, allowing the game to switch the active actor accordingly |
1.9.5