C# to C++ Transpiler for SEGA Dreamcast

Advanced C# to C++ Transpiler v3.0
Tool made by Mr.Croft

A powerful Unity Editor tool that converts C# MonoBehaviour scripts into production-ready (or at least 80% of it) C++ code for SEGA Dreamcast development. This transpiler bridges the gap between modern Unity development and retro Dreamcast homebrew programming.

🎯 Overview

This transpiler is specifically designed for developers porting Unity games to the SEGA Dreamcast. It provides two conversion modes:

• Advanced Parser Mode (v2.1) - Fast, Dreamcast-optimized, lightweight regex-based conversion
• IL2CPP Backend Mode (v3.0) - Unity's official IL2CPP compiler for production-grade, semantically accurate C++ output

---

✨ Key Features

🔧 Core Capabilities

• ✅ Complete Class Conversion - Converts MonoBehaviour, Component, ScriptableObject, and regular classes
• ✅ Method Translation - Translates methods with full parameter support and return types
• ✅ Field & Property Mapping - Converts fields, properties (getters/setters), and automatic properties
• ✅ Unity Lifecycle Support - Handles Awake, Start, Update, FixedUpdate, OnDestroy, OnCollisionEnter, etc.
• ✅ Type Mapping - Automatic conversion of Unity types to Dreamcast equivalents
  • Vector3 → vec3_t
  • GameObject → game_object_t*
  • Transform → transform_t*
  • Rigidbody → rigidbody_t*
  • And 60+ more type mappings
• ✅ Unity API Translation - Converts common Unity APIs to Dreamcast equivalents
  • Time.deltaTime → deltaTime
  • Debug.Log() → debug_log()
  • Vector3.zero → vec3_zero()
  • Physics.Raycast() → physics_raycast()
  • And 50+ more API mappings

📦 Advanced Features

• 🔍 Nested Classes & Structs - Preserves nested type definitions
• 🎲 Enum Support - Converts C# enums to C++ enum classes
• 🔄 Coroutine Detection - Identifies coroutine patterns (requires manual implementation)
• 🎮 Input System Support - Handles Unity's new Input System (InputAction, PlayerControls, etc.)
• 📊 Component References - Converts GetComponent() patterns
• ⚡ Performance Optimizations - Dreamcast-specific code generation
• 📝 Code Documentation - Generates warnings and TODO lists for manual review

🖥️ User Interface

• 🎨 Clean Editor Window - Integrated Unity Editor GUI
• 📂 Drag & Drop - Simple MonoScript selection
• 💾 Export Options - Save header (.h) and implementation (.cpp) files
• 📊 Multi-Tab View - Separate tabs for Header, Implementation, Warnings, and TODOs
• 🔄 Real-time Conversion - Instant feedback on code conversion
• 📋 Copy to Clipboard - Quick copy buttons for all outputs

---

📁 Components

Core Scripts

1. AdvancedCppConverter.cs (~700 lines)

   • Main conversion engine
   • Type mapping dictionary (typeMap)
   • Unity API mapping (unityApiMap)
   • Header and implementation generation

2. CppConverterParsing.cs (~400 lines)

   • Parsing utilities
   • Field/method/property extraction
   • Line-by-line code conversion
   • Syntax transformation helpers

3. IL2CPPIntegration.cs (~300 lines)

   • Unity IL2CPP backend integration
   • Process management for il2cpp.exe
   • Generated code extraction
   • Error handling and diagnostics

Editor UI Scripts

4. CSharpToCppTranspiler.cs (~200 lines)

   • Original Advanced Parser GUI (v2.1)
   • Menu: Dreamcast > Advanced C# to C++ Transpiler

5. HybridCppTranspiler.cs (~350 lines)

   • Hybrid mode GUI with IL2CPP support (v3.0)
   • Menu: Dreamcast > Hybrid C# to C++ Transpiler v3.0

---

🚀 Installation

Prerequisites

• Unity 6000.1 or newer (tested on Unity 6000.1)
• Windows, macOS, or Linux
• IL2CPP build support (optional, for IL2CPP mode)

Setup

1. Copy the folder
   Place the CSharp2CPP folder inside your Unity project:

   /Assets/DreamcastBridge/Dreamcast/Editor/CSharp2CPP/
   

2. Wait for compilation
   Unity will automatically compile the scripts.

3. Verify installation
   Check for new menu items:

   • Dreamcast > Advanced C# to C++ Transpiler
   • Dreamcast > Hybrid C# to C++ Transpiler v3.0

---

📖 Usage Guide

Basic Workflow

1. Open the transpiler

   • Go to Window > Dreamcast > Hybrid C# to C++ Transpiler v3.0

2. Select your C# script

   • Drag & drop a MonoScript into the "C# Script" field
   • Or click the field to browse

3. Choose conversion mode

   • Advanced Parser - For Dreamcast-optimized, lightweight output
   • IL2CPP Backend - For Unity-accurate, production code

4. Convert

   • Click "Convert with Advanced Parser" or "Convert with IL2CPP"
   • Wait for conversion to complete

5. Review output

   • Check the Header tab for the .h file
   • Check the Implementation tab for the .cpp file
   • Review Warnings for potential issues
   • Check TODOs for manual implementation tasks

6. Export

   • Click "Save Header (.h)" and "Save Implementation (.cpp)"
   • Choose destination folder
   • Files are ready for Dreamcast compilation!

---

🔀 Conversion Modes

Mode 1: Advanced Parser (Recommended for Dreamcast)

Best for: Final Dreamcast builds, memory-constrained environments

Characteristics:

• ✅ Fast conversion (~1-2 seconds)
• ✅ Dreamcast-optimized code
• ✅ Minimal memory footprint
• ✅ No external dependencies
• ✅ Direct C++ output
• ⚠️ May require manual fixes for complex logic

When to use:

• You need compact, Dreamcast-ready code
• Memory is critical (Dreamcast has 16MB RAM)
• You want full control over the C++ output
• You're willing to manually implement complex features

Example output:

// Header (.h)
struct player_controller_t : public component_t
{
    float moveSpeed;
    vec3_t velocity;
    
    void move(vec3_t direction);
    void jump();
};

// Implementation (.cpp)
void player_controller_t::move(vec3_t direction)
{
    velocity = vec3_scale(direction, moveSpeed);
}

---

Mode 2: IL2CPP Backend (Reference/Testing)

Best for: Reference code, understanding Unity semantics, testing

Characteristics:

• ✅ Unity-accurate conversion
• ✅ Production-grade C++ output
• ✅ Handles complex C# features
• ✅ Complete Unity API mapping
• ❌ Requires libil2cpp runtime (~30MB)
• ❌ Not practical for Dreamcast (16MB RAM limit)

When to use:

• You need to understand how Unity handles complex code
• You want reference implementations for manual porting
• You're testing conversion accuracy
• You're developing for other platforms first

⚠️ Important: IL2CPP mode is NOT suitable for final Dreamcast builds due to memory requirements. Use it as a reference, then implement optimized versions with Advanced Parser.

Example output:

// IL2CPP generates complete Unity runtime code
// with all safety checks, metadata, and runtime features
// Great for reference, but too large for Dreamcast

---

🎮 Hybrid Workflow (Recommended)

For best results, use both modes together:

1. Start with IL2CPP (Reference)

   • Convert your script with IL2CPP mode
   • Study the generated code
   • Understand Unity's implementation of complex features

2. Implement with Advanced Parser (Production)

   • Convert the same script with Advanced Parser
   • Use IL2CPP output as reference for manual fixes
   • Optimize for Dreamcast constraints
   • Test on hardware

3. Iterate

   • Refine the C++ code
   • Add Dreamcast-specific optimizations
   • Remove unnecessary Unity abstractions

⚠️ Limitations & Manual Work Required

What the Transpiler Handles

✅ Class structure and hierarchy
✅ Field and property declarations
✅ Method signatures and basic logic
✅ Type conversions
✅ Unity lifecycle method detection
✅ Basic API mappings

What Requires Manual Implementation

❌ Unity Runtime - You must implement the Dreamcast equivalents:

• game_object_t, transform_t, component_t structures
• Physics system (rigidbody_t, collision detection)
• Input handling (input_action_t, controller support)
• Rendering system (mesh, materials, textures)

❌ Complex Logic - Advanced C# features may need manual porting:

• Coroutines (requires state machine implementation)
• LINQ queries (convert to loops)
• Lambda expressions (convert to function pointers)
• Events and delegates (implement callback systems)
• Reflection (not supported on Dreamcast)

❌ Platform-Specific Code - Dreamcast has unique constraints:

• Memory management (16MB RAM total)
• VMU (Visual Memory Unit) integration
• Controller vibration (jump pack)
• Network play (modem/broadband adapter)

---

🛠️ Type Mappings

Primitive Types

C# Type	C++ Type
int	int32_t
float	float
bool	bool
string	std::string
void	void

Unity Math Types

C# Type	Dreamcast C++ Type
Vector2	vec2_t
Vector3	vec3_t
Vector4	vec4_t
Quaternion	quat_t
Color	color_t
Matrix4x4	matrix4x4_t

Unity Components

C# Type	Dreamcast C++ Type
GameObject	game_object_t*
Transform	transform_t*
Rigidbody	rigidbody_t*
Collider	collider_t*
CharacterController	character_controller_t*
AudioSource	audio_source_t*
Camera	camera_t*

Unity APIs

C# API	Dreamcast C++ API
Time.deltaTime	deltaTime
Debug.Log()	debug_log()
Vector3.zero	vec3_zero()
Physics.Raycast()	physics_raycast()
Input.GetKey()	is_key_down()
Instantiate()	instantiate_game_object()
Destroy()	destroy_game_object()

---

🐛 Troubleshooting

Issue: IL2CPP Mode Not Available

Solution:

• Install IL2CPP build support in Unity Hub
• Verify installation path in transpiler warnings
• Use Advanced Parser mode as fallback

Issue: Conversion Errors

Solution:

• Check C# script for syntax errors
• Ensure script compiles in Unity first
• Review warnings tab for specific issues
• Try simpler test scripts first

Issue: Generated Code Won't Compile

Solution:

• Implement missing Dreamcast types (game_object_t, vec3_t, etc.)
• Review TODOs tab for manual implementation tasks
• Check type mappings are correct
• Verify header includes are available

---

📚 Documentation

For detailed guides and workflows, see the Pages documentation:

• Guia de Port para SEGA Dreamcast - Complete porting guide
• Como Usar o Transpiler - Usage tutorial
• IL2CPP Integration - IL2CPP mode details
• Workflow Otimizado - Hybrid workflow

---

🎯 Best Practices

Do's ✅

• ✅ Start with simple scripts to test the workflow
• ✅ Review all warnings and TODOs before using generated code
• ✅ Use IL2CPP mode for reference, Advanced Parser for production
• ✅ Implement Dreamcast runtime incrementally
• ✅ Test frequently on Dreamcast hardware
• ✅ Keep C# code Dreamcast-friendly (avoid heavy allocations)
• ✅ Document your manual fixes for future reference

Don'ts ❌

• ❌ Don't blindly use generated code without review
• ❌ Don't use IL2CPP runtime on Dreamcast (memory limit)
• ❌ Don't expect 100% automatic conversion
• ❌ Don't ignore warnings and TODOs
• ❌ Don't use reflection or heavy C# features
• ❌ Don't allocate large amounts of memory per frame
• ❌ Don't forget to implement Unity runtime equivalents

---

📄 License

License to use only for NON-COMMERCIAL PROJECTS.

---

Happy Dreamcast Development! 🎮✨