NV3 Getting Started - Revision history

Starfrost at 00:30, 16 June 2025

2025-06-16T00:30:48Z

← Older revision		Revision as of 00:30, 16 June 2025
Line 15:		Line 15:

	== Concepts ==		== Concepts ==
	Before we start programming, there are many concepts, some general to raw-level GPU development and other very specific to Nvidia, that need to be explained.		Before we start programming, there are many concepts, some that are more general to raw-level GPU development and other very specific to Nvidia, that need to be explained.

Starfrost at 01:15, 9 June 2025

2025-06-09T01:15:54Z

← Older revision		Revision as of 01:15, 9 June 2025
Line 2:		Line 2:

	== Introduction ==		== Introduction ==
	Most of the pages on this website are for people interested in how Nvidia's hardware works. You don't need to know everything about how the RIVA 128 works in order to actually program the hardware; you just need to be able to understand the interfaces to it and some of the registers. This is not for the faint of hearted. You are directly programming complex graphics hardware (old does not mean simple - the RIVA 128 has 3.1 million transistors, far more than any human can individually comprehend) that is not yet fully understood, but advances are being made all the time, so check back to this page for new updates. Eventually versions of this page will be made for the NV1 and RIVA TNT, and hopefully the Riva TNT2 and maybe, one day, even the GeForce 256 and its Celsius/NV1x brethren, such as the GeForce 2 and the GeForce 4 MX. If you want to write a game or other software in this way, you will be effectively writing a mini-GPU driver to manage the GPU hardware resources combined with whatever software you may wish to develop. If you want to write raw-NV software for Windows, Linux or any other operating system you will need to write a kernel driver that exposes the GPU's raw interface to usermode before you can write anything at all (this driver may be done in the future). You can get around this by using something like [https://www.delorie.com/djgpp/ DJGPP] in order to write a DOS application using a 32-bit memory model, without any of DOS's 16-bit segmented cruft. This is the recommended approach as it has the minimum amount of overhead and boilerplate code, plus workin under a DOS box such as the Windows 9x DOS box. An emulator like [https://86box.net/ 86Box] and its emulated nVIDIA RIVA support can be used for testing without access to a real system, although it has not been merged into mainline as of yet and still may not be entirely accurate to how the real hardware may behave.		Most of the pages on this website are for people interested in how Nvidia's hardware works. You don't need to know everything about how the RIVA 128 works in order to actually program the hardware; you just need to be able to understand the interfaces to it and some of the registers. This is not for the faint of hearted. You are directly programming complex graphics hardware (old does not mean simple - the RIVA 128 has 3.5 million transistors, far more than any human can individually comprehend) that is not yet fully understood, but advances are being made all the time, so check back to this page for new updates. Eventually versions of this page will be made for the NV1 and RIVA TNT, and hopefully the Riva TNT2 and maybe, one day, even the GeForce 256 and its Celsius/NV1x brethren, such as the GeForce 2 and the GeForce 4 MX. If you want to write a game or other software in this way, you will be effectively writing a mini-GPU driver to manage the GPU hardware resources combined with whatever software you may wish to develop. If you want to write raw-NV software for Windows, Linux or any other operating system you will need to write a kernel driver that exposes the GPU's raw interface to usermode before you can write anything at all (this driver may be done in the future). You can get around this by using something like [https://www.delorie.com/djgpp/ DJGPP] in order to write a DOS application using a 32-bit memory model, without any of DOS's 16-bit segmented cruft. This is the recommended approach as it has the minimum amount of overhead and boilerplate code, plus workin under a DOS box such as the Windows 9x DOS box. An emulator like [https://86box.net/ 86Box] and its emulated nVIDIA RIVA support can be used for testing without access to a real system, although it has not been merged into mainline as of yet and still may not be entirely accurate to how the real hardware may behave.

	== Environment Setup ==		== Environment Setup ==

Starfrost at 01:15, 9 June 2025

2025-06-09T01:15:42Z

← Older revision		Revision as of 01:15, 9 June 2025
Line 2:		Line 2:

	== Introduction ==		== Introduction ==
	Most of the pages on this website are for people interested in how Nvidia's hardware works. You don't need to know everything about how the RIVA 128 works in order to actually program the hardware; you just need to be able to understand the interfaces to it and some of the registers. This is not for the faint of hearted. You are directly programming complex graphics hardware, ~~and the hardware~~ is not yet fully understood, but advances are being made all the time, so check back to this page for new updates. Eventually versions of this page will be made for the NV1 and RIVA TNT, and hopefully the Riva TNT2 and maybe, one day, even the GeForce 256 and its Celsius/NV1x brethren, such as the GeForce 2 and the GeForce 4 MX. If you want to write a game or other software in this way, you will be effectively writing a mini-GPU driver to manage the GPU hardware resources combined with whatever software you may wish to develop. If you want to write raw-NV software for Windows, Linux or any other operating system you will need to write a kernel driver that exposes the GPU's raw interface to usermode before you can write anything at all (this driver may be done in the future). You can get around this by using something like [https://www.delorie.com/djgpp/ DJGPP] in order to write a DOS application using a 32-bit memory model, without any of DOS's 16-bit segmented cruft. This is the recommended approach as it has the minimum amount of overhead and boilerplate code, plus workin under a DOS box such as the Windows 9x DOS box. An emulator like [https://86box.net/ 86Box] and its emulated nVIDIA RIVA support can be used for testing without access to a real system, although it has not been merged into mainline as of yet and still may not be entirely accurate to how the real hardware may behave.		Most of the pages on this website are for people interested in how Nvidia's hardware works. You don't need to know everything about how the RIVA 128 works in order to actually program the hardware; you just need to be able to understand the interfaces to it and some of the registers. This is not for the faint of hearted. You are directly programming complex graphics hardware (old does not mean simple - the RIVA 128 has 3.1 million transistors, far more than any human can individually comprehend) that is not yet fully understood, but advances are being made all the time, so check back to this page for new updates. Eventually versions of this page will be made for the NV1 and RIVA TNT, and hopefully the Riva TNT2 and maybe, one day, even the GeForce 256 and its Celsius/NV1x brethren, such as the GeForce 2 and the GeForce 4 MX. If you want to write a game or other software in this way, you will be effectively writing a mini-GPU driver to manage the GPU hardware resources combined with whatever software you may wish to develop. If you want to write raw-NV software for Windows, Linux or any other operating system you will need to write a kernel driver that exposes the GPU's raw interface to usermode before you can write anything at all (this driver may be done in the future). You can get around this by using something like [https://www.delorie.com/djgpp/ DJGPP] in order to write a DOS application using a 32-bit memory model, without any of DOS's 16-bit segmented cruft. This is the recommended approach as it has the minimum amount of overhead and boilerplate code, plus workin under a DOS box such as the Windows 9x DOS box. An emulator like [https://86box.net/ 86Box] and its emulated nVIDIA RIVA support can be used for testing without access to a real system, although it has not been merged into mainline as of yet and still may not be entirely accurate to how the real hardware may behave.

	== Environment Setup ==		== Environment Setup ==

Starfrost at 01:10, 9 June 2025

2025-06-09T01:10:50Z

← Older revision		Revision as of 01:10, 9 June 2025
Line 3:		Line 3:
	== Introduction ==		== Introduction ==
	Most of the pages on this website are for people interested in how Nvidia's hardware works. You don't need to know everything about how the RIVA 128 works in order to actually program the hardware; you just need to be able to understand the interfaces to it and some of the registers. This is not for the faint of hearted. You are directly programming complex graphics hardware, and the hardware is not yet fully understood, but advances are being made all the time, so check back to this page for new updates. Eventually versions of this page will be made for the NV1 and RIVA TNT, and hopefully the Riva TNT2 and maybe, one day, even the GeForce 256 and its Celsius/NV1x brethren, such as the GeForce 2 and the GeForce 4 MX. If you want to write a game or other software in this way, you will be effectively writing a mini-GPU driver to manage the GPU hardware resources combined with whatever software you may wish to develop. If you want to write raw-NV software for Windows, Linux or any other operating system you will need to write a kernel driver that exposes the GPU's raw interface to usermode before you can write anything at all (this driver may be done in the future). You can get around this by using something like [https://www.delorie.com/djgpp/ DJGPP] in order to write a DOS application using a 32-bit memory model, without any of DOS's 16-bit segmented cruft. This is the recommended approach as it has the minimum amount of overhead and boilerplate code, plus workin under a DOS box such as the Windows 9x DOS box. An emulator like [https://86box.net/ 86Box] and its emulated nVIDIA RIVA support can be used for testing without access to a real system, although it has not been merged into mainline as of yet and still may not be entirely accurate to how the real hardware may behave.		Most of the pages on this website are for people interested in how Nvidia's hardware works. You don't need to know everything about how the RIVA 128 works in order to actually program the hardware; you just need to be able to understand the interfaces to it and some of the registers. This is not for the faint of hearted. You are directly programming complex graphics hardware, and the hardware is not yet fully understood, but advances are being made all the time, so check back to this page for new updates. Eventually versions of this page will be made for the NV1 and RIVA TNT, and hopefully the Riva TNT2 and maybe, one day, even the GeForce 256 and its Celsius/NV1x brethren, such as the GeForce 2 and the GeForce 4 MX. If you want to write a game or other software in this way, you will be effectively writing a mini-GPU driver to manage the GPU hardware resources combined with whatever software you may wish to develop. If you want to write raw-NV software for Windows, Linux or any other operating system you will need to write a kernel driver that exposes the GPU's raw interface to usermode before you can write anything at all (this driver may be done in the future). You can get around this by using something like [https://www.delorie.com/djgpp/ DJGPP] in order to write a DOS application using a 32-bit memory model, without any of DOS's 16-bit segmented cruft. This is the recommended approach as it has the minimum amount of overhead and boilerplate code, plus workin under a DOS box such as the Windows 9x DOS box. An emulator like [https://86box.net/ 86Box] and its emulated nVIDIA RIVA support can be used for testing without access to a real system, although it has not been merged into mainline as of yet and still may not be entirely accurate to how the real hardware may behave.

			== Environment Setup ==
			Even before beginning to learn NV3 programming you must initialise the card. There are several steps for initialising an NV card:

			1. Mapping the MMIO and VRAM of the card into memory (using either the PCI BIOS or the main API)
			2. Determining the revision, straps, manufacture-time configuration and VRAM amount on the card
			3. Configuring the card for graphics operation
			4. Creating the objects that will be used for graphics operation (you can do this later, but in many cases objects are reused, so it is a good idea to do this)

			For now, copy <code>nv3_api.h</code> and <code>nv3_ref.h</code> from [https://github.com/starfrost013/nvplayground/tree/main/src/architecture/nv3 here] to get started. This isn't yet a complete reference, but it's enough to do basic work. This will be formalised into a real SDK later.

			== Concepts ==
			Before we start programming, there are many concepts, some general to raw-level GPU development and other very specific to Nvidia, that need to be explained.

Starfrost: X

2025-06-09T00:56:57Z

New page

You can program your completely obsolete GPU the way that the company intended, using boring APIs such as Direct3D and OpenGL. Or you can do it in the cool way. The choice is yours.

== Introduction ==
Most of the pages on this website are for people interested in how Nvidia's hardware works. You don't need to know everything about how the RIVA 128 works in order to actually program the hardware; you just need to be able to understand the interfaces to it and some of the registers. This is not for the faint of hearted. You are directly programming complex graphics hardware, and the hardware is not yet fully understood, but advances are being made all the time, so check back to this page for new updates. Eventually versions of this page will be made for the NV1 and RIVA TNT, and hopefully the Riva TNT2 and maybe, one day, even the GeForce 256 and its Celsius/NV1x brethren, such as the GeForce 2 and the GeForce 4 MX. If you want to write a game or other software in this way, you will be effectively writing a mini-GPU driver to manage the GPU hardware resources combined with whatever software you may wish to develop. If you want to write raw-NV software for Windows, Linux or any other operating system you will need to write a kernel driver that exposes the GPU's raw interface to usermode before you can write anything at all (this driver may be done in the future). You can get around this by using something like [https://www.delorie.com/djgpp/ DJGPP] in order to write a DOS application using a 32-bit memory model, without any of DOS's 16-bit segmented cruft. This is the recommended approach as it has the minimum amount of overhead and boilerplate code, plus workin under a DOS box such as the Windows 9x DOS box. An emulator like [https://86box.net/ 86Box] and its emulated nVIDIA RIVA support can be used for testing without access to a real system, although it has not been merged into mainline as of yet and still may not be entirely accurate to how the real hardware may behave.