Skip to content

DreamLab-AI/UE5-3DGS

BranchesTags

Repository files navigation

UE5-3DGS

Unreal Engine 5 → 3D Gaussian Splatting Export Pipeline

Unreal Engine License C++ COLMAP

Production-ready plugin for exporting Unreal Engine 5 scenes to 3D Gaussian Splatting training datasets

Quick Start · Architecture · API Reference · Guides

📋 Table of Contents

🎯 Overview

UE5-3DGS bridges Unreal Engine 5's powerful rendering capabilities with 3D Gaussian Splatting (3DGS) neural rendering. This plugin automates the complex process of generating training-ready datasets from UE5 scenes, handling coordinate system transformations, camera intrinsics extraction, and multi-format export.

flowchart LR
    subgraph UE5["Unreal Engine 5"]
        Scene[("3D Scene")]
        Camera["Camera System"]
        Depth["Depth Buffer"]
    end

    subgraph Plugin["UE5-3DGS Plugin"]
        Coord["Coordinate\nConverter"]
        Traj["Trajectory\nGenerator"]
        Orch["Capture\nOrchestrator"]
    end

    subgraph Output["Export Formats"]
        COLMAP["COLMAP\nDataset"]
        PLY["3DGS PLY\nPoint Cloud"]
        Images["Training\nImages"]
    end

    Scene --> Coord
    Camera --> Coord
    Depth --> Orch
    Coord --> Traj
    Traj --> Orch
    Orch --> COLMAP
    Orch --> PLY
    Orch --> Images

    style Plugin fill:#4a9eff,color:#fff
    style Output fill:#2ecc71,color:#fff
Loading

Why UE5-3DGS?

Challenge Solution
Complex coordinate transformations Automated UE5↔COLMAP conversion with mathematical precision
Camera intrinsics extraction Direct integration with UE5's camera component system
Optimal view sampling 5 trajectory algorithms optimized for 3DGS training
Format compliance Byte-perfect COLMAP and PLY output
Production workflow Editor mode with real-time preview and validation

✨ Features

🔄 Coordinate System Conversion

Handles the complex transformation between UE5 and COLMAP coordinate systems:

graph TB
    subgraph UE5["UE5 Coordinate System"]
        direction TB
        UE5_X["X → Forward"]
        UE5_Y["Y → Right"]
        UE5_Z["Z → Up"]
        UE5_H["Left-handed"]
        UE5_U["Centimeters"]
    end

    subgraph COLMAP["COLMAP Coordinate System"]
        direction TB
        COL_X["X → Right"]
        COL_Y["Y → Down"]
        COL_Z["Z → Forward"]
        COL_H["Right-handed"]
        COL_U["Meters"]
    end

    UE5 -->|"Transform Matrix"| COLMAP

    style UE5 fill:#ff6b6b,color:#fff
    style COLMAP fill:#4ecdc4,color:#fff
Loading

Transformation Matrix:

COLMAP.X =  UE5.Y / 100
COLMAP.Y = -UE5.Z / 100
COLMAP.Z =  UE5.X / 100
📸 Camera Intrinsics Extraction

Supports all standard camera models:

Model Parameters Use Case
PINHOLE fx, fy, cx, cy Standard perspective
SIMPLE_PINHOLE f, cx, cy Equal focal lengths
RADIAL f, cx, cy, k1, k2 Barrel/pincushion distortion
OPENCV fx, fy, cx, cy, k1, k2, p1, p2 Full OpenCV model 
FCameraIntrinsics Intrinsics;
Intrinsics.Width = 1920;
Intrinsics.Height = 1080;
Intrinsics.FocalLengthX = 1000.0f;
Intrinsics.FocalLengthY = 1000.0f;
Intrinsics.PrincipalPointX = 960.0f;
Intrinsics.PrincipalPointY = 540.0f;
Intrinsics.Model = ECameraModel::PINHOLE;
🎬 Trajectory Generation

Five optimized camera trajectory algorithms:

graph TD
    subgraph Trajectories["Camera Trajectory Types"]
        Orbital["🔄 Orbital Rings<br/>3-5 elevation levels"]
        Spiral["🌀 Spiral<br/>Continuous coverage"]
        Hemisphere["🌐 Hemisphere<br/>Fibonacci distribution"]
        Full360["⭕ Full 360°<br/>Single elevation"]
        Custom["⚙️ Custom<br/>User-defined paths"]
    end

    Orbital --> |"Best for"| Objects["Object Scanning"]
    Spiral --> |"Best for"| Interiors["Interior Scenes"]
    Hemisphere --> |"Best for"| Outdoor["Outdoor Environments"]
    Full360 --> |"Best for"| Turntable["Product Shots"]
    Custom --> |"Best for"| Special["Special Requirements"]
Loading

Optimal Training Parameters:

  • View Count: 100-180 images
  • Overlap: 60-80% between adjacent views
  • Elevation Angles: -30° to +60° for full coverage
📦 Export Format Support

COLMAP Dataset Structure

output/
├── cameras.txt          # Camera intrinsics
├── images.txt           # Image poses (quaternion + translation)
├── points3D.txt         # Sparse point cloud (optional)
└── images/
    ├── frame_0000.png
    ├── frame_0001.png
    └── ...

3DGS PLY Format (236 bytes/point)

graph LR
    subgraph PLY["PLY Point Structure (236 bytes)"]
        Pos["Position<br/>12 bytes<br/>float x,y,z"]
        Norm["Normal<br/>12 bytes<br/>float nx,ny,nz"]
        DC["DC SH<br/>12 bytes<br/>float r,g,b"]
        Rest["Rest SH<br/>180 bytes<br/>45 × float"]
        Op["Opacity<br/>4 bytes<br/>float"]
        Scale["Scale<br/>12 bytes<br/>float sx,sy,sz"]
        Rot["Rotation<br/>16 bytes<br/>float qw,qx,qy,qz"]
    end

    Pos --> Norm --> DC --> Rest --> Op --> Scale --> Rot
Loading

🚀 Quick Start

Prerequisites

  • Unreal Engine 5.3 or later
  • Visual Studio 2022 (Windows) or Xcode 14+ (macOS)
  • C++17 compatible compiler

Installation

Option 1: Clone into Plugins folder 
cd YourProject/Plugins
git clone https://github.com/yourusername/UE5-3DGS.git
Option 2: Add as Git submodule 
git submodule add https://github.com/yourusername/UE5-3DGS.git Plugins/UE5_3DGS
git submodule update --init --recursive

Basic Usage

#include "UE5_3DGS.h"

// 1. Configure capture settings
FCaptureSettings Settings;
Settings.OutputDirectory = TEXT("/Game/Exports/Scene01");
Settings.ImageWidth = 1920;
Settings.ImageHeight = 1080;
Settings.TrajectoryType = ETrajectoryType::Orbital;
Settings.ViewCount = 150;

// 2. Create and run orchestrator
UCaptureOrchestrator* Orchestrator = NewObject<UCaptureOrchestrator>();
Orchestrator->Initialize(Settings);
Orchestrator->StartCapture();

Editor Mode

  1. Enable the plugin in Edit → Plugins
  2. Open Window → UE5-3DGS Capture Panel
  3. Configure settings in the property panel
  4. Click "Generate Preview" to visualize camera positions
  5. Click "Start Capture" to begin export

🏗 Architecture

classDiagram
    class UCaptureOrchestrator {
        +FCaptureSettings Settings
        +Initialize(Settings)
        +StartCapture()
        +StopCapture()
        +GetProgress() float
        -ProcessFrame()
        -WriteOutput()
    }

    class FCoordinateConverter {
        +UE5ToColmap(FVector) FVector
        +ColmapToUE5(FVector) FVector
        +ConvertRotation(FQuat) FQuat
        +ConvertTransform(FTransform) FTransform
    }

    class FCameraIntrinsics {
        +int32 Width
        +int32 Height
        +float FocalLengthX
        +float FocalLengthY
        +float PrincipalPointX
        +float PrincipalPointY
        +ECameraModel Model
        +ExtractFromComponent(UCameraComponent*)
        +GetColmapModelName() FString
    }

    class FTrajectoryGenerator {
        +GenerateOrbital(FVector, float, int32) TArray~FTransform~
        +GenerateSpiral(FVector, float, float, int32) TArray~FTransform~
        +GenerateHemisphere(FVector, float, int32) TArray~FTransform~
        +Generate360(FVector, float, float, int32) TArray~FTransform~
    }

    class FColmapWriter {
        +WriteCamerasTxt(FString, TArray~FColmapCamera~)
        +WriteImagesTxt(FString, TArray~FColmapImage~)
        +WritePoints3DTxt(FString, TArray~FColmapPoint3D~)
        +WriteCamerasBin(FString, TArray~FColmapCamera~)
    }

    class FPlyExporter {
        +ExportGaussians(FString, TArray~FGaussianSplat~)
        +WriteHeader(FArchive&, int32)
        +WritePoint(FArchive&, FGaussianSplat)
    }

    UCaptureOrchestrator --> FCoordinateConverter
    UCaptureOrchestrator --> FCameraIntrinsics
    UCaptureOrchestrator --> FTrajectoryGenerator
    UCaptureOrchestrator --> FColmapWriter
    UCaptureOrchestrator --> FPlyExporter
Loading

Module Structure

graph TB
    subgraph Public["Public API"]
        UE5_3DGS["UE5_3DGS.h"]
        Types["Types.h"]
        Settings["CaptureSettings.h"]
    end

    subgraph Core["Core Systems"]
        Coord["CoordinateConverter"]
        Camera["CameraIntrinsics"]
        Traj["TrajectoryGenerator"]
        Depth["DepthExtractor"]
    end

    subgraph Export["Export Modules"]
        COLMAP["ColmapWriter"]
        PLY["PlyExporter"]
    end

    subgraph Orchestration["Orchestration"]
        Orch["CaptureOrchestrator"]
        Editor["EditorMode"]
        Widget["UI Widgets"]
    end

    Public --> Core
    Core --> Export
    Core --> Orchestration
    Export --> Orchestration

    style Public fill:#3498db,color:#fff
    style Core fill:#e74c3c,color:#fff
    style Export fill:#2ecc71,color:#fff
    style Orchestration fill:#9b59b6,color:#fff
Loading

🔧 Core Systems

Coordinate Converter

The coordinate converter handles all transformations between UE5 and COLMAP coordinate systems.

sequenceDiagram
    participant UE5 as UE5 Scene
    participant Conv as CoordinateConverter
    participant COLMAP as COLMAP Dataset

    UE5->>Conv: FVector Position (cm, LH, Z-up)
    Conv->>Conv: Apply axis remapping
    Conv->>Conv: Convert units (cm → m)
    Conv->>Conv: Adjust handedness
    Conv->>COLMAP: FVector Position (m, RH, Y-down)

    UE5->>Conv: FQuat Rotation
    Conv->>Conv: Conjugate for handedness
    Conv->>Conv: Remap quaternion axes
    Conv->>COLMAP: FQuat Rotation (COLMAP convention)
Loading
Implementation Details 
FVector FCoordinateConverter::UE5ToColmap(const FVector& UE5Position)
{
    // UE5: X-forward, Y-right, Z-up (left-handed, centimeters)
    // COLMAP: X-right, Y-down, Z-forward (right-handed, meters)
    return FVector(
        UE5Position.Y * 0.01f,   // UE5.Y → COLMAP.X (right)
        -UE5Position.Z * 0.01f,  // -UE5.Z → COLMAP.Y (down)
        UE5Position.X * 0.01f    // UE5.X → COLMAP.Z (forward)
    );
}

FQuat FCoordinateConverter::UE5ToColmapRotation(const FQuat& UE5Rotation)
{
    // Conjugate for handedness change, then remap axes
    FQuat Conjugate = UE5Rotation.IsNormalized() ?
        FQuat(-UE5Rotation.X, -UE5Rotation.Y, -UE5Rotation.Z, UE5Rotation.W) :
        UE5Rotation.GetNormalized().IsNormalized();

    return FQuat(
        Conjugate.Y,   // X component
        -Conjugate.Z,  // Y component
        Conjugate.X,   // Z component
        Conjugate.W    // W component
    );
}

Trajectory Generator

Generates optimal camera paths for 3DGS training coverage.

graph TD
    subgraph Input["Input Parameters"]
        Center["Target Center"]
        Radius["Orbit Radius"]
        Count["View Count"]
        Type["Trajectory Type"]
    end

    subgraph Generator["FTrajectoryGenerator"]
        Orbital["GenerateOrbital()"]
        Spiral["GenerateSpiral()"]
        Hemi["GenerateHemisphere()"]
        Full["Generate360()"]
    end

    subgraph Output["Output"]
        Transforms["TArray&lt;FTransform&gt;"]
        Validation["Coverage Validation"]
    end

    Input --> Generator
    Generator --> Output

    Orbital -->|"3-5 rings at<br/>different elevations"| Transforms
    Spiral -->|"Continuous helical<br/>path"| Transforms
    Hemi -->|"Fibonacci sphere<br/>sampling"| Transforms
    Full -->|"Single elevation<br/>360° ring"| Transforms
Loading
Orbital Ring Algorithm 
TArray<FTransform> FTrajectoryGenerator::GenerateOrbital(
    const FVector& TargetCenter,
    float Radius,
    int32 ViewCount,
    const TArray<float>& ElevationAngles)
{
    TArray<FTransform> Trajectory;

    int32 RingCount = ElevationAngles.Num();
    int32 ViewsPerRing = ViewCount / RingCount;

    for (int32 Ring = 0; Ring < RingCount; ++Ring)
    {
        float Elevation = FMath::DegreesToRadians(ElevationAngles[Ring]);
        float RingRadius = Radius * FMath::Cos(Elevation);
        float Height = Radius * FMath::Sin(Elevation);

        for (int32 i = 0; i < ViewsPerRing; ++i)
        {
            float Azimuth = (2.0f * PI * i) / ViewsPerRing;

            FVector Position(
                TargetCenter.X + RingRadius * FMath::Cos(Azimuth),
                TargetCenter.Y + RingRadius * FMath::Sin(Azimuth),
                TargetCenter.Z + Height
            );

            FRotator LookAt = (TargetCenter - Position).Rotation();
            Trajectory.Add(FTransform(LookAt, Position));
        }
    }

    return Trajectory;
}

Depth Extractor

Extracts depth information from UE5's scene capture system.

flowchart LR
    subgraph Capture["Scene Capture"]
        SCC["SceneCapture2D"]
        RT["RenderTarget"]
    end

    subgraph Process["Processing"]
        Read["ReadPixels"]
        Convert["Linear Depth<br/>Conversion"]
        Normalize["Normalize to<br/>[0, MaxDepth]"]
    end

    subgraph Output["Output"]
        DepthMap["Depth Map<br/>(32-bit float)"]
        PointCloud["Point Cloud<br/>(optional)"]
    end

    SCC --> RT --> Read --> Convert --> Normalize --> DepthMap
    Normalize --> PointCloud
Loading

📤 Export Formats

COLMAP Text Format

cameras.txt Specification 
# Camera list with one line of data per camera:
#   CAMERA_ID, MODEL, WIDTH, HEIGHT, PARAMS[]
# Number of cameras: N

1 PINHOLE 1920 1080 1000.0 1000.0 960.0 540.0

Supported Models:

Model Parameter Count Format
SIMPLE_PINHOLE 3 f, cx, cy
PINHOLE 4 fx, fy, cx, cy
SIMPLE_RADIAL 4 f, cx, cy, k
RADIAL 5 f, cx, cy, k1, k2
OPENCV 8 fx, fy, cx, cy, k1, k2, p1, p2
images.txt Specification 
# Image list with two lines of data per image:
#   IMAGE_ID, QW, QX, QY, QZ, TX, TY, TZ, CAMERA_ID, NAME
#   POINTS2D[] as (X, Y, POINT3D_ID)
# Number of images: N

1 0.851 0.325 -0.125 0.394 1.234 -0.567 2.891 1 frame_0000.png

2 0.923 0.284 -0.198 0.156 1.456 -0.234 3.012 1 frame_0001.png

Quaternion Convention: COLMAP uses (QW, QX, QY, QZ) order (scalar-first).

points3D.txt Specification 
# 3D point list with one line of data per point:
#   POINT3D_ID, X, Y, Z, R, G, B, ERROR, TRACK[] as (IMAGE_ID, POINT2D_IDX)

1 1.234 -0.567 2.891 128 64 32 0.5 1 0 2 1

3DGS PLY Format

PLY Header Structure 
ply
format binary_little_endian 1.0
element vertex N
property float x
property float y
property float z
property float nx
property float ny
property float nz
property float f_dc_0
property float f_dc_1
property float f_dc_2
property float f_rest_0
...
property float f_rest_44
property float opacity
property float scale_0
property float scale_1
property float scale_2
property float rot_0
property float rot_1
property float rot_2
property float rot_3
end_header
Spherical Harmonics Encoding 
graph LR
    subgraph RGB["RGB Color"]
        R["Red"]
        G["Green"]
        B["Blue"]
    end

    subgraph SH["Spherical Harmonics"]
        DC["DC Component<br/>(f_dc_0, f_dc_1, f_dc_2)"]
        Rest["Higher Order<br/>(f_rest_0 ... f_rest_44)"]
    end

    RGB -->|"C0 = 0.28209479177"| DC
    DC -->|"View-dependent<br/>effects"| Rest
Loading

Conversion Formula:

// RGB to SH DC coefficient
const float C0 = 0.28209479177387814f;
float sh_dc = (color - 0.5f) / C0;

// SH DC to RGB
float rgb = sh_dc * C0 + 0.5f;

💡 Usage Examples

Basic Scene Export

void ExportSceneToColmap()
{
    // Configure settings
    FCaptureSettings Settings;
    Settings.OutputDirectory = FPaths::ProjectSavedDir() / TEXT("Exports/MyScene");
    Settings.ImageWidth = 1920;
    Settings.ImageHeight = 1080;
    Settings.TrajectoryType = ETrajectoryType::Orbital;
    Settings.ViewCount = 150;
    Settings.TargetActor = GetWorld()->GetFirstPlayerController()->GetPawn();
    Settings.OrbitRadius = 500.0f; // 5 meters

    // Create orchestrator
    UCaptureOrchestrator* Orchestrator = NewObject<UCaptureOrchestrator>(this);
    Orchestrator->Initialize(Settings);

    // Bind completion delegate
    Orchestrator->OnCaptureComplete.AddDynamic(this, &AMyActor::OnExportComplete);

    // Start async capture
    Orchestrator->StartCapture();
}

void OnExportComplete(bool bSuccess, const FString& OutputPath)
{
    if (bSuccess)
    {
        UE_LOG(LogTemp, Log, TEXT("Export complete: %s"), *OutputPath);
    }
}

Custom Trajectory

void ExportWithCustomTrajectory()
{
    // Generate custom keyframe trajectory
    TArray<FTransform> CustomPath;

    // Add keyframes manually
    CustomPath.Add(FTransform(FRotator(0, 0, 0), FVector(0, 0, 200)));
    CustomPath.Add(FTransform(FRotator(0, 90, 0), FVector(200, 0, 200)));
    CustomPath.Add(FTransform(FRotator(0, 180, 0), FVector(0, 0, 200)));
    CustomPath.Add(FTransform(FRotator(0, 270, 0), FVector(-200, 0, 200)));

    // Interpolate between keyframes
    TArray<FTransform> InterpolatedPath =
        FTrajectoryGenerator::InterpolateKeyframes(CustomPath, 150);

    // Configure with custom trajectory
    FCaptureSettings Settings;
    Settings.TrajectoryType = ETrajectoryType::Custom;
    Settings.CustomTrajectory = InterpolatedPath;

    // ... rest of export code
}

Blueprint Integration

graph TD
    subgraph BP["Blueprint Graph"]
        Begin["Begin Play"]
        Create["Create Capture<br/>Orchestrator"]
        Config["Set Capture<br/>Settings"]
        Start["Start Capture"]
        Complete["On Capture<br/>Complete"]
    end

    Begin --> Create --> Config --> Start --> Complete
Loading

📚 API Reference

Full API documentation available in docs/api/README.md.

Quick Reference

Class Purpose Key Methods
UCaptureOrchestrator Main capture controller Initialize(), StartCapture(), StopCapture()
FCoordinateConverter Coordinate transformation UE5ToColmap(), ColmapToUE5()
FCameraIntrinsics Camera parameters ExtractFromComponent(), GetColmapModelName()
FTrajectoryGenerator Path generation GenerateOrbital(), GenerateSpiral()
FColmapWriter COLMAP export WriteCamerasTxt(), WriteImagesTxt()
FPlyExporter PLY export ExportGaussians()
FDepthExtractor Depth capture ExtractDepth(), ConvertToPointCloud()

⚙️ Configuration

FCaptureSettings

Complete Settings Reference 
USTRUCT(BlueprintType)
struct FCaptureSettings
{
    GENERATED_BODY()

    // Output Configuration
    UPROPERTY(EditAnywhere, Category = "Output")
    FString OutputDirectory;

    UPROPERTY(EditAnywhere, Category = "Output")
    EExportFormat ExportFormat = EExportFormat::COLMAP_Text;

    // Image Settings
    UPROPERTY(EditAnywhere, Category = "Image", meta = (ClampMin = "256", ClampMax = "8192"))
    int32 ImageWidth = 1920;

    UPROPERTY(EditAnywhere, Category = "Image", meta = (ClampMin = "256", ClampMax = "8192"))
    int32 ImageHeight = 1080;

    UPROPERTY(EditAnywhere, Category = "Image")
    EImageFormat ImageFormat = EImageFormat::PNG;

    // Trajectory Settings
    UPROPERTY(EditAnywhere, Category = "Trajectory")
    ETrajectoryType TrajectoryType = ETrajectoryType::Orbital;

    UPROPERTY(EditAnywhere, Category = "Trajectory", meta = (ClampMin = "10", ClampMax = "500"))
    int32 ViewCount = 150;

    UPROPERTY(EditAnywhere, Category = "Trajectory")
    float OrbitRadius = 500.0f;

    UPROPERTY(EditAnywhere, Category = "Trajectory")
    TArray<float> ElevationAngles = {-15.0f, 0.0f, 15.0f, 30.0f, 45.0f};

    // Target Settings
    UPROPERTY(EditAnywhere, Category = "Target")
    AActor* TargetActor = nullptr;

    UPROPERTY(EditAnywhere, Category = "Target")
    FVector TargetOffset = FVector::ZeroVector;

    // Advanced Settings
    UPROPERTY(EditAnywhere, Category = "Advanced")
    bool bCaptureDepth = true;

    UPROPERTY(EditAnywhere, Category = "Advanced")
    bool bGeneratePointCloud = false;

    UPROPERTY(EditAnywhere, Category = "Advanced")
    float MaxDepthDistance = 10000.0f;
};

Editor Preferences

Access via Edit → Project Settings → Plugins → UE5-3DGS:

Setting Default Description
Default Export Format COLMAP_Text Output format
Preview Visualization Enabled Show camera gizmos
Auto-validate Output Enabled Verify export integrity
Parallel Capture Enabled Multi-threaded rendering

🧪 Testing

Unit Tests

# Run all UE5-3DGS tests
UE5Editor.exe YourProject -ExecCmds="Automation RunTests UE5_3DGS" -unattended -nopause -nullrhi

# Run specific test category
UE5Editor.exe YourProject -ExecCmds="Automation RunTests UE5_3DGS.Unit.CoordinateConverter" -unattended

Test Categories

graph TD
    subgraph Unit["Unit Tests"]
        Coord["CoordinateConverter<br/>388 lines"]
        Camera["CameraIntrinsics"]
        Traj["TrajectoryGenerator"]
        Writers["Format Writers"]
    end

    subgraph Integration["Integration Tests"]
        Pipeline["Pipeline Flow<br/>589 lines"]
        Compliance["Format Compliance"]
        Orchestrator["Orchestrator"]
    end

    subgraph E2E["End-to-End"]
        Full["Full Export"]
        Training["3DGS Training<br/>Validation"]
    end

    Unit --> Integration --> E2E
Loading
Test Coverage
Module Lines Coverage
CoordinateConverter 388 95%
CameraIntrinsics 245 92%
TrajectoryGenerator 312 88%
ColmapWriter 456 90%
PlyExporter 289 85%
CaptureOrchestrator 534 82%

Total: 977 lines of test code covering 5,831 lines of production code.

📖 Documentation

Document Description
Architecture Guide System design and module interactions
API Reference Complete API documentation
User Guide Step-by-step usage instructions
Format Specifications COLMAP and PLY format details
Coordinate Systems Transformation mathematics
Troubleshooting Common issues and solutions

🤝 Contributing

Contributions are welcome! Please read our Contributing Guide for details.

Development Setup

# Clone repository
git clone https://github.com/yourusername/UE5-3DGS.git

# Generate project files (Windows)
GenerateProjectFiles.bat

# Build (Windows)
MSBuild.exe UE5_3DGS.sln /p:Configuration=Development

# Run tests
UE5Editor.exe YourProject -ExecCmds="Automation RunTests UE5_3DGS"

Code Style

  • Follow UE5 Coding Standards
  • Prefix classes: U (UObject), A (Actor), F (struct/non-UObject)
  • Use UPROPERTY/UFUNCTION macros for reflection
  • Document public APIs with /** */ comments

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

📚 References & Citations

Academic Papers

3D Gaussian Splatting 
@article{kerbl3Dgaussians,
    author    = {Kerbl, Bernhard and Kopanas, Georgios and Leimk{\"u}hler, Thomas and Drettakis, George},
    title     = {3D Gaussian Splatting for Real-Time Radiance Field Rendering},
    journal   = {ACM Transactions on Graphics},
    number    = {4},
    volume    = {42},
    month     = {July},
    year      = {2023},
    url       = {https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/}
}

Repository: graphdeco-inria/gaussian-splatting

COLMAP: Structure-from-Motion 
@inproceedings{schoenberger2016sfm,
    author    = {Sch\"{o}nberger, Johannes Lutz and Frahm, Jan-Michael},
    title     = {Structure-from-Motion Revisited},
    booktitle = {Conference on Computer Vision and Pattern Recognition (CVPR)},
    year      = {2016}
}

@inproceedings{schoenberger2016mvs,
    author    = {Sch\"{o}nberger, Johannes Lutz and Zheng, Enliang and Pollefeys, Marc and Frahm, Jan-Michael},
    title     = {Pixelwise View Selection for Unstructured Multi-View Stereo},
    booktitle = {European Conference on Computer Vision (ECCV)},
    year      = {2016}
}

Repository: colmap/colmap Documentation: colmap.github.io

Related Research

NeRF (Neural Radiance Fields):

@inproceedings{mildenhall2020nerf,
    title     = {NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis},
    author    = {Ben Mildenhall and Pratul P. Srinivasan and Matthew Tancik and Jonathan T. Barron and Ravi Ramamoorthi and Ren Ng},
    year      = {2020},
    booktitle = {ECCV}
}

Instant-NGP:

@article{mueller2022instant,
    author  = {M\"{u}ller, Thomas and Evans, Alex and Schied, Christoph and Keller, Alexander},
    title   = {Instant Neural Graphics Primitives with a Multiresolution Hash Encoding},
    journal = {ACM Trans. Graph.},
    year    = {2022},
    volume  = {41},
    number  = {4}
}

GitHub Repositories

Repository Description License
graphdeco-inria/gaussian-splatting Original 3DGS implementation Inria/Max-Planck
colmap/colmap Structure-from-Motion pipeline BSD-3-Clause
nerfstudio-project/nerfstudio NeRF training framework Apache-2.0
NVlabs/instant-ngp NVIDIA Instant-NGP NVIDIA License
sxyu/svox2 Plenoxels implementation BSD-2-Clause
apchenstu/softras Differentiable rendering MIT

Format Specifications

Format Specification Source
COLMAP cameras.txt cameras.txt format COLMAP Documentation
COLMAP images.txt images.txt format COLMAP Documentation
PLY Format PLY Polygon File Format Paul Bourke
Spherical Harmonics SH Coefficients 3DGS Repository

🙏 Acknowledgments

⬆ Back to Top

Built with ❤️ for the 3D Gaussian Splatting community

About

No description, website, or topics provided.

Resources

Readme

License

MIT license

Contributing

Contributing
Activity
Custom properties

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

No packages published

Contributors 2

  •  
  •  

Languages