I Hacked Diablo II To Use Modern Graphics

Summary

In this video, the creator tackles the challenge of enhancing the graphics of the 25-year-old game, Diablo I, for modern hardware. They explore the game's rendering backends, focusing on Glide, and develop a Glide wrapper to translate its API calls to the more contemporary Vulkan API. The process involves debugging, understanding Glide's texture management, and overcoming API differences. The video offers a deep dive into graphics API translation, showcasing the complexities of bridging old and new technologies.

Takeaways

• 🎮 The video discusses hacking the 25-year-old game Diablo I to render with modern graphics technology.
• 📽️ The original Diablo I is still popular, and many prefer it over the remastered edition, despite its outdated graphics on modern screens.
• 💻 The game supports three rendering backends: Direct Draw, Direct 3D, and Glide, with Glide being the most optimized but unsupported on modern hardware.
• 🛠️ A Glide wrapper has been created to trick the game into using OpenGL, serving as a bridge between the old and new APIs.
• 🔧 The process involves creating a custom library that mimics the Glide API, with functions that log calls to a file for analysis.
• 👨‍💻 The video creator attempts to use the Vulkan API, a modern graphics system, to replace Glide, despite its complexity.
• 📚 The video highlights the importance of reading documentation, as misunderstanding function return values and data formats caused initial failures.
• 🖼️ The process of extracting and rendering textures from the game is detailed, including handling palettes and converting pixel data.
• 🔄 The video creator encounters synchronization issues between the game's texture loading and the Vulkan API's rendering process.
• 🕹️ The final result is a proof of concept that shows the game's sprites rendered with textures in a modern graphics context, though not without challenges.

Q & A

What is the main challenge the author faces when trying to render Diablo I with modern graphics technology?

The main challenge is that Diablo I, a 25-year-old game, was not designed with modern graphics hardware in mind. The game's rendering backends, Direct Draw, Direct 3D, and Glide, are outdated, and Glide, which the game was optimized for, is not supported by modern graphics cards without additional workarounds.

What does the author mean by 'hacks' in the context of enhancing Diablo I's graphics?

The 'hacks' refer to modifications and workarounds that the author implements to enable the game to render with modern graphics technology despite its age and the limitations of its original design.

Why does the author choose to work with the Glide API instead of Direct Draw or Direct 3D?

The author chooses to work with the Glide API because the game was optimized for it. However, Glide is not supported by modern graphics cards, so the author aims to create a wrapper that makes the game think it's using Glide while actually utilizing a more modern API like OpenGL or Vulkan.

What is the purpose of creating a Glide wrapper?

The purpose of creating a Glide wrapper is to provide a translation layer between the old Glide API and a modern graphics API like Vulkan. This allows the game to continue using its Glide calls while actually rendering with modern graphics capabilities.

What is Vulkan, and why does the author choose to use it for this project?

Vulkan is a modern graphics API designed to give graphics programmers full control over their hardware. It is chosen for this project because it offers a more direct and efficient way to interact with the graphics card, which is necessary for translating the older Glide API calls.

How does the author force Diablo I to use the Glide backend?

The author forces Diablo I to use the Glide backend by passing a specific flag ('D3dfx') to the game, which directs the game to use the Glide API for rendering.

What issues arise when the author tries to load a 64-bit library with a 32-bit game?

When the author tries to load a 64-bit library with a 32-bit game, the game crashes on the first function call due to a bad read pointer, indicating a compatibility issue between the game's architecture and the library.

Why does the game crash when the author's custom Glide library is loaded?

The game crashes because the author's library is 64-bit and the game is 32-bit, leading to compatibility issues. Additionally, the game expects the functions to clean up the stack, which is not happening due to the calling convention used in the author's library.

How does the author address the issue of function names being decorated by the compiler?

The author addresses the issue of function names being decorated by providing a .def file, which instructs the compiler to not change the function names, allowing the game to correctly call the functions from the custom library.

What is the significance of the function 'grSTWinOpen' in the context of this project?

The function 'grSTWinOpen' is significant because it is part of the Glide API that initializes the Glide rendering context. The author's incorrect return value from a function with this name initially caused the game to crash, highlighting the importance of accurate API emulation.