BranchesTags

Repository files navigation

DOOM-ED

DOOM-ED Screenshot

A modern open-source level editor for classic DOOM games, built with C and the Orion UI framework.

Features

  • Full-featured level editor for DOOM, DOOM II, Heretic, and other DOOM engine games
  • Support for PWAD/IWAD file formats
  • Real-time 2D map editing with visual feedback
  • 3D map preview and navigation
  • Vertex manipulation and geometry editing
  • Sector creation and editing with triangulation
  • BSP tree visualization and traversal
  • Texture management and display
  • Thing placement and properties
  • Linedef and sidedef editing
  • Inspector panels for editing map elements
  • Built with the Orion UI framework for window management
  • Cross-platform support (macOS, Linux)

Requirements

  • Orion UI (window management and UI — included as a git submodule)
  • OpenGL (3D rendering)
  • cglm (OpenGL Mathematics library for C)
  • C17 compatible compiler (gcc)
  • Make (for building with Makefile)

Building

Prerequisites

Linux (Ubuntu/Debian):

sudo apt-get install build-essential libcglm-dev libgl1-mesa-dev

macOS:

brew install cglm

OpenGL is included with Xcode Command Line Tools on macOS.

Clone the Repository

After cloning, initialize the submodules to get the WAD files and the Orion UI framework (orion-ui):

git submodule update --init --recursive

Build with Make

Build the main executable:

make

This will create the doom-ed executable in the current directory.

Clean Build Artifacts

make clean

This removes all object files, executables, and the build directory.

Troubleshooting

OpenGL headers not found: Make sure you have the OpenGL development headers installed:

  • Linux: sudo apt-get install libgl1-mesa-dev
  • macOS: OpenGL is included with Xcode Command Line Tools

cglm not found: Install cglm library:

  • Linux: sudo apt-get install libcglm-dev
  • macOS: brew install cglm

Usage

The editor requires a WAD file to load:

./doom-ed path/to/yourfile.wad

You can use the WAD files included via git submodules in the wads/ directory.

Basic Controls

  • Left Mouse: Select objects
  • Mouse Wheel: Zoom in/out
  • WASD / Arrow Keys: Navigate in map view
  • Tab: Switch top/first-person views in 3D view
  • Mouse Movement: Pan/navigate the view

The editor includes multiple inspector windows for editing different map elements (vertices, lines, sectors, things).

Project Structure

/
├── mapview/ # Core map viewer and renderer
│ ├── *.c, *.h # Map rendering, BSP, textures, sprites
│ └── main.c # Application entry point
├── editor/ # Editor-specific functionality
│ ├── editor_*.c # Drawing, input, sector editing
│ ├── radial_menu.* # Radial menu system
│ └── windows/ # Editor windows (inspector, game view, etc.)
│ └── inspector/ # Property inspector for map elements
├── ui/ # [Orion UI](https://github.com/corepunch/orion-ui) framework (git submodule)
│ ├── kernel/ # Event handling and initialization
│ ├── user/ # Window system API
│ └── commctl/ # Common controls (buttons, lists, etc.)
├── doom/ # DOOM engine headers and some source
├── hexen/ # Hexen game engine headers and source
├── tests/ # Test suite (triangulation, BSP)
├── screenshots/ # Screenshot images
├── wads/ # WAD files (git submodule)
├── Makefile # Build system
└── mapview.xcodeproj/ # Xcode project files

Testing

Run all tests:

make test

This will run the triangulation tests and BSP tree traversal tests.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add some amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request

License

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

Acknowledgments

  • id Software for creating DOOM
  • The DOOM modding community for their dedication and tools that inspired this project
  • The Orion UI framework for window management and UI

About

Proof of concept for doom editor within the game itself

Resources

Readme
Activity

Stars

0 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
DOOM-ED
DOOM-ED Screenshot
A modern open-source level editor for classic DOOM games, built with C and the Orion UI framework.
Features
  • Full-featured level editor for DOOM, DOOM II, Heretic, and other DOOM engine games
  • Support for PWAD/IWAD file formats
  • Real-time 2D map editing with visual feedback
  • 3D map preview and navigation
  • Vertex manipulation and geometry editing
  • Sector creation and editing with triangulation
  • BSP tree visualization and traversal
  • Texture management and display
  • Thing placement and properties
  • Linedef and sidedef editing
  • Inspector panels for editing map elements
  • Built with the Orion UI framework for window management
  • Cross-platform support (macOS, Linux)
Requirements
  • Orion UI (window management and UI — included as a git submodule)
  • OpenGL (3D rendering)
  • cglm (OpenGL Mathematics library for C)
  • C17 compatible compiler (gcc)
  • Make (for building with Makefile)
Building
Prerequisites
Linux (Ubuntu/Debian):
sudo apt-get install build-essential libcglm-dev libgl1-mesa-dev
macOS:
brew install cglm
OpenGL is included with Xcode Command Line Tools on macOS.
Clone the Repository
After cloning, initialize the submodules to get the WAD files and the Orion UI framework (orion-ui):
git submodule update --init --recursive
Build with Make
Build the main executable:
make
This will create the doom-ed executable in the current directory.
Clean Build Artifacts
make clean
This removes all object files, executables, and the build directory.
Troubleshooting
OpenGL headers not found:
Make sure you have the OpenGL development headers installed:
  • Linux: sudo apt-get install libgl1-mesa-dev
  • macOS: OpenGL is included with Xcode Command Line Tools
cglm not found:
Install cglm library:
  • Linux: sudo apt-get install libcglm-dev
  • macOS: brew install cglm
Usage
The editor requires a WAD file to load:
./doom-ed path/to/yourfile.wad
You can use the WAD files included via git submodules in the wads/ directory.
Basic Controls
  • Left Mouse: Select objects
  • Mouse Wheel: Zoom in/out
  • WASD / Arrow Keys: Navigate in map view
  • Tab: Switch top/first-person views in 3D view
  • Mouse Movement: Pan/navigate the view
The editor includes multiple inspector windows for editing different map elements (vertices, lines, sectors, things).
Project Structure
/
├── mapview/ # Core map viewer and renderer
│ ├── *.c, *.h # Map rendering, BSP, textures, sprites
│ └── main.c # Application entry point
├── editor/ # Editor-specific functionality
│ ├── editor_*.c # Drawing, input, sector editing
│ ├── radial_menu.* # Radial menu system
│ └── windows/ # Editor windows (inspector, game view, etc.)
│ └── inspector/ # Property inspector for map elements
├── ui/ # [Orion UI](https://github.com/corepunch/orion-ui) framework (git submodule)
│ ├── kernel/ # Event handling and initialization
│ ├── user/ # Window system API
│ └── commctl/ # Common controls (buttons, lists, etc.)
├── doom/ # DOOM engine headers and some source
├── hexen/ # Hexen game engine headers and source
├── tests/ # Test suite (triangulation, BSP)
├── screenshots/ # Screenshot images
├── wads/ # WAD files (git submodule)
├── Makefile # Build system
└── mapview.xcodeproj/ # Xcode project files

Testing
Run all tests:
make test
This will run the triangulation tests and BSP tree traversal tests.
Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add some amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request
License
This project is licensed under the GPL v3 License - see the LICENSE file for details.
Acknowledgments
  • id Software for creating DOOM
  • The DOOM modding community for their dedication and tools that inspired this project
  • The Orion UI framework for window management and UI
About
Proof of concept for doom editor within the game itself
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
DOOM-ED
DOOM-ED Screenshot
A modern open-source level editor for classic DOOM games, built with C and the Orion UI framework.
Features
  • Full-featured level editor for DOOM, DOOM II, Heretic, and other DOOM engine games
  • Support for PWAD/IWAD file formats
  • Real-time 2D map editing with visual feedback
  • 3D map preview and navigation
  • Vertex manipulation and geometry editing
  • Sector creation and editing with triangulation
  • BSP tree visualization and traversal
  • Texture management and display
  • Thing placement and properties
  • Linedef and sidedef editing
  • Inspector panels for editing map elements
  • Built with the Orion UI framework for window management
  • Cross-platform support (macOS, Linux)
Requirements
  • Orion UI (window management and UI — included as a git submodule)
  • OpenGL (3D rendering)
  • cglm (OpenGL Mathematics library for C)
  • C17 compatible compiler (gcc)
  • Make (for building with Makefile)
Building
Prerequisites
Linux (Ubuntu/Debian):
sudo apt-get install build-essential libcglm-dev libgl1-mesa-dev
macOS:
brew install cglm
OpenGL is included with Xcode Command Line Tools on macOS.
Clone the Repository
After cloning, initialize the submodules to get the WAD files and the Orion UI framework (orion-ui):
git submodule update --init --recursive
Build with Make
Build the main executable:
make
This will create the doom-ed executable in the current directory.
Clean Build Artifacts
make clean
This removes all object files, executables, and the build directory.
Troubleshooting
OpenGL headers not found:
Make sure you have the OpenGL development headers installed:
  • Linux: sudo apt-get install libgl1-mesa-dev
  • macOS: OpenGL is included with Xcode Command Line Tools
cglm not found:
Install cglm library:
  • Linux: sudo apt-get install libcglm-dev
  • macOS: brew install cglm
Usage
The editor requires a WAD file to load:
./doom-ed path/to/yourfile.wad
You can use the WAD files included via git submodules in the wads/ directory.
Basic Controls
  • Left Mouse: Select objects
  • Mouse Wheel: Zoom in/out
  • WASD / Arrow Keys: Navigate in map view
  • Tab: Switch top/first-person views in 3D view
  • Mouse Movement: Pan/navigate the view
The editor includes multiple inspector windows for editing different map elements (vertices, lines, sectors, things).
Project Structure
/
├── mapview/ # Core map viewer and renderer
│ ├── *.c, *.h # Map rendering, BSP, textures, sprites
│ └── main.c # Application entry point
├── editor/ # Editor-specific functionality
│ ├── editor_*.c # Drawing, input, sector editing
│ ├── radial_menu.* # Radial menu system
│ └── windows/ # Editor windows (inspector, game view, etc.)
│ └── inspector/ # Property inspector for map elements
├── ui/ # [Orion UI](https://github.com/corepunch/orion-ui) framework (git submodule)
│ ├── kernel/ # Event handling and initialization
│ ├── user/ # Window system API
│ └── commctl/ # Common controls (buttons, lists, etc.)
├── doom/ # DOOM engine headers and some source
├── hexen/ # Hexen game engine headers and source
├── tests/ # Test suite (triangulation, BSP)
├── screenshots/ # Screenshot images
├── wads/ # WAD files (git submodule)
├── Makefile # Build system
└── mapview.xcodeproj/ # Xcode project files

Testing
Run all tests:
make test
This will run the triangulation tests and BSP tree traversal tests.
Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add some amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request
License
This project is licensed under the GPL v3 License - see the LICENSE file for details.
Acknowledgments
  • id Software for creating DOOM
  • The DOOM modding community for their dedication and tools that inspired this project
  • The Orion UI framework for window management and UI
About
Proof of concept for doom editor within the game itself
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
DOOM-ED
DOOM-ED Screenshot
A modern open-source level editor for classic DOOM games, built with C and the Orion UI framework.
Features
  • Full-featured level editor for DOOM, DOOM II, Heretic, and other DOOM engine games
  • Support for PWAD/IWAD file formats
  • Real-time 2D map editing with visual feedback
  • 3D map preview and navigation
  • Vertex manipulation and geometry editing
  • Sector creation and editing with triangulation
  • BSP tree visualization and traversal
  • Texture management and display
  • Thing placement and properties
  • Linedef and sidedef editing
  • Inspector panels for editing map elements
  • Built with the Orion UI framework for window management
  • Cross-platform support (macOS, Linux)
Requirements
  • Orion UI (window management and UI — included as a git submodule)
  • OpenGL (3D rendering)
  • cglm (OpenGL Mathematics library for C)
  • C17 compatible compiler (gcc)
  • Make (for building with Makefile)
Building
Prerequisites
Linux (Ubuntu/Debian):
sudo apt-get install build-essential libcglm-dev libgl1-mesa-dev
macOS:
brew install cglm
OpenGL is included with Xcode Command Line Tools on macOS.
Clone the Repository
After cloning, initialize the submodules to get the WAD files and the Orion UI framework (orion-ui):
git submodule update --init --recursive
Build with Make
Build the main executable:
make
This will create the doom-ed executable in the current directory.
Clean Build Artifacts
make clean
This removes all object files, executables, and the build directory.
Troubleshooting
OpenGL headers not found:
Make sure you have the OpenGL development headers installed:
  • Linux: sudo apt-get install libgl1-mesa-dev
  • macOS: OpenGL is included with Xcode Command Line Tools
cglm not found:
Install cglm library:
  • Linux: sudo apt-get install libcglm-dev
  • macOS: brew install cglm
Usage
The editor requires a WAD file to load:
./doom-ed path/to/yourfile.wad
You can use the WAD files included via git submodules in the wads/ directory.
Basic Controls
  • Left Mouse: Select objects
  • Mouse Wheel: Zoom in/out
  • WASD / Arrow Keys: Navigate in map view
  • Tab: Switch top/first-person views in 3D view
  • Mouse Movement: Pan/navigate the view
The editor includes multiple inspector windows for editing different map elements (vertices, lines, sectors, things).
Project Structure
/
├── mapview/ # Core map viewer and renderer
│ ├── *.c, *.h # Map rendering, BSP, textures, sprites
│ └── main.c # Application entry point
├── editor/ # Editor-specific functionality
│ ├── editor_*.c # Drawing, input, sector editing
│ ├── radial_menu.* # Radial menu system
│ └── windows/ # Editor windows (inspector, game view, etc.)
│ └── inspector/ # Property inspector for map elements
├── ui/ # [Orion UI](https://github.com/corepunch/orion-ui) framework (git submodule)
│ ├── kernel/ # Event handling and initialization
│ ├── user/ # Window system API
│ └── commctl/ # Common controls (buttons, lists, etc.)
├── doom/ # DOOM engine headers and some source
├── hexen/ # Hexen game engine headers and source
├── tests/ # Test suite (triangulation, BSP)
├── screenshots/ # Screenshot images
├── wads/ # WAD files (git submodule)
├── Makefile # Build system
└── mapview.xcodeproj/ # Xcode project files

Testing
Run all tests:
make test
This will run the triangulation tests and BSP tree traversal tests.
Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add some amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request
License
This project is licensed under the GPL v3 License - see the LICENSE file for details.
Acknowledgments
  • id Software for creating DOOM
  • The DOOM modding community for their dedication and tools that inspired this project
  • The Orion UI framework for window management and UI
About
Proof of concept for doom editor within the game itself
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
DOOM-ED
DOOM-ED Screenshot
A modern open-source level editor for classic DOOM games, built with C and the Orion UI framework.
Features
  • Full-featured level editor for DOOM, DOOM II, Heretic, and other DOOM engine games
  • Support for PWAD/IWAD file formats
  • Real-time 2D map editing with visual feedback
  • 3D map preview and navigation
  • Vertex manipulation and geometry editing
  • Sector creation and editing with triangulation
  • BSP tree visualization and traversal
  • Texture management and display
  • Thing placement and properties
  • Linedef and sidedef editing
  • Inspector panels for editing map elements
  • Built with the Orion UI framework for window management
  • Cross-platform support (macOS, Linux)
Requirements
  • Orion UI (window management and UI — included as a git submodule)
  • OpenGL (3D rendering)
  • cglm (OpenGL Mathematics library for C)
  • C17 compatible compiler (gcc)
  • Make (for building with Makefile)
Building
Prerequisites
Linux (Ubuntu/Debian):
sudo apt-get install build-essential libcglm-dev libgl1-mesa-dev
macOS:
brew install cglm
OpenGL is included with Xcode Command Line Tools on macOS.
Clone the Repository
After cloning, initialize the submodules to get the WAD files and the Orion UI framework (orion-ui):
git submodule update --init --recursive
Build with Make
Build the main executable:
make
This will create the doom-ed executable in the current directory.
Clean Build Artifacts
make clean
This removes all object files, executables, and the build directory.
Troubleshooting
OpenGL headers not found:
Make sure you have the OpenGL development headers installed:
  • Linux: sudo apt-get install libgl1-mesa-dev
  • macOS: OpenGL is included with Xcode Command Line Tools
cglm not found:
Install cglm library:
  • Linux: sudo apt-get install libcglm-dev
  • macOS: brew install cglm
Usage
The editor requires a WAD file to load:
./doom-ed path/to/yourfile.wad
You can use the WAD files included via git submodules in the wads/ directory.
Basic Controls
  • Left Mouse: Select objects
  • Mouse Wheel: Zoom in/out
  • WASD / Arrow Keys: Navigate in map view
  • Tab: Switch top/first-person views in 3D view
  • Mouse Movement: Pan/navigate the view
The editor includes multiple inspector windows for editing different map elements (vertices, lines, sectors, things).
Project Structure
/
├── mapview/ # Core map viewer and renderer
│ ├── *.c, *.h # Map rendering, BSP, textures, sprites
│ └── main.c # Application entry point
├── editor/ # Editor-specific functionality
│ ├── editor_*.c # Drawing, input, sector editing
│ ├── radial_menu.* # Radial menu system
│ └── windows/ # Editor windows (inspector, game view, etc.)
│ └── inspector/ # Property inspector for map elements
├── ui/ # [Orion UI](https://github.com/corepunch/orion-ui) framework (git submodule)
│ ├── kernel/ # Event handling and initialization
│ ├── user/ # Window system API
│ └── commctl/ # Common controls (buttons, lists, etc.)
├── doom/ # DOOM engine headers and some source
├── hexen/ # Hexen game engine headers and source
├── tests/ # Test suite (triangulation, BSP)
├── screenshots/ # Screenshot images
├── wads/ # WAD files (git submodule)
├── Makefile # Build system
└── mapview.xcodeproj/ # Xcode project files

Testing
Run all tests:
make test
This will run the triangulation tests and BSP tree traversal tests.
Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add some amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request
License
This project is licensed under the GPL v3 License - see the LICENSE file for details.
Acknowledgments
  • id Software for creating DOOM
  • The DOOM modding community for their dedication and tools that inspired this project
  • The Orion UI framework for window management and UI
About
Proof of concept for doom editor within the game itself
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
DOOM-ED
DOOM-ED Screenshot
A modern open-source level editor for classic DOOM games, built with C and the Orion UI framework.
Features
  • Full-featured level editor for DOOM, DOOM II, Heretic, and other DOOM engine games
  • Support for PWAD/IWAD file formats
  • Real-time 2D map editing with visual feedback
  • 3D map preview and navigation
  • Vertex manipulation and geometry editing
  • Sector creation and editing with triangulation
  • BSP tree visualization and traversal
  • Texture management and display
  • Thing placement and properties
  • Linedef and sidedef editing
  • Inspector panels for editing map elements
  • Built with the Orion UI framework for window management
  • Cross-platform support (macOS, Linux)
Requirements
  • Orion UI (window management and UI — included as a git submodule)
  • OpenGL (3D rendering)
  • cglm (OpenGL Mathematics library for C)
  • C17 compatible compiler (gcc)
  • Make (for building with Makefile)
Building
Prerequisites
Linux (Ubuntu/Debian):
sudo apt-get install build-essential libcglm-dev libgl1-mesa-dev
macOS:
brew install cglm
OpenGL is included with Xcode Command Line Tools on macOS.
Clone the Repository
After cloning, initialize the submodules to get the WAD files and the Orion UI framework (orion-ui):
git submodule update --init --recursive
Build with Make
Build the main executable:
make
This will create the doom-ed executable in the current directory.
Clean Build Artifacts
make clean
This removes all object files, executables, and the build directory.
Troubleshooting
OpenGL headers not found:
Make sure you have the OpenGL development headers installed:
  • Linux: sudo apt-get install libgl1-mesa-dev
  • macOS: OpenGL is included with Xcode Command Line Tools
cglm not found:
Install cglm library:
  • Linux: sudo apt-get install libcglm-dev
  • macOS: brew install cglm
Usage
The editor requires a WAD file to load:
./doom-ed path/to/yourfile.wad
You can use the WAD files included via git submodules in the wads/ directory.
Basic Controls
  • Left Mouse: Select objects
  • Mouse Wheel: Zoom in/out
  • WASD / Arrow Keys: Navigate in map view
  • Tab: Switch top/first-person views in 3D view
  • Mouse Movement: Pan/navigate the view
The editor includes multiple inspector windows for editing different map elements (vertices, lines, sectors, things).
Project Structure
/
├── mapview/ # Core map viewer and renderer
│ ├── *.c, *.h # Map rendering, BSP, textures, sprites
│ └── main.c # Application entry point
├── editor/ # Editor-specific functionality
│ ├── editor_*.c # Drawing, input, sector editing
│ ├── radial_menu.* # Radial menu system
│ └── windows/ # Editor windows (inspector, game view, etc.)
│ └── inspector/ # Property inspector for map elements
├── ui/ # [Orion UI](https://github.com/corepunch/orion-ui) framework (git submodule)
│ ├── kernel/ # Event handling and initialization
│ ├── user/ # Window system API
│ └── commctl/ # Common controls (buttons, lists, etc.)
├── doom/ # DOOM engine headers and some source
├── hexen/ # Hexen game engine headers and source
├── tests/ # Test suite (triangulation, BSP)
├── screenshots/ # Screenshot images
├── wads/ # WAD files (git submodule)
├── Makefile # Build system
└── mapview.xcodeproj/ # Xcode project files

Testing
Run all tests:
make test
This will run the triangulation tests and BSP tree traversal tests.
Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add some amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request
License
This project is licensed under the GPL v3 License - see the LICENSE file for details.
Acknowledgments
  • id Software for creating DOOM
  • The DOOM modding community for their dedication and tools that inspired this project
  • The Orion UI framework for window management and UI
About
Proof of concept for doom editor within the game itself
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
DOOM-ED
DOOM-ED Screenshot
A modern open-source level editor for classic DOOM games, built with C and the Orion UI framework.
Features
  • Full-featured level editor for DOOM, DOOM II, Heretic, and other DOOM engine games
  • Support for PWAD/IWAD file formats
  • Real-time 2D map editing with visual feedback
  • 3D map preview and navigation
  • Vertex manipulation and geometry editing
  • Sector creation and editing with triangulation
  • BSP tree visualization and traversal
  • Texture management and display
  • Thing placement and properties
  • Linedef and sidedef editing
  • Inspector panels for editing map elements
  • Built with the Orion UI framework for window management
  • Cross-platform support (macOS, Linux)
Requirements
  • Orion UI (window management and UI — included as a git submodule)
  • OpenGL (3D rendering)
  • cglm (OpenGL Mathematics library for C)
  • C17 compatible compiler (gcc)
  • Make (for building with Makefile)
Building
Prerequisites
Linux (Ubuntu/Debian):
sudo apt-get install build-essential libcglm-dev libgl1-mesa-dev
macOS:
brew install cglm
OpenGL is included with Xcode Command Line Tools on macOS.
Clone the Repository
After cloning, initialize the submodules to get the WAD files and the Orion UI framework (orion-ui):
git submodule update --init --recursive
Build with Make
Build the main executable:
make
This will create the doom-ed executable in the current directory.
Clean Build Artifacts
make clean
This removes all object files, executables, and the build directory.
Troubleshooting
OpenGL headers not found:
Make sure you have the OpenGL development headers installed:
  • Linux: sudo apt-get install libgl1-mesa-dev
  • macOS: OpenGL is included with Xcode Command Line Tools
cglm not found:
Install cglm library:
  • Linux: sudo apt-get install libcglm-dev
  • macOS: brew install cglm
Usage
The editor requires a WAD file to load:
./doom-ed path/to/yourfile.wad
You can use the WAD files included via git submodules in the wads/ directory.
Basic Controls
  • Left Mouse: Select objects
  • Mouse Wheel: Zoom in/out
  • WASD / Arrow Keys: Navigate in map view
  • Tab: Switch top/first-person views in 3D view
  • Mouse Movement: Pan/navigate the view
The editor includes multiple inspector windows for editing different map elements (vertices, lines, sectors, things).
Project Structure
/
├── mapview/ # Core map viewer and renderer
│ ├── *.c, *.h # Map rendering, BSP, textures, sprites
│ └── main.c # Application entry point
├── editor/ # Editor-specific functionality
│ ├── editor_*.c # Drawing, input, sector editing
│ ├── radial_menu.* # Radial menu system
│ └── windows/ # Editor windows (inspector, game view, etc.)
│ └── inspector/ # Property inspector for map elements
├── ui/ # [Orion UI](https://github.com/corepunch/orion-ui) framework (git submodule)
│ ├── kernel/ # Event handling and initialization
│ ├── user/ # Window system API
│ └── commctl/ # Common controls (buttons, lists, etc.)
├── doom/ # DOOM engine headers and some source
├── hexen/ # Hexen game engine headers and source
├── tests/ # Test suite (triangulation, BSP)
├── screenshots/ # Screenshot images
├── wads/ # WAD files (git submodule)
├── Makefile # Build system
└── mapview.xcodeproj/ # Xcode project files

Testing
Run all tests:
make test
This will run the triangulation tests and BSP tree traversal tests.
Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add some amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request
License
This project is licensed under the GPL v3 License - see the LICENSE file for details.
Acknowledgments
  • id Software for creating DOOM
  • The DOOM modding community for their dedication and tools that inspired this project
  • The Orion UI framework for window management and UI
About
Proof of concept for doom editor within the game itself
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
DOOM-ED
DOOM-ED Screenshot
A modern open-source level editor for classic DOOM games, built with C and the Orion UI framework.
Features
  • Full-featured level editor for DOOM, DOOM II, Heretic, and other DOOM engine games
  • Support for PWAD/IWAD file formats
  • Real-time 2D map editing with visual feedback
  • 3D map preview and navigation
  • Vertex manipulation and geometry editing
  • Sector creation and editing with triangulation
  • BSP tree visualization and traversal
  • Texture management and display
  • Thing placement and properties
  • Linedef and sidedef editing
  • Inspector panels for editing map elements
  • Built with the Orion UI framework for window management
  • Cross-platform support (macOS, Linux)
Requirements
  • Orion UI (window management and UI — included as a git submodule)
  • OpenGL (3D rendering)
  • cglm (OpenGL Mathematics library for C)
  • C17 compatible compiler (gcc)
  • Make (for building with Makefile)
Building
Prerequisites
Linux (Ubuntu/Debian):
sudo apt-get install build-essential libcglm-dev libgl1-mesa-dev
macOS:
brew install cglm
OpenGL is included with Xcode Command Line Tools on macOS.
Clone the Repository
After cloning, initialize the submodules to get the WAD files and the Orion UI framework (orion-ui):
git submodule update --init --recursive
Build with Make
Build the main executable:
make
This will create the doom-ed executable in the current directory.
Clean Build Artifacts
make clean
This removes all object files, executables, and the build directory.
Troubleshooting
OpenGL headers not found:
Make sure you have the OpenGL development headers installed:
  • Linux: sudo apt-get install libgl1-mesa-dev
  • macOS: OpenGL is included with Xcode Command Line Tools
cglm not found:
Install cglm library:
  • Linux: sudo apt-get install libcglm-dev
  • macOS: brew install cglm
Usage
The editor requires a WAD file to load:
./doom-ed path/to/yourfile.wad
You can use the WAD files included via git submodules in the wads/ directory.
Basic Controls
  • Left Mouse: Select objects
  • Mouse Wheel: Zoom in/out
  • WASD / Arrow Keys: Navigate in map view
  • Tab: Switch top/first-person views in 3D view
  • Mouse Movement: Pan/navigate the view
The editor includes multiple inspector windows for editing different map elements (vertices, lines, sectors, things).
Project Structure
/
├── mapview/ # Core map viewer and renderer
│ ├── *.c, *.h # Map rendering, BSP, textures, sprites
│ └── main.c # Application entry point
├── editor/ # Editor-specific functionality
│ ├── editor_*.c # Drawing, input, sector editing
│ ├── radial_menu.* # Radial menu system
│ └── windows/ # Editor windows (inspector, game view, etc.)
│ └── inspector/ # Property inspector for map elements
├── ui/ # [Orion UI](https://github.com/corepunch/orion-ui) framework (git submodule)
│ ├── kernel/ # Event handling and initialization
│ ├── user/ # Window system API
│ └── commctl/ # Common controls (buttons, lists, etc.)
├── doom/ # DOOM engine headers and some source
├── hexen/ # Hexen game engine headers and source
├── tests/ # Test suite (triangulation, BSP)
├── screenshots/ # Screenshot images
├── wads/ # WAD files (git submodule)
├── Makefile # Build system
└── mapview.xcodeproj/ # Xcode project files

Testing
Run all tests:
make test
This will run the triangulation tests and BSP tree traversal tests.
Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add some amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request
License
This project is licensed under the GPL v3 License - see the LICENSE file for details.
Acknowledgments
  • id Software for creating DOOM
  • The DOOM modding community for their dedication and tools that inspired this project
  • The Orion UI framework for window management and UI
About
Proof of concept for doom editor within the game itself
Resources
Readme
Activity
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages