chore: commit untracked UE/scaffold files (repo cleanup triage 20260707)

Co-authored-by: Cursor <cursoragent@cursor.com>

docs/workflows/BUILDING_PIPELINE.md

@@ -0,0 +1,294 @@
+# Building Pipeline - Dubai Metaverse
+
+## Overview
+
+This document describes the complete pipeline for creating building assets for the Dubai Metaverse project, from modeling to final placement in Unreal Engine.
+
+## Pipeline Stages
+
+### 1. Planning & Reference
+
+#### Reference Collection
+
+- **Photography**: Collect reference photos
+- **Architectural Plans**: If available
+- **Material References**: Glass, concrete, metal samples
+- **Context**: Surrounding buildings, scale reference
+
+#### Asset Planning
+
+- **Building Type**: Residential, commercial, mixed-use
+- **Priority**: Tier 1 (hero), Tier 2 (primary), Tier 3 (background)
+- **Specifications**: Dimensions, materials, details
+- **Timeline**: Estimated completion date
+
+---
+
+### 2. Modeling
+
+#### Blockout
+
+1. **Basic Shape**: Create basic building shape
+2. **Scale Verification**: Verify scale is 1:1
+3. **Proportions**: Check proportions match reference
+4. **Placement**: Place in blockout level
+
+#### High-Poly Modeling
+
+1. **Main Structure**: Model main building structure
+2. **Architectural Details**: Add windows, balconies, details
+3. **Rooftop Elements**: Add rooftop features
+4. **Base Structure**: Model base/podium
+
+#### Low-Poly Modeling (if not using Nanite)
+
+1. **Optimization**: Create optimized low-poly version
+2. **LODs**: Generate LOD0-3
+3. **Topology**: Clean topology for performance
+
+#### UV Mapping
+
+1. **UV Layout**: Create UV layout
+2. **UDIM**: Use UDIM for hero assets (8K)
+3. **Standard UVs**: Use standard UVs for primary/background (4K/2K)
+4. **Optimization**: Optimize UV space usage
+
+---
+
+### 3. Texturing
+
+#### Substance Painter
+
+1. **Project Setup**: Import mesh, set resolution
+2. **Bake Maps**: Bake normal, AO, curvature
+3. **Texture Creation**: Create texture sets
+4. **Export**: Export textures (see TEXTURING_WORKFLOW.md)
+
+#### Texture Sets
+
+- **Base Color**: Material colors
+- **Normal**: Surface detail
+- **Roughness**: Surface roughness
+- **Metallic**: Metallic map
+- **AO**: Ambient occlusion
+
+---
+
+### 4. Material Creation
+
+#### Material Setup
+
+1. **Create Material**: Create material asset
+2. **Assign Textures**: Assign texture maps
+3. **Configure**: Set material properties
+4. **Parameters**: Expose parameters for instances
+
+#### Material Library
+
+- **Shared Materials**: Use shared materials where possible
+- **Instances**: Create instances for variations
+- **Documentation**: Document material usage
+
+---
+
+### 5. Import to Unreal
+
+#### Import Settings
+
+- **Nanite**: Enable for high-poly (hero/primary)
+- **LODs**: Generate LODs for non-Nanite
+- **Collision**: Auto-generate or custom
+- **Scale**: Verify 1:1 scale
+
+#### Material Assignment
+
+1. **Assign Materials**: Assign materials to mesh
+2. **Test**: Test in level
+3. **Adjust**: Adjust materials if needed
+4. **Validate**: Validate visual quality
+
+---
+
+### 6. Placement & Integration
+
+#### Level Placement
+
+1. **Place Building**: Place in level
+2. **Position**: Verify position matches blockout
+3. **Orientation**: Check orientation
+4. **Scale**: Verify scale
+
+#### Integration
+
+1. **Lighting**: Test with lighting
+2. **Shadows**: Verify shadows
+3. **Reflections**: Check reflections (glass)
+4. **Performance**: Test performance
+
+---
+
+## Building Categories
+
+### Hero Buildings (Tier 1)
+
+- **Count**: 1-2 buildings
+- **Quality**: Maximum (8K textures, Nanite)
+- **Examples**: Cayan Tower
+- **Pipeline**: Full pipeline with maximum detail
+
+### Primary Buildings (Tier 2)
+
+- **Count**: 20-40 buildings
+- **Quality**: High (4K textures, optimized geometry)
+- **Examples**: Marina residential towers
+- **Pipeline**: Full pipeline with high detail
+
+### Background Buildings (Tier 3)
+
+- **Count**: 30-50 buildings
+- **Quality**: Standard (2K textures, simplified geometry)
+- **Examples**: Generic modern buildings
+- **Pipeline**: Simplified pipeline, procedural where possible
+
+---
+
+## Quality Standards
+
+### Geometry
+
+- **Hero**: Maximum detail, photoreal quality
+- **Primary**: High detail, recognizable features
+- **Background**: Simplified but recognizable
+
+### Textures
+
+- **Hero**: 8K (UDIM workflow)
+- **Primary**: 4K
+- **Background**: 2K
+
+### Materials
+
+- **PBR Workflow**: All materials use PBR
+- **Consistency**: Maintain consistency across assets
+- **Performance**: Optimize for performance
+
+---
+
+## Naming Conventions
+
+### Static Meshes
+
+- **Format**: `SM_Building_Category_Number`
+- **Examples**: 
+  - `SM_Building_Marina_01`
+  - `SM_Building_Support_01`
+
+### Materials
+
+- **Format**: `M_Building_Type_Resolution`
+- **Examples**:
+  - `M_Building_Glass_4K`
+  - `M_Building_Concrete_4K`
+
+See [docs/NAMING_CONVENTIONS.md](../docs/NAMING_CONVENTIONS.md) for details.
+
+---
+
+## Performance Optimization
+
+### Nanite
+
+- **Usage**: All static meshes where possible
+- **Benefit**: High-poly without performance penalty
+- **Target**: 100% of static meshes use Nanite
+
+### LODs
+
+- **Usage**: Non-Nanite assets
+- **LODs**: LOD0-3 for primary, LOD0-2 for background
+- **Generation**: Auto-generate or manual
+
+### Material Optimization
+
+- **Shared Materials**: Use shared materials
+- **Instances**: Use material instances for variations
+- **Complexity**: Minimize shader complexity
+
+---
+
+## Validation Checklist
+
+### Modeling
+
+- [ ] Scale is correct (1:1)
+- [ ] Proportions match reference
+- [ ] Geometry is clean
+- [ ] UVs are optimized
+
+### Texturing
+
+- [ ] Textures meet resolution requirements
+- [ ] All texture maps are present
+- [ ] Textures are artifact-free
+- [ ] Colors are accurate
+
+### Materials
+
+- [ ] Materials are assigned correctly
+- [ ] PBR workflow is correct
+- [ ] Materials look realistic
+- [ ] Performance is acceptable
+
+### Integration
+
+- [ ] Building placed correctly
+- [ ] Lighting works correctly
+- [ ] Shadows are correct
+- [ ] Performance is acceptable
+
+---
+
+## Troubleshooting
+
+### Common Issues
+
+**Issue**: Building scale is wrong
+- **Solution**: Check import scale settings
+- **Solution**: Verify reference dimensions
+
+**Issue**: Textures not displaying
+- **Solution**: Check material assignment
+- **Solution**: Verify texture import settings
+
+**Issue**: Performance issues
+- **Solution**: Enable Nanite
+- **Solution**: Generate LODs
+- **Solution**: Optimize materials
+
+---
+
+## Tools
+
+### Modeling
+
+- **Blender**: Free, recommended
+- **Maya**: Professional alternative
+- **3ds Max**: Alternative
+
+### Texturing
+
+- **Substance Painter**: Primary tool
+- **Substance Designer**: Procedural materials
+- **Photoshop**: Additional editing
+
+### Import
+
+- **Unreal Engine**: Direct import
+- **FBX**: Standard format
+- **Datasmith**: For CAD data (optional)
+
+---
+
+**Version**: 1.0
+**Last Updated**: 2024-11-21
+

docs/workflows/CINEMATIC_PIPELINE.md

@@ -0,0 +1,340 @@
+# Cinematic Pipeline - Dubai Metaverse
+
+## Overview
+
+This document describes the cinematic rendering pipeline using Sequencer and Movie Render Queue for 8K cinematic output.
+
+## Sequencer
+
+### Overview
+
+Sequencer is Unreal Engine's cinematic tool for creating and editing cinematic sequences.
+
+### Setup
+
+1. **Create Sequence**:
+   - Content Browser > Right-click > Cinematics > Level Sequence
+   - Name: `SQ_DubaiCinematic_01`, etc.
+
+2. **Add Tracks**:
+   - Camera tracks
+   - Actor tracks
+   - Property tracks
+   - Audio tracks
+
+---
+
+## Cinematic Shots
+
+### Shot Planning
+
+**6-12 cinematic shots planned**
+
+#### Shot Types
+
+1. **Drone Sweeps**: Aerial shots of district
+2. **Helicopter Shots**: High-altitude shots
+3. **Street-Level Shots**: Ground-level shots
+4. **Building Focus**: Focus on Cayan Tower
+5. **Marina Shots**: Marina water and yachts
+6. **Sunset Shots**: Sunset lighting shots
+7. **Night Shots**: Night lighting with neon
+8. **Vehicle Shots**: Supercars in motion
+
+### Shot Breakdown
+
+#### SQ_DubaiCinematic_01: Opening Drone Sweep
+
+- **Camera**: CineCamera_Drone
+- **Duration**: 5-8 seconds
+- **Movement**: Slow sweep over district
+- **Focus**: District overview, Cayan Tower
+
+#### SQ_DubaiCinematic_02: Cayan Tower Focus
+
+- **Camera**: CineCamera_StreetLevel
+- **Duration**: 4-6 seconds
+- **Movement**: Slow orbit around tower
+- **Focus**: Cayan Tower details
+
+#### SQ_DubaiCinematic_03-12: Additional Shots
+
+- **Variety**: Mix of shot types
+- **Duration**: 4-8 seconds each
+- **Total**: 45-60 seconds combined
+
+---
+
+## Camera Setup
+
+### CineCamera Actors
+
+#### CineCamera_Drone
+
+**Drone camera for aerial shots**
+
+- **Lens**: Wide-angle (18-24mm)
+- **Focus**: Manual focus
+- **Aperture**: f/2.8-f/4
+- **Movement**: Smooth, cinematic
+
+#### CineCamera_Helicopter
+
+**Helicopter camera for high-altitude shots**
+
+- **Lens**: Wide-angle (18-35mm)
+- **Focus**: Manual focus
+- **Aperture**: f/2.8-f/5.6
+- **Movement**: Smooth, sweeping
+
+#### CineCamera_StreetLevel
+
+**Street-level camera for ground shots**
+
+- **Lens**: Normal to wide (24-50mm)
+- **Focus**: Manual focus, shallow DOF
+- **Aperture**: f/1.4-f/2.8
+- **Movement**: Smooth, tracking
+
+---
+
+## Master Sequence
+
+### SQ_MasterSequence
+
+**Master sequence combining all shots**
+
+### Setup
+
+1. **Create Master Sequence**:
+   - Create new level sequence
+   - Name: `SQ_MasterSequence`
+
+2. **Add Sub-Sequences**:
+   - Add all cinematic shots as sub-sequences
+   - Arrange in order
+   - Add transitions (optional)
+
+3. **Audio Track**:
+   - Add music track
+   - Sync with visuals
+   - Mix audio levels
+
+---
+
+## Movie Render Queue
+
+### Overview
+
+Movie Render Queue is Unreal Engine's high-quality rendering system for cinematic output.
+
+### Setup
+
+1. **Open Movie Render Queue**:
+   - Window > Movie Render Queue
+
+2. **Add Sequence**:
+   - Add master sequence
+   - Configure render settings
+
+3. **Render Presets**:
+   - Create render presets
+   - Save for reuse
+
+---
+
+## Render Presets
+
+### MRQ_8K_EXR
+
+**8K EXR render preset**
+
+#### Settings
+
+- **Output Format**: EXR (16-bit)
+- **Resolution**: 7680x4320 (8K UHD)
+- **Frame Rate**: 24 fps (cinematic)
+- **Anti-Aliasing**: Temporal AA
+- **Additional Passes**:
+  - Motion Vectors
+  - Depth
+  - Normals (optional)
+
+#### Output
+
+- **File Format**: EXR sequence
+- **Color Space**: Linear
+- **Bit Depth**: 16-bit
+- **Compression**: None or ZIP
+
+---
+
+### MRQ_4K_MP4
+
+**4K MP4 render preset**
+
+#### Settings
+
+- **Output Format**: MP4
+- **Resolution**: 3840x2160 (4K UHD)
+- **Frame Rate**: 24 or 30 fps
+- **Anti-Aliasing**: Temporal AA
+- **Codec**: H.264 or H.265
+
+#### Output
+
+- **File Format**: MP4
+- **Quality**: High
+- **Bitrate**: High (50+ Mbps)
+
+---
+
+## Render Settings
+
+### Quality Settings
+
+#### Anti-Aliasing
+
+- **Method**: Temporal AA
+- **Quality**: High
+- **Samples**: Maximum
+
+#### Motion Blur
+
+- **Enable**: Yes
+- **Amount**: Cinematic amount
+- **Quality**: High
+
+#### Depth of Field
+
+- **Enable**: Yes
+- **Method**: Gaussian
+- **Quality**: High
+
+#### Global Illumination
+
+- **Lumen Quality**: Epic
+- **Reflection Quality**: Epic
+- **Final Gather**: High quality
+
+---
+
+## Additional Passes
+
+### Motion Vectors
+
+- **Purpose**: For motion blur in post
+- **Format**: EXR
+- **Usage**: Post-production
+
+### Depth
+
+- **Purpose**: For depth effects in post
+- **Format**: EXR
+- **Usage**: Post-production
+
+### Normals
+
+- **Purpose**: For compositing
+- **Format**: EXR
+- **Usage**: Post-production (optional)
+
+---
+
+## Rendering Workflow
+
+### Pre-Render
+
+1. **Sequence Review**: Review all sequences
+2. **Settings Check**: Verify render settings
+3. **Output Path**: Set output directory
+4. **Test Render**: Render test frame
+
+### Render
+
+1. **Start Render**: Start Movie Render Queue
+2. **Monitor**: Monitor render progress
+3. **Time Estimate**: Review time estimates
+4. **Completion**: Wait for completion
+
+### Post-Render
+
+1. **Review**: Review rendered output
+2. **Validation**: Validate quality
+3. **Post-Production**: Edit in post (optional)
+4. **Delivery**: Prepare for delivery
+
+---
+
+## Performance Considerations
+
+### Render Time
+
+- **8K EXR**: Long render time (hours)
+- **4K MP4**: Moderate render time
+- **Optimization**: Optimize settings for balance
+
+### Resource Usage
+
+- **CPU**: High CPU usage
+- **GPU**: High GPU usage
+- **Memory**: High memory usage
+- **Storage**: Large output files
+
+---
+
+## Troubleshooting
+
+### Common Issues
+
+**Issue**: Render fails
+- **Solution**: Check output path
+- **Solution**: Verify disk space
+- **Solution**: Check render settings
+
+**Issue**: Quality issues
+- **Solution**: Increase quality settings
+- **Solution**: Check anti-aliasing
+- **Solution**: Verify resolution
+
+**Issue**: Render time too long
+- **Solution**: Optimize quality settings
+- **Solution**: Reduce resolution for tests
+- **Solution**: Use render farm (if available)
+
+---
+
+## Post-Production
+
+### Editing
+
+- **Software**: Premiere, DaVinci Resolve, etc.
+- **Color Grading**: Final color grading
+- **Audio**: Final audio mix
+- **Export**: Final export
+
+### Delivery
+
+- **Format**: Final delivery format
+- **Resolution**: Final resolution
+- **Codec**: Final codec
+- **Quality**: Final quality check
+
+---
+
+## Documentation
+
+### Shot Documentation
+
+Document each shot:
+- **Shot Name**: Shot identifier
+- **Camera**: Camera used
+- **Duration**: Shot duration
+- **Description**: Shot description
+- **Notes**: Production notes
+
+---
+
+**Version**: 1.0
+**Last Updated**: 2024-11-21
+

docs/workflows/HOUDINI_PIPELINE.md

@@ -0,0 +1,267 @@
+# Houdini Pipeline - Dubai Metaverse
+
+## Overview
+
+This document describes the Houdini to Unreal Engine pipeline for procedural generation in the Dubai Metaverse project.
+
+## Houdini Engine Setup
+
+### Prerequisites
+
+- **Houdini**: Installed on development machine
+- **Houdini Engine Plugin**: Installed in Unreal Engine 5.4
+- **Compatible Versions**: Check UE5.4 compatibility with Houdini version
+
+### Installation
+
+1. **Install Houdini**: Download and install from SideFX
+2. **Install Houdini Engine Plugin**:
+   - Edit > Plugins
+   - Search for "Houdini Engine"
+   - Enable plugin
+   - Restart editor
+3. **Configure Houdini Path**:
+   - Edit > Project Settings > Plugins > Houdini Engine
+   - Set Houdini installation path
+   - Verify connection
+
+---
+
+## Houdini Digital Assets (HDAs)
+
+### What are HDAs?
+
+Houdini Digital Assets are packaged Houdini tools that can be imported into Unreal Engine. They expose parameters that can be adjusted in Unreal without opening Houdini.
+
+### HDA Types for Dubai Metaverse
+
+1. **Building Generator**: Modular building generation
+2. **Road Network**: Road generation tool
+3. **Terrain Sculpt**: Terrain refinement
+
+---
+
+## Building Generator HDA
+
+### File: building_generator.hda
+
+**Purpose**: Generate modular buildings procedurally
+
+### Parameters
+
+- **Building Type**: Residential, Commercial, Mixed-use
+- **Height**: Building height (floors)
+- **Width**: Building width
+- **Depth**: Building depth
+- **Style**: Modern, Traditional, Luxury
+- **Details**: Window patterns, balconies, etc.
+
+### Output
+
+- **High-Poly Mesh**: Detailed building geometry
+- **Low-Poly Mesh**: Optimized version (optional)
+- **UVs**: Unwrapped UVs for texturing
+- **Material IDs**: Material assignment IDs
+
+### Workflow
+
+1. **Create HDA in Houdini**:
+   - Build procedural building generator
+   - Define parameters
+   - Package as HDA
+
+2. **Export HDA**:
+   - Save as `.hda` file
+   - Place in `houdini/` directory
+
+3. **Import to Unreal**:
+   - Import HDA via Houdini Engine
+   - Create HDA instance in level
+   - Adjust parameters in Unreal
+
+4. **Bake to Static Mesh** (optional):
+   - Bake HDA output to static mesh
+   - Enable Nanite if high-poly
+   - Assign materials
+
+---
+
+## Road Network HDA
+
+### File: road_network.hda
+
+**Purpose**: Generate road network from splines or points
+
+### Parameters
+
+- **Road Width**: Main road width
+- **Sidewalk Width**: Sidewalk width
+- **Road Material**: Road surface material
+- **Lane Count**: Number of lanes
+- **Intersection Type**: T-intersection, 4-way, roundabout
+
+### Output
+
+- **Road Mesh**: Road geometry
+- **Sidewalk Mesh**: Sidewalk geometry
+- **Markings**: Lane markings, crosswalks
+- **Intersections**: Road intersections
+
+### Workflow
+
+1. **Create Road Network in Houdini**:
+   - Input: Splines or points defining road network
+   - Generate road geometry
+   - Add intersections
+   - Package as HDA
+
+2. **Import to Unreal**:
+   - Import HDA
+   - Create instance
+   - Connect to road splines in level
+
+3. **Bake to Static Mesh**:
+   - Bake road geometry
+   - Assign materials
+   - Place in level
+
+---
+
+## Terrain Sculpt HDA
+
+### File: terrain_sculpt.hda
+
+**Purpose**: Refine and sculpt terrain from elevation data
+
+### Parameters
+
+- **Terrain Resolution**: Heightmap resolution
+- **Sculpting Tools**: Erosion, smoothing, detail
+- **Feature Generation**: Hills, valleys, etc.
+
+### Output
+
+- **Refined Heightmap**: Enhanced terrain heightmap
+- **Terrain Mesh**: Terrain geometry (optional)
+
+### Workflow
+
+1. **Import Elevation Data**:
+   - Import DEM/GeoTIFF to Houdini
+   - Convert to heightfield
+
+2. **Sculpt Terrain**:
+   - Apply erosion
+   - Add details
+   - Smooth areas
+
+3. **Export**:
+   - Export refined heightmap
+   - Import to Unreal
+   - Generate landscape
+
+---
+
+## Houdini to Unreal Workflow
+
+### Step 1: Create HDA in Houdini
+
+1. **Build Tool**: Create procedural tool in Houdini
+2. **Define Parameters**: Expose parameters for adjustment
+3. **Test**: Test tool in Houdini
+4. **Package**: Package as HDA file
+
+### Step 2: Import to Unreal
+
+1. **Import HDA**: Import via Houdini Engine
+2. **Create Instance**: Create HDA instance in level
+3. **Adjust Parameters**: Adjust parameters in Unreal
+4. **Validate**: Check output quality
+
+### Step 3: Bake (Optional)
+
+1. **Bake to Static Mesh**: Convert HDA output to static mesh
+2. **Enable Nanite**: If high-poly, enable Nanite
+3. **Assign Materials**: Assign materials
+4. **Optimize**: Optimize for performance
+
+---
+
+## HDA Organization
+
+### Folder Structure
+
+```
+houdini/
+├── building_generator.hda
+├── road_network.hda
+├── terrain_sculpt.hda
+└── assets/
+    └── [HDA source files]
+```
+
+### Naming Convention
+
+- **Format**: `system_name.hda`
+- **Examples**: 
+  - `building_generator.hda`
+  - `road_network.hda`
+
+---
+
+## Best Practices
+
+### HDA Design
+
+1. **Parameter Organization**: Group related parameters
+2. **Default Values**: Set sensible defaults
+3. **Documentation**: Document parameters and usage
+4. **Validation**: Validate input and output
+
+### Performance
+
+1. **Optimization**: Optimize HDA for performance
+2. **Baking**: Bake to static meshes when possible
+3. **LODs**: Consider LOD generation
+4. **Caching**: Use Houdini caching for complex operations
+
+### Workflow
+
+1. **Iterate in Houdini**: Develop and test in Houdini first
+2. **Simplify for Unreal**: Simplify if needed for Unreal
+3. **Document**: Document HDA usage
+4. **Version Control**: Track HDA versions
+
+---
+
+## Troubleshooting
+
+### Common Issues
+
+**Issue**: HDA not importing
+- **Solution**: Check Houdini Engine plugin is enabled
+- **Solution**: Verify Houdini installation path
+- **Solution**: Check Houdini version compatibility
+
+**Issue**: Parameters not working
+- **Solution**: Verify parameters are exposed in HDA
+- **Solution**: Check parameter types match
+
+**Issue**: Performance issues
+- **Solution**: Bake to static meshes
+- **Solution**: Optimize HDA operations
+- **Solution**: Use caching
+
+---
+
+## Resources
+
+- **Houdini Documentation**: [sidefx.com/docs](https://www.sidefx.com/docs/)
+- **Houdini Engine for Unreal**: [sidefx.com/software/engines/unreal](https://www.sidefx.com/software/engines/unreal/)
+- **Houdini Learning**: SideFX learning resources
+
+---
+
+**Version**: 1.0
+**Last Updated**: 2024-11-21
+

docs/workflows/PCG_WORKFLOW.md

@@ -0,0 +1,276 @@
+# PCG Workflow - Dubai Metaverse
+
+## Overview
+
+This document describes the Procedural Content Generation (PCG) workflow for the Dubai Metaverse project, including building placement, road props, and vegetation.
+
+## PCG Framework Basics
+
+### What is PCG?
+
+Procedural Content Generation Framework is Unreal Engine 5's built-in system for procedurally placing and generating content in levels. It uses graph-based workflows to define rules for content placement.
+
+### Key Concepts
+
+- **PCG Graph**: Visual graph defining placement rules
+- **Input**: Splines, volumes, points, or other data
+- **Output**: Placed actors, meshes, or other content
+- **Rules**: Logic defining how content is placed
+
+---
+
+## Building Placement PCG
+
+### Graph: PCG_BuildingPlacement
+
+**Purpose**: Procedurally place buildings in the Dubai Marina district
+
+### Input Data
+
+- **Building Footprints**: From OpenStreetMap data or manual placement
+- **Spline Points**: Road network splines
+- **Volume**: District boundary volume
+
+### Placement Rules
+
+1. **Distance from Roads**: Buildings placed 5-10m from road edges
+2. **Building Spacing**: Minimum 2m spacing between buildings
+3. **Building Types**: 
+   - Residential towers: Near Marina
+   - Commercial: Along main roads
+   - Background: Fill remaining areas
+4. **Orientation**: Buildings face roads or Marina
+
+### Output
+
+- **Static Mesh Actors**: Building meshes placed in level
+- **Material Instances**: Assigned based on building type
+- **LODs**: Automatically assigned based on distance
+
+### Implementation Steps
+
+1. **Create PCG Graph**:
+   - Create new PCG graph asset: `PCG_BuildingPlacement.pcg`
+   - Add input node (spline or points)
+
+2. **Define Rules**:
+   - Add "Surface Sampler" node to sample building locations
+   - Add "Point Filter" to filter valid placement points
+   - Add "Spawn Actor" node to place building meshes
+
+3. **Configure Parameters**:
+   - Building density
+   - Building types
+   - Placement constraints
+
+4. **Test and Iterate**:
+   - Execute graph
+   - Review placement
+   - Adjust rules as needed
+
+---
+
+## Road Props PCG
+
+### Graph: PCG_RoadProps
+
+**Purpose**: Place road props (lamp posts, barriers, signs) along roads
+
+### Input Data
+
+- **Road Splines**: Road network splines
+- **Prop Types**: Lamp posts, barriers, signs, etc.
+
+### Placement Rules
+
+1. **Lamp Posts**: 
+   - Spacing: 20-30m along roads
+   - Placement: Road edges, alternating sides
+   - Height: Match road level
+
+2. **Barriers**:
+   - Placement: Road medians, pedestrian areas
+   - Spacing: Continuous or 2-5m gaps
+
+3. **Signs**:
+   - Placement: Road intersections, important locations
+   - Orientation: Face traffic direction
+
+### Output
+
+- **Static Mesh Actors**: Prop meshes placed along roads
+- **Variations**: Random prop variations for variety
+
+### Implementation Steps
+
+1. **Create PCG Graph**: `PCG_RoadProps.pcg`
+2. **Add Spline Sampler**: Sample points along road splines
+3. **Add Spawn Actor**: Place prop meshes at sampled points
+4. **Add Variation**: Random prop selection and rotation
+
+---
+
+## Vegetation PCG
+
+### Graph: PCG_Vegetation
+
+**Purpose**: Place trees, shrubs, and vegetation in the district
+
+### Input Data
+
+- **Terrain**: Landscape/terrain data
+- **Exclusion Zones**: Areas where vegetation shouldn't be placed (roads, buildings)
+
+### Placement Rules
+
+1. **Palm Trees**:
+   - Placement: Marina promenade, parks, green spaces
+   - Spacing: 5-10m between trees
+   - Clustering: Group in natural clusters
+
+2. **Shrubs**:
+   - Placement: Around buildings, along paths
+   - Density: Medium to high
+   - Randomization: Vary size and rotation
+
+3. **Grass**:
+   - Placement: Open areas, parks
+   - Density: High
+   - Use foliage system for performance
+
+### Output
+
+- **Static Mesh Actors**: Tree and shrub meshes
+- **Foliage Instances**: Grass and small vegetation
+- **Variations**: Random size, rotation, and type
+
+### Implementation Steps
+
+1. **Create PCG Graph**: `PCG_Vegetation.pcg`
+2. **Add Surface Sampler**: Sample terrain surface
+3. **Add Exclusion Filter**: Exclude roads and buildings
+4. **Add Spawn Actor**: Place vegetation meshes
+5. **Add Variation**: Randomize size and rotation
+
+---
+
+## Traffic PCG
+
+### Graph: PCG_Traffic
+
+**Purpose**: Generate AI traffic on roads
+
+### Input Data
+
+- **Road Splines**: Road network for traffic paths
+- **Vehicle Types**: Car, SUV, supercar variants
+
+### Placement Rules
+
+1. **Vehicle Spawning**:
+   - Spawn points: Road intersections, entry points
+   - Density: Moderate (not too crowded)
+   - Types: Mix of vehicle types
+
+2. **Traffic Flow**:
+   - Direction: Follow road direction
+   - Speed: Vary by vehicle type
+   - Behavior: Use Chaos Vehicle AI
+
+### Output
+
+- **Vehicle Actors**: Spawned vehicles on roads
+- **AI Controllers**: Vehicle AI for movement
+- **Traffic Flow**: Realistic traffic patterns
+
+### Implementation Steps
+
+1. **Create PCG Graph**: `PCG_Traffic.pcg`
+2. **Add Spline Sampler**: Sample road splines
+3. **Add Spawn Actor**: Spawn vehicle blueprints
+4. **Configure AI**: Set up vehicle AI controllers
+
+---
+
+## PCG Graph Organization
+
+### Folder Structure
+
+```
+Content/PCG/
+├── PCG_BuildingPlacement.pcg
+├── PCG_RoadProps.pcg
+├── PCG_Vegetation.pcg
+├── PCG_Traffic.pcg
+└── SubGraphs/
+    ├── PCG_BuildingRules.pcg
+    └── PCG_PropRules.pcg
+```
+
+### Naming Convention
+
+- **Format**: `PCG_SystemName_Purpose.pcg`
+- **Examples**: 
+  - `PCG_BuildingPlacement.pcg`
+  - `PCG_RoadProps_LampPosts.pcg`
+
+---
+
+## Best Practices
+
+### Performance
+
+1. **Baking**: Bake PCG output to static meshes for performance
+2. **LODs**: Use LOD system for distant content
+3. **Culling**: Use distance culling for props
+4. **Instancing**: Use instanced static meshes where possible
+
+### Quality
+
+1. **Variation**: Add randomization for natural look
+2. **Rules**: Define clear placement rules
+3. **Validation**: Validate output quality
+4. **Iteration**: Iterate on rules until satisfied
+
+### Workflow
+
+1. **Start Simple**: Begin with basic placement rules
+2. **Iterate**: Refine rules based on output
+3. **Test**: Test in level regularly
+4. **Document**: Document rules and parameters
+
+---
+
+## Troubleshooting
+
+### Common Issues
+
+**Issue**: Buildings overlapping
+- **Solution**: Add minimum distance filter
+
+**Issue**: Props not placing correctly
+- **Solution**: Check spline direction and sampling
+
+**Issue**: Performance issues
+- **Solution**: Bake to static meshes, use LODs
+
+**Issue**: Vegetation in wrong areas
+- **Solution**: Add exclusion zones/filters
+
+---
+
+## Validation
+
+### PCG Output Validation
+
+Use `scripts/pcg_validation.py` to validate:
+- Placement rules are followed
+- No overlapping content
+- Performance is acceptable
+- Visual quality meets standards
+
+---
+
+**Version**: 1.0
+**Last Updated**: 2024-11-21
+

docs/workflows/TEXTURING_WORKFLOW.md

@@ -0,0 +1,288 @@
+# Texturing Workflow - Dubai Metaverse
+
+## Overview
+
+This document describes the texturing workflow from Substance Painter to Unreal Engine for the Dubai Metaverse project.
+
+## Workflow Overview
+
+1. **Model Preparation**: Prepare model with UVs
+2. **Substance Painter**: Create textures
+3. **Export**: Export texture sets
+4. **Import to Unreal**: Import and create materials
+5. **Assignment**: Assign materials to meshes
+
+---
+
+## Model Preparation
+
+### UV Mapping
+
+- **UDIM Workflow**: Use UDIM for hero assets (8K textures)
+- **Standard UVs**: Use standard UVs for primary/background assets
+- **UV Layout**: Optimize UV layout for texture space
+- **Seams**: Minimize visible seams
+
+### Export for Texturing
+
+- **Format**: FBX or OBJ
+- **Include**: 
+  - High-poly mesh (for baking)
+  - Low-poly mesh (for texturing)
+  - UVs
+  - Material IDs (if using)
+
+---
+
+## Substance Painter Workflow
+
+### Project Setup
+
+1. **Create Project**:
+   - Import low-poly mesh
+   - Import high-poly mesh (for baking)
+   - Set texture resolution (8K for hero, 4K for primary)
+
+2. **Bake Maps**:
+   - Normal map (from high-poly)
+   - Ambient Occlusion
+   - Curvature
+   - Position
+   - Thickness
+
+### Texture Creation
+
+#### Base Color
+
+- **Purpose**: Albedo/diffuse colors
+- **Content**: Material colors, patterns, details
+- **Notes**: No lighting information, pure color
+
+#### Normal
+
+- **Purpose**: Surface detail and geometry
+- **Content**: Bumps, surface detail, geometry
+- **Source**: Baked from high-poly or painted
+- **Notes**: RGB format, tangent space
+
+#### Roughness
+
+- **Purpose**: Surface roughness (shininess)
+- **Content**: 
+  - Glass: 0.05-0.1 (very smooth)
+  - Metal: 0.1-0.3 (smooth)
+  - Concrete: 0.4-0.6 (rough)
+- **Notes**: Critical for material realism
+
+#### Metallic
+
+- **Purpose**: Metallic vs. dielectric materials
+- **Content**:
+  - Metal: 1.0 (white)
+  - Non-metal: 0.0 (black)
+  - Mixed: Grayscale values
+- **Notes**: Binary or grayscale
+
+#### Ambient Occlusion
+
+- **Purpose**: Shadow and occlusion information
+- **Content**: Baked AO or painted
+- **Notes**: Enhances depth and realism
+
+#### Additional Maps (if needed)
+
+- **Emissive**: For neon lights, interior lighting
+- **Height**: For parallax/displacement (optional)
+- **Opacity**: For transparency (glass)
+
+### Export Settings
+
+#### Resolution
+
+- **Hero Assets**: 8K (8192x8192) per UDIM tile
+- **Primary Buildings**: 4K (4096x4096)
+- **Background**: 2K (2048x2048)
+
+#### Format
+
+- **Export**: PNG or TGA
+- **Bit Depth**: 16-bit (recommended)
+- **Color Space**: sRGB for base color, linear for others
+
+#### Export Configuration
+
+- **Base Color**: sRGB, 16-bit PNG
+- **Normal**: Linear, 16-bit PNG
+- **Roughness**: Linear, 16-bit PNG
+- **Metallic**: Linear, 16-bit PNG
+- **AO**: Linear, 16-bit PNG
+- **Emissive**: sRGB, 16-bit PNG (if needed)
+
+---
+
+## Import to Unreal Engine
+
+### Texture Import
+
+1. **Import Textures**:
+   - Drag textures to Content Browser
+   - Or use Import button
+
+2. **Import Settings**:
+   - **Compression**: 
+     - Base Color: BC7 (DXT5)
+     - Normal: BC5
+     - Roughness/Metallic/AO: BC7
+   - **sRGB**: 
+     - Base Color: Enabled
+     - Others: Disabled
+   - **Mip Maps**: Generate mip maps
+   - **Virtual Texturing**: Enable if using (optional)
+
+### Material Creation
+
+1. **Create Material**:
+   - Create new material asset
+   - Name: `M_AssetName_Type`
+
+2. **Texture Assignment**:
+   - Base Color: Connect Base Color texture
+   - Normal: Connect Normal texture
+   - Roughness: Connect Roughness texture
+   - Metallic: Connect Metallic texture
+   - Ambient Occlusion: Connect AO texture
+
+3. **Material Settings**:
+   - **Shading Model**: Default Lit
+   - **Blend Mode**: Opaque (or Translucent for glass)
+   - **Two-Sided**: Enable for glass if needed
+
+4. **Parameters**:
+   - Expose parameters for material instances
+   - Color tint
+   - Roughness multiplier
+   - Metallic value
+
+### Material Instances
+
+1. **Create Instance**:
+   - Right-click material > Create Material Instance
+   - Name: `MI_AssetName_Variant`
+
+2. **Adjust Parameters**:
+   - Color variations
+   - Roughness adjustments
+   - Other exposed parameters
+
+---
+
+## UDIM Workflow (Hero Assets)
+
+### UDIM Overview
+
+- **UDIM**: U-Dimension texture mapping
+- **Tiles**: Multiple UV tiles (1001, 1002, 1003, etc.)
+- **Usage**: Large assets requiring high-resolution textures
+
+### Texture Naming
+
+- **Format**: `T_AssetName_MapType_UDIMNumber`
+- **Example**: 
+  - `T_Hero_CayanTower_BaseColor_1001`
+  - `T_Hero_CayanTower_BaseColor_1002`
+
+### Import UDIM Textures
+
+1. **Import All Tiles**: Import all UDIM tiles
+2. **Create Material**: Create material with UDIM support
+3. **Texture Arrays**: Use texture arrays or virtual textures
+4. **UV Mapping**: Ensure UVs use UDIM coordinates
+
+---
+
+## Quality Validation
+
+### Texture Quality
+
+- [ ] Resolution meets requirements
+- [ ] No compression artifacts
+- [ ] Colors are accurate
+- [ ] Normal maps are correct
+- [ ] Roughness values are realistic
+- [ ] Metallic values are correct
+
+### Material Quality
+
+- [ ] Materials look realistic
+- [ ] PBR workflow is correct
+- [ ] Lighting responds correctly
+- [ ] Performance is acceptable
+
+---
+
+## Best Practices
+
+### Texture Creation
+
+1. **Reference**: Use real-world material references
+2. **Consistency**: Maintain consistency across assets
+3. **Detail**: Add appropriate detail level
+4. **Optimization**: Balance quality and performance
+
+### Material Creation
+
+1. **Shared Materials**: Use shared materials where possible
+2. **Instances**: Use material instances for variations
+3. **Performance**: Optimize shader complexity
+4. **Documentation**: Document material usage
+
+### Workflow
+
+1. **Iterate**: Iterate on textures based on feedback
+2. **Test**: Test materials in level regularly
+3. **Validate**: Validate quality and performance
+4. **Document**: Document texture and material specifications
+
+---
+
+## Troubleshooting
+
+### Common Issues
+
+**Issue**: Textures look washed out
+- **Solution**: Check sRGB settings (base color should be sRGB)
+
+**Issue**: Normal maps not working
+- **Solution**: Check normal map format (BC5 compression)
+- **Solution**: Verify normal map is tangent space
+
+**Issue**: Materials too shiny/rough
+- **Solution**: Adjust roughness values
+- **Solution**: Check metallic values
+
+**Issue**: Performance issues
+- **Solution**: Reduce texture resolution
+- **Solution**: Use texture streaming
+- **Solution**: Optimize material complexity
+
+---
+
+## Tools
+
+### Primary Tools
+
+- **Substance Painter**: Primary texturing tool
+- **Substance Designer**: Procedural materials (optional)
+- **Photoshop**: Additional editing (optional)
+
+### Validation Tools
+
+- **Unreal Material Editor**: Material validation
+- **Performance Profiler**: Performance testing
+- **Texture Validation Script**: `scripts/texture_validation.py`
+
+---
+
+**Version**: 1.0
+**Last Updated**: 2024-11-21
+