<p>There seems to be a lot of confusion around the NV1, so I tried to find a few actual sources.</p>
<p>It looks like NVidia and SGS-Thomson entered a partnership [#1] [#2] for a &quot;Multimedia Accelerator&quot;, and then NVidia sold the NV1 chip as the VRAM version, while Thomson sold the STG 2000 chip as the DRAM version.</p>
<p>The Sega Saturn did <strong>not</strong> use the NV1, the Sega Saturn used the VDP1 [#3], and while some people say they are comparable [#4], and potentially the NV1/STG2000 was based on the VDP1, they are different.</p>
<p>The VDP1 has detailed documentation [#5], and it's less of a 3D-pipeline engine and more of a sprite engine that can distort and texture sprites. That's what <a href="https://en.wikipedia.org/wiki/Texture_mapping#Forward_texture_mapping" rel="nofollow noreferrer">forward texture mapping</a> means: You iterate over the texture and map the result to the framebuffer, instead of iterating over the framebuffer pixels of the geometric primitive, sampling the texture while you do so (which is what modern engines do).</p>
<p>Forward mapping also does not have to deal with the case where a rendered quadrilateral is not flat, as the source image is flat by definition, and using a quadrilateral instead of a triangle makes iterating over it simpler.</p>
<p>I have not been able to find detailed documentation for the NV1 or the STG 2000, and apparently other people have also been looking and have found nothing. However, there's <em>some</em> basic documention for the STG 2000 [#6], which doesn't describe the rendering in detail, but says on page 9:</p>
<blockquote>
<ul>
<li>High performance acceleration of perspective-correct triangles, quadrilaterals and curves</li>
<li>[...]</li>
<li>Photorealistic 3D texture mapping, including lighting, fog, transparency, etc.</li>
<li>Video Texturing - ability to treat video as a texture.</li>
</ul>
</blockquote>
<p>So the claim that the NV1 used &quot;primitive quadrilateral rendering over triangle based rendering&quot; is wrong, both triangles and quadrilaterals are available as primitives.</p>
<p>It also doesn't say anything about the texture mapping mode used, and having triangles and curves as primitives makes it more likely that it was the modern &quot;reverse&quot; texture mapping, and not the forward mapping of the VDP1 used in the Sega Saturn.</p>
<p>In general, the assumption of the question that there was somehow an &quot;advantage&quot; to the way the NV1 implemented also does not apply: There was a lot of experimenting going on at that time, the rendering pipeline had not yet settled into the &quot;generally accepted&quot; flavour that turned out to be optimum for that era, and the actual details of the way of doing things were more historical accident, or a development of existing architectures.</p>
<hr />
<p>Thanks for pointing out the &quot;nVidia NV1 Windows 95 Software Development Kit 1.50&quot; (SDK) on Vogons [#7]. The NV/SDK/DOCS directory contains a file TECHOVER.PDF which gives a technical overview. This confirms that the primitives are (p. 8)</p>
<blockquote>
<ul>
<li>Points, lines, polylines</li>
<li>Flat triangles</li>
<li>Flat quadrilaterals (quads)</li>
<li>Flat triangle strips, triangle chains</li>
<li>Flat quadstrips, quadchains, quadmeshes</li>
</ul>
</blockquote>
<p>and in addition, either bilinear textured or quadratic textured</p>
<blockquote>
<ul>
<li>triangles</li>
<li>triangle strips and chains</li>
<li>quadrilaterals</li>
<li>quadstrips, quadchains, quadmeshes</li>
</ul>
</blockquote>
<p>They also split the &quot;standard&quot; rendering pipeline into a CPU based part (transformation, clipping, Z-sorting; if you want, vector shader operations) and an accelerated part (lighting, texture mapping, transparency, depth, buffering; if you want, pixel shader operations). So they were indeed very familiar with the &quot;standard&quot; pipeline.</p>
<p>Nevertheless, they chose to implement only forward texture mapping (which was probably their mistake), though they give their reasoning and compare the forward texture mapping approach to the inverse texture mapping approach (p. 11 ff.) The reasons more or less boil down to performance on consumer hardware, and expectations for behaviour on consumer hardware.</p>
<p>However, that means that porting games from the Sega Saturn was really easy (as noted in the comments), as the features of the VDP1 could easily be mimicked by using a particular choice of primitives and texture interpolation. (This may of course have also influenced the decision to implement forward mapping in the first place, though they did not restrict the functionality to it).</p>
<ul>
<li>#1 <a href="https://archive.org/details/edn-1995_08_17/page/n113/mode/2up?q=stg2000" rel="nofollow noreferrer">https://archive.org/details/edn-1995_08_17/page/n113/mode/2up?q=stg2000</a></li>
<li>#2 <a href="https://archive.org/details/InterActivity05Jan1996/page/n19/mode/2up?q=stg2000" rel="nofollow noreferrer">https://archive.org/details/InterActivity05Jan1996/page/n19/mode/2up?q=stg2000</a></li>
<li>#3 <a href="https://segaretro.org/VDP1_(Saturn)" rel="nofollow noreferrer">https://segaretro.org/VDP1_(Saturn)</a></li>
<li>#4 <a href="https://segaretro.org/NV1" rel="nofollow noreferrer">https://segaretro.org/NV1</a></li>
<li>#5 <a href="https://segaretro.org/images/8/8b/ST-013-R3-061694.pdf" rel="nofollow noreferrer">https://segaretro.org/images/8/8b/ST-013-R3-061694.pdf</a></li>
<li>#6 <a href="https://archive.org/details/manuallib-id-2715792/mode/1up" rel="nofollow noreferrer">https://archive.org/details/manuallib-id-2715792/mode/1up</a></li>
<li>#7 <a href="http://vogonsdrivers.com/getfile.php?fileid=706&amp;menustate=0" rel="nofollow noreferrer">http://vogonsdrivers.com/getfile.php?fileid=706&amp;menustate=0</a></li>
</ul>

CC BY-SA 4.0
2024-02-23T08:53:37.470Z
Thank you for your answer.  This morning I briefly skimmed the "nVidia NV1 Windows 95 Software Development Kit 1.50" (SDK) and it seems very promising in terms of detailed information about the NV1. In the evening I'll take a closer look. You can find it on Vogons. http://vogonsdrivers.com/getfile.php?fileid=706&menustate=0
Coder
CC BY-SA 4.0
2024-02-23T09:53:19.260Z
One has to also wonder why NV1 had Saturn gamepad ports in an already established PC joypad world, Saturn only titles (Panzer Dragoon) as well as Model2 ports which are resource/detail gimped like Saturn ports (Daytona). And then throw in some playstation titles (NASCAR, Twisted Metal and Descent). Cash-grab to capitalise on the booming (wrt PC gaming market) console gaming market?
lfgtm
CC BY-SA 4.0
2024-02-23T09:53:34.343Z
I disagree about the rendering pipeline not being established by this point. Triangle primitive for rendering pipeline was already the defacto (even though quads were supported at this point [IrisGL/OpenGL], they were already known to have their issues with rendering), even already on PC hardware (IrisVision). This also suggests NV1 being something to align itself with Saturn-esque (last minute kludge to do 3D) practices which as you said was not what the Saturn was originally designed for.
lfgtm
CC BY-SA 4.0
2024-02-23T09:54:39.757Z
Also note, two of the founders (Curtis Priem and Chris Malachowsky) were previously SUN GX engineeres and Jensen Huang coming from LSI Logic (who made chips for SGI) were all probably well versed in 3D pipeline practices. So to add and market this capability suggests something a bit more. This is all purely subjective I might add. Only they know!
lfgtm
CC BY-SA 4.0
2024-02-23T13:12:10.997Z
Internally video cards choose a particular geometry as a fundamental unit of drawing. Everything else is converted into that geometry.  So no, NV1 didn't use quads and triangles and other exotic geometry for drawing, it converted them into a basic unit. That basic unit drives design which make the question of what was the advantage of that choice even more relevant.
pmw1234
CC BY-SA 4.0
2024-02-23T16:00:58.187Z
@pmw1234 Actually, the NV1 **really** does have a hardware specific way to input different primitives, and it **doesn't** choose a particular geometry as fundamental. Read e.g. UMAOV.PDF in the SDK. This actually carries on to newer Nvidia cards as well.
dirkt
CC BY-SA 4.0
2024-02-23T16:22:22.477Z
They do indeed have a front end that accepts the primitive types, but that type is converted internally. The on chip device budget was WAY to small to create multiple pipelines for processing different geometry's.
pmw1234
CC BY-SA 4.0
2024-02-24T08:26:36.040Z
@pmw1234 But quadratic texture mapping will give different results for quads and triangles, even if it internally reduces them to the some common geometry (which cannot be quads or triangles, and which we don't know anything about, there might as well be different microcode for triangles and quads, which is more likely, given the resource constraints of the chip). So the choice of INPUT primitives together with that particular texture mapping IS important.
dirkt
CC BY-SA 4.0
2024-02-23T07:17:09.740Z
2024-02-23T12:33:41.507Z
2024-02-23T12:33:41.507Z
dirkt
<p>So much confusion. Yes the NV1 could render shaded triangles strips. But for <em>texture mapping</em> you fed the chip rectangular power-of-two textures and dedicated hardware warped the texels in the texture into screen space. (The hardware could also blend in a lighting color.) This is <em><a href="https://en.wikipedia.org/wiki/Texture_mapping#Forward_texture_mapping" rel="nofollow noreferrer">forward texture mapping</a></em>; the benefit is the graphics chip does not need memory to store textures for inverse texture mapping hardware to sample (which was a big deal when 2MB of graphics memory was expensive). You could either do bilinear texture mapping in which you provided four control points in screen space and hardware warped the texture to fit the quadrilateral defined by these corners, or hella cool <em>quadratic</em> texture mapping, in which you provided 9 control points and hardware warped the texels of the texture to fit the <em>smoothly curving</em> parabolic shape in screen space defined by these quadratic control points. Here's figure 4 in NVLIB_PRG from that excellent NV SDK resource that makes it slightly clearer:</p>
<p><a href="https://i.sstatic.net/ECT8HVZP.png" rel="nofollow noreferrer"><img src="https://i.sstatic.net/ECT8HVZP.png" alt="the 9 control points for Nvidia's quadratic forward texture mapping" /></a></p>
<p>This meant low-res textures could appear smoothly curved in screen space which was pretty amazing for 1995. However there were several disadvantages: a quadratic curve can only approximate a circle; AIUI Illustrator and 3D programs used bicubic splines and/or triangular meshes, so it was hard to convert 3D assets to use quadratic curves; shifting the inner control points only approximates perspective correction; it's hard math to clip textures properly when they go beyond the viewing frustrum (imagine if those 9 control points were out of order, then weird curved blobs could &quot;rear up&quot;, often when the viewpoint got close to textured objects).</p>
<p>As everyone says, triangles in screen space that sample from a texture map in memory (inverse texture mapping) won out.</p>

CC BY-SA 4.0
2024-09-19T10:43:48.347Z
2024-09-19T10:43:48.347Z
skierpage
<p>Quads are an overloaded term in this context. The NV1 processed geometry using triangles and did not process quads as geometry. However it did process textures as 2x2 groups that was called &quot;Quadrilinear&quot; rendering.</p>
<p>I retract my retraction, the geometry processing was triangles.</p>
<p>The NV1 had a fixed function pipeline. With a fixed function pipeline, processing textures in 2x2 groups allowed the pixels to be processed in parallel improving texture throughput which in turn improved rending speed and performance.</p>
<p>Programmable pipelines required changes that made quadrilinear rendering infeasible.</p>

CC BY-SA 4.0
2024-02-22T21:29:56.307Z
I found on archive dot org the portfolio disc of the diamond edge 3d graphics card. In the hlp file of the edge3d is stated: "Quadrilateral - A polygon with 4 vertexes". Thus the NV1 is not using triangles.
Coder
CC BY-SA 4.0
2024-02-22T22:12:32.587Z
Found something very interesting  on the website vogonsdriver dot com , the "nVidia NV1 Windows 95 Software Development Kit 1.50". But it's late now, i will take a look into it tomorrow.
Coder
CC BY-SA 4.0
2024-02-23T01:15:48.453Z
Everyone picked triangles; Microsoft followed. The PlayStation, Nintendo 64, 3dfx Voodoo, 3d Studio, etc, etc, etc existed before Direct3d.
Tommy
CC BY-SA 4.0
2024-02-23T11:43:40.410Z
I wasn't suggesting that Microsoft drove triangles in the industry.
pmw1234
CC BY-SA 4.0
2024-02-22T20:08:18.397Z
2024-02-23T13:15:54.667Z
2024-02-23T13:15:54.667Z
pmw1234
<p>What were the benefits of primitive quadrilateral rendering used by Nvidia's NV1 graphic chip over triangle based rendering? And what was the reason why Nvidia followed this approach?</p>

CC BY-SA 4.0
2024-02-21T22:22:57.237Z
By "quadratic surface rendering", do you mean quadratic texture interpolation, or quadrilateral (quad) primitives? NV1 supported both. If the former, does "triangle based rendering" mean "affine texture interpolation"? (Probably shouldn't have migrated this before that was cleared up, sorry.)
wizzwizz4
CC BY-SA 4.0
2024-02-22T07:12:35.447Z
I honestly don't know,  just the opposite of triangle based rendering. Unfortunately there is little information about it. The Voodoo 3d accelerator cards and most other 3d graphics cards for example did use triangle based rendering with the exception of Nvidias NV1. When Microsoft decided to support triangle based rendering in their first Direct3d version, Nvidia switched to triangle based rendering too with its later Riva128 chip. Triangle based rendering means setting up triangles and filling them with pixels.
Coder
CC BY-SA 4.0
2024-02-22T09:30:21.080Z
Okay, that makes sense. I assume "quadratic surface rendering" is setting up quadrilaterals and filling them with pixels (i.e. quad primitives / primitive quadrilaterals), then.
wizzwizz4
CC BY-SA 4.0
2024-02-22T11:07:48.293Z
That sounds logical to me. So probably yes.
Coder
CC BY-SA 4.0
2024-02-22T13:02:32.240Z
I've suggested an edit. It might be useful to add some background motivation to your question as well. [This question on GameDev Stack Exchange](https://gamedev.stackexchange.com/q/66312) shows some people being confused, which might provide inspiration. Maybe you could point out that previous GPUs used tris, and modern GPUs use tris (often with no support for quads).
wizzwizz4
CC BY-SA 4.0
2024-02-22T13:45:14.903Z
@wizzwizz4 I think your link is referring of quads for 3d artist, when they create the 3d objects. In blender, maya etc. they use quads, while in realty these are 2 triangles where one edge is hidden. But that's not the same as 3d chip based rendering with quads vs. triangles.
Coder
CC BY-SA 4.0
2024-02-22T14:16:40.723Z
@wizzwizz4 The [NV1](https://en.wikipedia.org/wiki/NV1) and [Texture mapping](https://en.wikipedia.org/wiki/Texture_mapping#Forward_texture_mapping) wikipedia pages suggest the NV1 used quadratic forward texture mapping, so "quadratic" was not about using quads as primitives. Then the question wouldn't make sense.
dirkt
CC BY-SA 4.0
2024-02-22T15:03:37.553Z
@​Coder This is true (linked question is not a cross-site duplicate). I was referring to the discussions in the comments. @dirkt It did, but it _also_ used quad primitives (search the NV1 article for "quadratic surface" and "quadratic 3D"). The question's about four-vertex surface primitives, though discussion of texture mapping might form part of an answer (this isn't my field of expertise).
wizzwizz4
CC BY-SA 4.0
2024-02-22T15:15:37.787Z
@wizzwizz4 there just one mentioning of "quadratic surfaces" in the NV1 article, and I am not sure if this is about quadrilaterals (which are not called "quadratic"). Typically, you either reduce a quadrilateral to two triangles, or a degenerate quadrilateral IS a triangle, and you just ignore non-planar quadrilaterals, so there's not that much difference. Either way, the different way of texture mapping is the defining technology difference.
dirkt
CC BY-SA 4.0
2024-02-22T15:56:41.003Z
@dirkt Per [Tommy's answer to _How did most fifth-generation consoles avoid wobbly graphics?_](https://retrocomputing.stackexchange.com/a/13559/278): “The Saturn has a couple of tricks up its sleeve:

    the primitive is a rectangle, not a triangle; and
    it can do multilayer 2d backgrounds and Mode 7-type floor effects.

The Saturn gets to 3d by extending its sprite blitter so that they can be distorted into any quad.” The Sega Saturn used the NV1. Tommy's explanation does sound simplified, though, so it might be wrong.
wizzwizz4
CC BY-SA 4.0
2024-05-13T02:10:28.147Z
I also came here looking for answers about claim the NV1 used "quadratic" rendering. It seems to me that almost nobody knows what they meant.

It also seems to be the case that if you try to find out what they mean by "quadratic texture mapping" most of the time you will be redirected to pages discussing or repeating the same claim made by Nvidia and, again, without explanation for what they meant.
Georgina Davenport
<gpu><hardware>
What were the benefits of quads used by Nvidia's NV1 over tri based rendering?
Coder
# What were the benefits of quads used by Nvidia's NV1 over tri based rendering?

(Asked by: username_0 on 2024-02-21)

What were the benefits of primitive quadrilateral rendering used by Nvidia's NV1 graphic chip over triangle based rendering? And what was the reason why Nvidia followed this approach?

**Tags:** gpu, hardware

> **Comments:**
> **username_1**: By "quadratic surface rendering", do you mean quadratic texture interpolation, or quadrilateral (quad) primitives? NV1 supported both. If the former, does "triangle based rendering" mean "affine texture interpolation"? (Probably shouldn't have migrated this before that was cleared up, sorry.)  
> **username_0**: I honestly don't know,  just the opposite of triangle based rendering. Unfortunately there is little information about it. The Voodoo 3d accelerator cards and most other 3d graphics cards for example did use triangle based rendering with the exception of Nvidias NV1. When Microsoft decided to support triangle based rendering in their first Direct3d version, Nvidia switched to triangle based rendering too with its later Riva128 chip. Triangle based rendering means setting up triangles and filling them with pixels.  
> **username_1**: Okay, that makes sense. I assume "quadratic surface rendering" is setting up quadrilaterals and filling them with pixels (i.e. quad primitives / primitive quadrilaterals), then.  
> **username_0**: That sounds logical to me. So probably yes.  
> **username_1**: I've suggested an edit. It might be useful to add some background motivation to your question as well. [This question on GameDev Stack Exchange](https://gamedev.stackexchange.com/q/66312) shows some people being confused, which might provide inspiration. Maybe you could point out that previous GPUs used tris, and modern GPUs use tris (often with no support for quads).  
> **username_0**: @username_1 I think your link is referring of quads for 3d artist, when they create the 3d objects. In blender, maya etc. they use quads, while in realty these are 2 triangles where one edge is hidden. But that's not the same as 3d chip based rendering with quads vs. triangles.  
> **username_2**: @username_1 The [NV1](https://en.wikipedia.org/wiki/NV1) and [Texture mapping](https://en.wikipedia.org/wiki/Texture_mapping#Forward_texture_mapping) wikipedia pages suggest the NV1 used quadratic forward texture mapping, so "quadratic" was not about using quads as primitives. Then the question wouldn't make sense.  
> **username_1**: @​username_0 This is true (linked question is not a cross-site duplicate). I was referring to the discussions in the comments. @username_2 It did, but it _also_ used quad primitives (search the NV1 article for "quadratic surface" and "quadratic 3D"). The question's about four-vertex surface primitives, though discussion of texture mapping might form part of an answer (this isn't my field of expertise).  
> **username_2**: @username_1 there just one mentioning of "quadratic surfaces" in the NV1 article, and I am not sure if this is about quadrilaterals (which are not called "quadratic"). Typically, you either reduce a quadrilateral to two triangles, or a degenerate quadrilateral IS a triangle, and you just ignore non-planar quadrilaterals, so there's not that much difference. Either way, the different way of texture mapping is the defining technology difference.  
> **username_1**: @username_2 Per [username_7's answer to _How did most fifth-generation consoles avoid wobbly graphics?_](https://retrocomputing.stackexchange.com/a/13559/278): “The Saturn has a couple of tricks up its sleeve:      the primitive is a rectangle, not a triangle; and     it can do multilayer 2d backgrounds and Mode 7-type floor effects.  The Saturn gets to 3d by extending its sprite blitter so that they can be distorted into any quad.” The Sega Saturn used the NV1. username_7's explanation does sound simplified, though, so it might be wrong.  
> **username_3**: I also came here looking for answers about claim the NV1 used "quadratic" rendering. It seems to me that almost nobody knows what they meant.  It also seems to be the case that if you try to find out what they mean by "quadratic texture mapping" most of the time you will be redirected to pages discussing or repeating the same claim made by Nvidia and, again, without explanation for what they meant.  

---

## 3 answers

### Answer by username_2 on 2024-02-23. Score: 4

There seems to be a lot of confusion around the NV1, so I tried to find a few actual sources.

It looks like NVidia and SGS-Thomson entered a partnership [#1] [#2] for a "Multimedia Accelerator", and then NVidia sold the NV1 chip as the VRAM version, while Thomson sold the STG 2000 chip as the DRAM version.

The Sega Saturn did **not** use the NV1, the Sega Saturn used the VDP1 [#3], and while some people say they are comparable [#4], and potentially the NV1/STG2000 was based on the VDP1, they are different.

The VDP1 has detailed documentation [#5], and it's less of a 3D-pipeline engine and more of a sprite engine that can distort and texture sprites. That's what [forward texture mapping](https://en.wikipedia.org/wiki/Texture_mapping#Forward_texture_mapping) means: You iterate over the texture and map the result to the framebuffer, instead of iterating over the framebuffer pixels of the geometric primitive, sampling the texture while you do so (which is what modern engines do).

Forward mapping also does not have to deal with the case where a rendered quadrilateral is not flat, as the source image is flat by definition, and using a quadrilateral instead of a triangle makes iterating over it simpler.

I have not been able to find detailed documentation for the NV1 or the STG 2000, and apparently other people have also been looking and have found nothing. However, there's *some* basic documention for the STG 2000 [#6], which doesn't describe the rendering in detail, but says on page 9:

> * High performance acceleration of perspective-correct triangles, quadrilaterals and curves
> * [...]
> * Photorealistic 3D texture mapping, including lighting, fog, transparency, etc.
> * Video Texturing - ability to treat video as a texture.

So the claim that the NV1 used "primitive quadrilateral rendering over triangle based rendering" is wrong, both triangles and quadrilaterals are available as primitives.

It also doesn't say anything about the texture mapping mode used, and having triangles and curves as primitives makes it more likely that it was the modern "reverse" texture mapping, and not the forward mapping of the VDP1 used in the Sega Saturn.

In general, the assumption of the question that there was somehow an "advantage" to the way the NV1 implemented also does not apply: There was a lot of experimenting going on at that time, the rendering pipeline had not yet settled into the "generally accepted" flavour that turned out to be optimum for that era, and the actual details of the way of doing things were more historical accident, or a development of existing architectures.

---

Thanks for pointing out the "nVidia NV1 Windows 95 Software Development Kit 1.50" (SDK) on Vogons [#7]. The NV/SDK/DOCS directory contains a file TECHOVER.PDF which gives a technical overview. This confirms that the primitives are (p. 8)

> * Points, lines, polylines
> * Flat triangles
> * Flat quadrilaterals (quads)
> * Flat triangle strips, triangle chains
> * Flat quadstrips, quadchains, quadmeshes

and in addition, either bilinear textured or quadratic textured

> * triangles
> * triangle strips and chains
> * quadrilaterals
> * quadstrips, quadchains, quadmeshes

They also split the "standard" rendering pipeline into a CPU based part (transformation, clipping, Z-sorting; if you want, vector shader operations) and an accelerated part (lighting, texture mapping, transparency, depth, buffering; if you want, pixel shader operations). So they were indeed very familiar with the "standard" pipeline.

Nevertheless, they chose to implement only forward texture mapping (which was probably their mistake), though they give their reasoning and compare the forward texture mapping approach to the inverse texture mapping approach (p. 11 ff.) The reasons more or less boil down to performance on consumer hardware, and expectations for behaviour on consumer hardware.

However, that means that porting games from the Sega Saturn was really easy (as noted in the comments), as the features of the VDP1 could easily be mimicked by using a particular choice of primitives and texture interpolation. (This may of course have also influenced the decision to implement forward mapping in the first place, though they did not restrict the functionality to it).

* #1 <https://archive.org/details/edn-1995_08_17/page/n113/mode/2up?q=stg2000>
* #2 <https://archive.org/details/InterActivity05Jan1996/page/n19/mode/2up?q=stg2000>
* #3 <https://segaretro.org/VDP1_(Saturn)>
* #4 <https://segaretro.org/NV1>
* #5 <https://segaretro.org/images/8/8b/ST-013-R3-061694.pdf>
* #6 <https://archive.org/details/manuallib-id-2715792/mode/1up>
* #7 <http://vogonsdrivers.com/getfile.php?fileid=706&menustate=0>

> **Comments:**
> **username_0**: Thank you for your answer.  This morning I briefly skimmed the "nVidia NV1 Windows 95 Software Development Kit 1.50" (SDK) and it seems very promising in terms of detailed information about the NV1. In the evening I'll take a closer look. You can find it on Vogons. http://vogonsdrivers.com/getfile.php?fileid=706&menustate=0  
> **username_4**: One has to also wonder why NV1 had Saturn gamepad ports in an already established PC joypad world, Saturn only titles (Panzer Dragoon) as well as Model2 ports which are resource/detail gimped like Saturn ports (Daytona). And then throw in some playstation titles (NASCAR, Twisted Metal and Descent). Cash-grab to capitalise on the booming (wrt PC gaming market) console gaming market?  
> **username_4**: I disagree about the rendering pipeline not being established by this point. Triangle primitive for rendering pipeline was already the defacto (even though quads were supported at this point [IrisGL/OpenGL], they were already known to have their issues with rendering), even already on PC hardware (IrisVision). This also suggests NV1 being something to align itself with Saturn-esque (last minute kludge to do 3D) practices which as you said was not what the Saturn was originally designed for.  
> **username_4**: Also note, two of the founders (Curtis Priem and Chris Malachowsky) were previously SUN GX engineeres and Jensen Huang coming from LSI Logic (who made chips for SGI) were all probably well versed in 3D pipeline practices. So to add and market this capability suggests something a bit more. This is all purely subjective I might add. Only they know!  
> **username_5**: Internally video cards choose a particular geometry as a fundamental unit of drawing. Everything else is converted into that geometry.  So no, NV1 didn't use quads and triangles and other exotic geometry for drawing, it converted them into a basic unit. That basic unit drives design which make the question of what was the advantage of that choice even more relevant.  
> **username_2**: @username_5 Actually, the NV1 **really** does have a hardware specific way to input different primitives, and it **doesn't** choose a particular geometry as fundamental. Read e.g. UMAOV.PDF in the SDK. This actually carries on to newer Nvidia cards as well.  
> **username_5**: They do indeed have a front end that accepts the primitive types, but that type is converted internally. The on chip device budget was WAY to small to create multiple pipelines for processing different geometry's.  
> **username_2**: @username_5 But quadratic texture mapping will give different results for quads and triangles, even if it internally reduces them to the some common geometry (which cannot be quads or triangles, and which we don't know anything about, there might as well be different microcode for triangles and quads, which is more likely, given the resource constraints of the chip). So the choice of INPUT primitives together with that particular texture mapping IS important.  

---

### Answer by username_6 on 2024-09-19. Score: 1

So much confusion. Yes the NV1 could render shaded triangles strips. But for *texture mapping* you fed the chip rectangular power-of-two textures and dedicated hardware warped the texels in the texture into screen space. (The hardware could also blend in a lighting color.) This is *[forward texture mapping](https://en.wikipedia.org/wiki/Texture_mapping#Forward_texture_mapping)*; the benefit is the graphics chip does not need memory to store textures for inverse texture mapping hardware to sample (which was a big deal when 2MB of graphics memory was expensive). You could either do bilinear texture mapping in which you provided four control points in screen space and hardware warped the texture to fit the quadrilateral defined by these corners, or hella cool *quadratic* texture mapping, in which you provided 9 control points and hardware warped the texels of the texture to fit the *smoothly curving* parabolic shape in screen space defined by these quadratic control points. Here's figure 4 in NVLIB\_PRG from that excellent NV SDK resource that makes it slightly clearer:

[![the 9 control points for Nvidia's quadratic forward texture mapping](https://i.sstatic.net/ECT8HVZP.png)](https://i.sstatic.net/ECT8HVZP.png)

This meant low-res textures could appear smoothly curved in screen space which was pretty amazing for 1995. However there were several disadvantages: a quadratic curve can only approximate a circle; AIUI Illustrator and 3D programs used bicubic splines and/or triangular meshes, so it was hard to convert 3D assets to use quadratic curves; shifting the inner control points only approximates perspective correction; it's hard math to clip textures properly when they go beyond the viewing frustrum (imagine if those 9 control points were out of order, then weird curved blobs could "rear up", often when the viewpoint got close to textured objects).

As everyone says, triangles in screen space that sample from a texture map in memory (inverse texture mapping) won out.


---

### Answer by username_5 on 2024-02-22. Score: -1

Quads are an overloaded term in this context. The NV1 processed geometry using triangles and did not process quads as geometry. However it did process textures as 2x2 groups that was called "Quadrilinear" rendering.

I retract my retraction, the geometry processing was triangles.

The NV1 had a fixed function pipeline. With a fixed function pipeline, processing textures in 2x2 groups allowed the pixels to be processed in parallel improving texture throughput which in turn improved rending speed and performance.

Programmable pipelines required changes that made quadrilinear rendering infeasible.

> **Comments:**
> **username_0**: I found on archive dot org the portfolio disc of the diamond edge 3d graphics card. In the hlp file of the edge3d is stated: "Quadrilateral - A polygon with 4 vertexes". Thus the NV1 is not using triangles.  
> **username_0**: Found something very interesting  on the website vogonsdriver dot com , the "nVidia NV1 Windows 95 Software Development Kit 1.50". But it's late now, i will take a look into it tomorrow.  
> **username_7**: Everyone picked triangles; Microsoft followed. The PlayStation, Nintendo 64, 3dfx Voodoo, 3d Studio, etc, etc, etc existed before Direct3d.  
> **username_5**: I wasn't suggesting that Microsoft drove triangles in the industry.  

---

