<?xml version="1.0"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="de">
		<id>https://wiki.delphigl.com/index.php?action=history&amp;feed=atom&amp;title=Tutorial_OpenGL3_Scissor_Clipping_DepthTest</id>
		<title>Tutorial OpenGL3 Scissor Clipping DepthTest - Versionsgeschichte</title>
		<link rel="self" type="application/atom+xml" href="https://wiki.delphigl.com/index.php?action=history&amp;feed=atom&amp;title=Tutorial_OpenGL3_Scissor_Clipping_DepthTest"/>
		<link rel="alternate" type="text/html" href="https://wiki.delphigl.com/index.php?title=Tutorial_OpenGL3_Scissor_Clipping_DepthTest&amp;action=history"/>
		<updated>2026-04-20T17:13:36Z</updated>
		<subtitle>Versionsgeschichte dieser Seite in DGL Wiki</subtitle>
		<generator>MediaWiki 1.27.4</generator>

	<entry>
		<id>https://wiki.delphigl.com/index.php?title=Tutorial_OpenGL3_Scissor_Clipping_DepthTest&amp;diff=25617&amp;oldid=prev</id>
		<title>Openglerf: Herraus -&gt; Heraus</title>
		<link rel="alternate" type="text/html" href="https://wiki.delphigl.com/index.php?title=Tutorial_OpenGL3_Scissor_Clipping_DepthTest&amp;diff=25617&amp;oldid=prev"/>
				<updated>2012-03-21T14:31:46Z</updated>
		
		<summary type="html">&lt;p&gt;Herraus -&amp;gt; Heraus&lt;/p&gt;
&lt;table class=&quot;diff diff-contentalign-left&quot; data-mw=&quot;interface&quot;&gt;
				&lt;col class='diff-marker' /&gt;
				&lt;col class='diff-content' /&gt;
				&lt;col class='diff-marker' /&gt;
				&lt;col class='diff-content' /&gt;
				&lt;tr style='vertical-align: top;' lang='de'&gt;
				&lt;td colspan='2' style=&quot;background-color: white; color:black; text-align: center;&quot;&gt;← Nächstältere Version&lt;/td&gt;
				&lt;td colspan='2' style=&quot;background-color: white; color:black; text-align: center;&quot;&gt;Version vom 21. März 2012, 14:31 Uhr&lt;/td&gt;
				&lt;/tr&gt;&lt;tr&gt;&lt;td colspan=&quot;2&quot; class=&quot;diff-lineno&quot; id=&quot;mw-diff-left-l10&quot; &gt;Zeile 10:&lt;/td&gt;
&lt;td colspan=&quot;2&quot; class=&quot;diff-lineno&quot;&gt;Zeile 10:&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;==Scissor==&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;==Scissor==&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;−&lt;/td&gt;&lt;td style=&quot;color:black; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #ffe49c; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;Der Scissor-Prozess wird vor dem Fragmentshader durch geführt, dieser Schritt muss nicht durchgeführt werden. Der Scissor-Test kann über [[glEnable#GL_SCISSOR_TEST]] aktiviert werden und mit Hilfe von [[glScissor]] konfiguriert werden. Genau wie beim Clipping wird die X und Y Koordinate des Bildschirmpixels als Eingabe genommen aber im gegensatz zum Clipping-Test wird im Scissor-Test nur ein X/Y Wertepaar benötigt und nicht 3. Der Test ist daher recht einfach und kann bei komplexeren Shadern immense Summen an Zeit &lt;del class=&quot;diffchange diffchange-inline&quot;&gt;herraus &lt;/del&gt;holen. Folgender Code zeigt ein einfachen InBound check.&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;+&lt;/td&gt;&lt;td style=&quot;color:black; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #a3d3ff; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;Der Scissor-Prozess wird vor dem Fragmentshader durch geführt, dieser Schritt muss nicht durchgeführt werden. Der Scissor-Test kann über [[glEnable#GL_SCISSOR_TEST]] aktiviert werden und mit Hilfe von [[glScissor]] konfiguriert werden. Genau wie beim Clipping wird die X und Y Koordinate des Bildschirmpixels als Eingabe genommen aber im gegensatz zum Clipping-Test wird im Scissor-Test nur ein X/Y Wertepaar benötigt und nicht 3. Der Test ist daher recht einfach und kann bei komplexeren Shadern immense Summen an Zeit &lt;ins class=&quot;diffchange diffchange-inline&quot;&gt;heraus &lt;/ins&gt;holen. Folgender Code zeigt ein einfachen InBound check.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;&amp;lt;source lang=&amp;quot;cpp&amp;quot;&amp;gt;bool InBoundCheck(const int X, const int Y, const int RectX, const int RectY, const unsigned int RectWidth, const unsigned int RectHeight)&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;&amp;lt;source lang=&amp;quot;cpp&amp;quot;&amp;gt;bool InBoundCheck(const int X, const int Y, const int RectX, const int RectY, const unsigned int RectWidth, const unsigned int RectHeight)&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;{&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;{&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;/table&gt;</summary>
		<author><name>Openglerf</name></author>	</entry>

	<entry>
		<id>https://wiki.delphigl.com/index.php?title=Tutorial_OpenGL3_Scissor_Clipping_DepthTest&amp;diff=24286&amp;oldid=prev</id>
		<title>Igel457: /* Tiefen-Test */</title>
		<link rel="alternate" type="text/html" href="https://wiki.delphigl.com/index.php?title=Tutorial_OpenGL3_Scissor_Clipping_DepthTest&amp;diff=24286&amp;oldid=prev"/>
				<updated>2009-11-04T15:51:00Z</updated>
		
		<summary type="html">&lt;p&gt;‎&lt;span dir=&quot;auto&quot;&gt;&lt;span class=&quot;autocomment&quot;&gt;Tiefen-Test&lt;/span&gt;&lt;/span&gt;&lt;/p&gt;
&lt;table class=&quot;diff diff-contentalign-left&quot; data-mw=&quot;interface&quot;&gt;
				&lt;col class='diff-marker' /&gt;
				&lt;col class='diff-content' /&gt;
				&lt;col class='diff-marker' /&gt;
				&lt;col class='diff-content' /&gt;
				&lt;tr style='vertical-align: top;' lang='de'&gt;
				&lt;td colspan='2' style=&quot;background-color: white; color:black; text-align: center;&quot;&gt;← Nächstältere Version&lt;/td&gt;
				&lt;td colspan='2' style=&quot;background-color: white; color:black; text-align: center;&quot;&gt;Version vom 4. November 2009, 15:51 Uhr&lt;/td&gt;
				&lt;/tr&gt;&lt;tr&gt;&lt;td colspan=&quot;2&quot; class=&quot;diff-lineno&quot; id=&quot;mw-diff-left-l27&quot; &gt;Zeile 27:&lt;/td&gt;
&lt;td colspan=&quot;2&quot; class=&quot;diff-lineno&quot;&gt;Zeile 27:&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;Es ist sinnvoll, die Tiefen-Test Funktion nur auf kleinere oder gleiche Z Werte, als im Tiefenpuffer, fest zu legen. Wenn man nun seine Dreiecke von vorne nach hinten sortiert und rendert, dann werden nur die vordersten Fragmente, der Dreiecke gezeichnet. Sollten man die Dreiecke von hinten nach vorne zeichnen, dann wird jedes Fragment in der Szene durch den Fragmentshader geschliffen und die Framerate bricht stark ein. &amp;#160;&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;Es ist sinnvoll, die Tiefen-Test Funktion nur auf kleinere oder gleiche Z Werte, als im Tiefenpuffer, fest zu legen. Wenn man nun seine Dreiecke von vorne nach hinten sortiert und rendert, dann werden nur die vordersten Fragmente, der Dreiecke gezeichnet. Sollten man die Dreiecke von hinten nach vorne zeichnen, dann wird jedes Fragment in der Szene durch den Fragmentshader geschliffen und die Framerate bricht stark ein. &amp;#160;&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;−&lt;/td&gt;&lt;td style=&quot;color:black; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #ffe49c; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;{{Hinweis|Nvidia und ATI empfehlen das Rendern in 2 Schritten zu vollziehen. Im ersten Schritt wird mit Hilfe von [[glColorMask]] alle Kanälle ab geschalten, mit [[glDepthMask]] der Tiefenpuffer schreibar gemacht, der Tiefen-Test aktiviert, der Tiefen- und Farbpuffer geleert, die Texturen deaktivert([[glDisable#GL_TEXTURE_2D]]) und die nicht Transparente Geometry gezeichnet. Dieser Schritt ist zum erfassen der Z-Koordinaten. Anschliessend aktiviert man wieder alle Farbkanälle, deaktiviert das schreiben im Tiefenpuffer, Texturen und zeichnet nun ganz normal seine nicht Transparente Geometry und dann die Transparente. Dieses 2 Schritt verfahren ist um ein vielfaches schneller und wird &lt;del class=&quot;diffchange diffchange-inline&quot;&gt;immer &lt;/del&gt;schneller, &lt;del class=&quot;diffchange diffchange-inline&quot;&gt;des so &lt;/del&gt;komplexer &lt;del class=&quot;diffchange diffchange-inline&quot;&gt;die &lt;/del&gt;Shader &lt;del class=&quot;diffchange diffchange-inline&quot;&gt;und Geometry wird&lt;/del&gt;.}}&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;+&lt;/td&gt;&lt;td style=&quot;color:black; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #a3d3ff; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;{{Hinweis|Nvidia und ATI empfehlen das Rendern in 2 Schritten zu vollziehen. Im ersten Schritt wird mit Hilfe von [[glColorMask]] alle Kanälle ab geschalten, mit [[glDepthMask]] der Tiefenpuffer schreibar gemacht, der Tiefen-Test aktiviert, der Tiefen- und Farbpuffer geleert, die Texturen deaktivert([[glDisable#GL_TEXTURE_2D]]) und die nicht Transparente Geometry gezeichnet. Dieser Schritt ist zum erfassen der Z-Koordinaten. Anschliessend aktiviert man wieder alle Farbkanälle, deaktiviert das schreiben im Tiefenpuffer, Texturen und zeichnet nun ganz normal seine nicht Transparente Geometry und dann die Transparente. Dieses 2 Schritt verfahren ist um ein vielfaches schneller und wird &lt;ins class=&quot;diffchange diffchange-inline&quot;&gt;umso &lt;/ins&gt;schneller, &lt;ins class=&quot;diffchange diffchange-inline&quot;&gt;je &lt;/ins&gt;komplexer &lt;ins class=&quot;diffchange diffchange-inline&quot;&gt;Geometry und &lt;/ins&gt;Shader &lt;ins class=&quot;diffchange diffchange-inline&quot;&gt;werden&lt;/ins&gt;.}}&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;/table&gt;</summary>
		<author><name>Igel457</name></author>	</entry>

	<entry>
		<id>https://wiki.delphigl.com/index.php?title=Tutorial_OpenGL3_Scissor_Clipping_DepthTest&amp;diff=24281&amp;oldid=prev</id>
		<title>Tak2004 am 3. November 2009 um 12:30 Uhr</title>
		<link rel="alternate" type="text/html" href="https://wiki.delphigl.com/index.php?title=Tutorial_OpenGL3_Scissor_Clipping_DepthTest&amp;diff=24281&amp;oldid=prev"/>
				<updated>2009-11-03T12:30:47Z</updated>
		
		<summary type="html">&lt;p&gt;&lt;/p&gt;
&lt;table class=&quot;diff diff-contentalign-left&quot; data-mw=&quot;interface&quot;&gt;
				&lt;col class='diff-marker' /&gt;
				&lt;col class='diff-content' /&gt;
				&lt;col class='diff-marker' /&gt;
				&lt;col class='diff-content' /&gt;
				&lt;tr style='vertical-align: top;' lang='de'&gt;
				&lt;td colspan='2' style=&quot;background-color: white; color:black; text-align: center;&quot;&gt;← Nächstältere Version&lt;/td&gt;
				&lt;td colspan='2' style=&quot;background-color: white; color:black; text-align: center;&quot;&gt;Version vom 3. November 2009, 12:30 Uhr&lt;/td&gt;
				&lt;/tr&gt;&lt;tr&gt;&lt;td colspan=&quot;2&quot; class=&quot;diff-lineno&quot; id=&quot;mw-diff-left-l1&quot; &gt;Zeile 1:&lt;/td&gt;
&lt;td colspan=&quot;2&quot; class=&quot;diff-lineno&quot;&gt;Zeile 1:&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;=Clipping, Scissor und Tiefen-Test=&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;=Clipping, Scissor und Tiefen-Test=&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;−&lt;/td&gt;&lt;td style=&quot;color:black; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #ffe49c; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;Clipping und &lt;del class=&quot;diffchange diffchange-inline&quot;&gt;Scissor &lt;/del&gt;sind Optimierungsprozesse&lt;del class=&quot;diffchange diffchange-inline&quot;&gt;, &lt;/del&gt;welche dafür sorgen, dass der Datenpool minimiert wird. Dabei ist die Clipping Funktion dafür zuständig Vertice und damit verbundene Daten aus der Renderpipeline zu werfen. Die Scissor Funktion soll den Shading-Prozess beschleunigen, also das errechnen der &lt;del class=&quot;diffchange diffchange-inline&quot;&gt;Pixelfarbe &lt;/del&gt;für ein Dreieck reduzieren.&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;+&lt;/td&gt;&lt;td style=&quot;color:black; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #a3d3ff; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;Clipping&lt;ins class=&quot;diffchange diffchange-inline&quot;&gt;, Scissor &lt;/ins&gt;und &lt;ins class=&quot;diffchange diffchange-inline&quot;&gt;Tiefen-Test &lt;/ins&gt;sind Optimierungsprozesse welche dafür sorgen, dass der Datenpool minimiert wird. Dabei ist die Clipping Funktion dafür zuständig Vertice und damit verbundene Daten aus der Renderpipeline zu werfen. Die Scissor Funktion soll den Shading-Prozess beschleunigen, also das errechnen der &lt;ins class=&quot;diffchange diffchange-inline&quot;&gt;Pixelfarben &lt;/ins&gt;für ein Dreieck reduzieren&lt;ins class=&quot;diffchange diffchange-inline&quot;&gt;.&lt;/ins&gt;&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td colspan=&quot;2&quot;&gt;&amp;#160;&lt;/td&gt;&lt;td class='diff-marker'&gt;+&lt;/td&gt;&lt;td style=&quot;color:black; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #a3d3ff; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;&lt;ins class=&quot;diffchange diffchange-inline&quot;&gt;Der Tiefen-Test hat die gleiche Aufgabe wie der Scissor-Test aber reduziert die Datenmenge auf Basis anderer Informationen und soll zugleich das korrekte Zeichnen von sich überschneidender Geometry ermöglichen&lt;/ins&gt;.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;==Clipping==&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;==Clipping==&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td colspan=&quot;2&quot; class=&quot;diff-lineno&quot; id=&quot;mw-diff-left-l24&quot; &gt;Zeile 24:&lt;/td&gt;
&lt;td colspan=&quot;2&quot; class=&quot;diff-lineno&quot;&gt;Zeile 25:&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;Wenn man in einen Artikel, Blog oder Forum von Overdraw redet, dann hat dies mit dem Tiefen-Test zu tun. Overdraw ist der Zustand, wenn ein Bildschirmpixel mehrfach gezeichnet wird, also mehrere Dreiecke die gleiche X-,Y-Koordinate auf dem Bildschirm haben.&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;Wenn man in einen Artikel, Blog oder Forum von Overdraw redet, dann hat dies mit dem Tiefen-Test zu tun. Overdraw ist der Zustand, wenn ein Bildschirmpixel mehrfach gezeichnet wird, also mehrere Dreiecke die gleiche X-,Y-Koordinate auf dem Bildschirm haben.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;Der Tiefen-Test betrachtet die Z-Koordinate von dem Bildschirmpixel und schaut in einen Tiefenpuffer nach, ob das Fragment(aktueller Pixel vom Dreieck) sichtbar wäre. Jedes Fragment, welches durch ein Dreieck in der Pipeline verarbeitet wird, besitzt einen Tiefenwert Z und dieser wird in dem Tiefenpuffer Hinterlegt. Wenn man mit [[glEnable#GL_DEPTH_TEST]] den Tiefen-Test aktiviert, dann wird jedes Fragment mit einer definierten Funktion verarbeitet. Diese Funktion kann über [[glDepthFunc]] fest gelegt werden. Wenn die Funktion erfolgreich ist und true zurück gibt, dann wird der Z Wert in den Tiefenpuffer eingetragen und wird anschliessend vom Fragmentshader verarbeitet. Sollte der Test negativ ausfallen, dann wird der Tiefenwert nicht geschrieben und das Fragment verworfen.&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;Der Tiefen-Test betrachtet die Z-Koordinate von dem Bildschirmpixel und schaut in einen Tiefenpuffer nach, ob das Fragment(aktueller Pixel vom Dreieck) sichtbar wäre. Jedes Fragment, welches durch ein Dreieck in der Pipeline verarbeitet wird, besitzt einen Tiefenwert Z und dieser wird in dem Tiefenpuffer Hinterlegt. Wenn man mit [[glEnable#GL_DEPTH_TEST]] den Tiefen-Test aktiviert, dann wird jedes Fragment mit einer definierten Funktion verarbeitet. Diese Funktion kann über [[glDepthFunc]] fest gelegt werden. Wenn die Funktion erfolgreich ist und true zurück gibt, dann wird der Z Wert in den Tiefenpuffer eingetragen und wird anschliessend vom Fragmentshader verarbeitet. Sollte der Test negativ ausfallen, dann wird der Tiefenwert nicht geschrieben und das Fragment verworfen.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;−&lt;/td&gt;&lt;td style=&quot;color:black; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #ffe49c; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;Es ist sinnvoll, die Tiefen-Test Funktion nur auf kleinere oder gleiche Z, als im Tiefenpuffer, fest zu legen. Wenn man nun seine Dreiecke von vorne nach hinten sortiert und rendert, dann werden nur die vordersten Fragmente, der Dreiecke gezeichnet. Sollten man die Dreiecke von hinten nach vorne zeichnen, dann wird jedes Fragment in der Szene durch den Fragmentshader geschliffen und die Framerate bricht stark ein. &amp;#160;&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;+&lt;/td&gt;&lt;td style=&quot;color:black; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #a3d3ff; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;Es ist sinnvoll, die Tiefen-Test Funktion nur auf kleinere oder gleiche Z &lt;ins class=&quot;diffchange diffchange-inline&quot;&gt;Werte&lt;/ins&gt;, als im Tiefenpuffer, fest zu legen. Wenn man nun seine Dreiecke von vorne nach hinten sortiert und rendert, dann werden nur die vordersten Fragmente, der Dreiecke gezeichnet. Sollten man die Dreiecke von hinten nach vorne zeichnen, dann wird jedes Fragment in der Szene durch den Fragmentshader geschliffen und die Framerate bricht stark ein. &amp;#160;&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;&amp;#160;&lt;/td&gt;&lt;td style=&quot;background-color: #f9f9f9; color: #333333; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #e6e6e6; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;−&lt;/td&gt;&lt;td style=&quot;color:black; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #ffe49c; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;{{Hinweis|Nvidia und ATI empfehlen das Rendern in 2 Schritten zu vollziehen. Im ersten Schritt wird mit Hilfe von [[glColorMask]] alle Kanälle ab geschalten, der &lt;del class=&quot;diffchange diffchange-inline&quot;&gt;Tiefentest &lt;/del&gt;aktiviert, der Tiefen- und Farbpuffer geleert, die Texturen deaktivert([[glDisable#GL_TEXTURE_2D]]) und die nicht Transparente Geometry gezeichnet. Dieser Schritt ist zum erfassen der Z-Koordinaten. Anschliessend aktiviert man wieder alle Farbkanälle, Texturen und zeichnet nun ganz normal seine nicht Transparente Geometry und dann die Transparente. Dieses 2 Schritt verfahren ist um ein vielfaches schneller und wird immer schneller, des so komplexer die Shader und Geometry wird.}}&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;+&lt;/td&gt;&lt;td style=&quot;color:black; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #a3d3ff; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;{{Hinweis|Nvidia und ATI empfehlen das Rendern in 2 Schritten zu vollziehen. Im ersten Schritt wird mit Hilfe von [[glColorMask]] alle Kanälle ab geschalten, &lt;ins class=&quot;diffchange diffchange-inline&quot;&gt;mit [[glDepthMask]] &lt;/ins&gt;der &lt;ins class=&quot;diffchange diffchange-inline&quot;&gt;Tiefenpuffer schreibar gemacht, der Tiefen-Test &lt;/ins&gt;aktiviert, der Tiefen- und Farbpuffer geleert, die Texturen deaktivert([[glDisable#GL_TEXTURE_2D]]) und die nicht Transparente Geometry gezeichnet. Dieser Schritt ist zum erfassen der Z-Koordinaten. Anschliessend aktiviert man wieder alle Farbkanälle&lt;ins class=&quot;diffchange diffchange-inline&quot;&gt;, deaktiviert das schreiben im Tiefenpuffer&lt;/ins&gt;, Texturen und zeichnet nun ganz normal seine nicht Transparente Geometry und dann die Transparente. Dieses 2 Schritt verfahren ist um ein vielfaches schneller und wird immer schneller, des so komplexer die Shader und Geometry wird.}}&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;/table&gt;</summary>
		<author><name>Tak2004</name></author>	</entry>

	<entry>
		<id>https://wiki.delphigl.com/index.php?title=Tutorial_OpenGL3_Scissor_Clipping_DepthTest&amp;diff=24280&amp;oldid=prev</id>
		<title>Tak2004: Die Seite wurde neu angelegt: „=Clipping, Scissor und Tiefen-Test= Clipping und Scissor sind Optimierungsprozesse, welche dafür sorgen, dass der Datenpool minimiert wird. Dabei ist die Clippin…“</title>
		<link rel="alternate" type="text/html" href="https://wiki.delphigl.com/index.php?title=Tutorial_OpenGL3_Scissor_Clipping_DepthTest&amp;diff=24280&amp;oldid=prev"/>
				<updated>2009-11-03T12:20:09Z</updated>
		
		<summary type="html">&lt;p&gt;Die Seite wurde neu angelegt: „=Clipping, Scissor und Tiefen-Test= Clipping und Scissor sind Optimierungsprozesse, welche dafür sorgen, dass der Datenpool minimiert wird. Dabei ist die Clippin…“&lt;/p&gt;
&lt;p&gt;&lt;b&gt;Neue Seite&lt;/b&gt;&lt;/p&gt;&lt;div&gt;=Clipping, Scissor und Tiefen-Test=&lt;br /&gt;
Clipping und Scissor sind Optimierungsprozesse, welche dafür sorgen, dass der Datenpool minimiert wird. Dabei ist die Clipping Funktion dafür zuständig Vertice und damit verbundene Daten aus der Renderpipeline zu werfen. Die Scissor Funktion soll den Shading-Prozess beschleunigen, also das errechnen der Pixelfarbe für ein Dreieck reduzieren.&lt;br /&gt;
&lt;br /&gt;
==Clipping==&lt;br /&gt;
Der Clipping-Prozess wird nach dem errechnen der Vertexpositionen auf dem Monitor durch geführt. Diese erhält man durch das Multiplizieren der Projektionsmatrix mit der Modelviewmatrix und dem anschliessenden multiplizieren mit der Vertexposition. Die neue Vertexposition hat zwar noch 4 Komponenten aber beim Clipping werden nur X und Y betrachtet.&lt;br /&gt;
Man muss in allen OpenGL Versionen den Viewport einstellen, indem man [[glViewport]] verwendet.&lt;br /&gt;
Als Parameter übergibt man X,Y,Width und Height, welche zusammen ein Rechteck ergeben.&lt;br /&gt;
Dieses Rechteck ist nun der gültige Sichtebereich und alles ausserhalb von diesen ist nicht sichtbar und wird damit nicht in der Renderpipeline benötigt. Wenn nun also ein Dreieck nicht das Rechteck schneidet, dann wird es aus der Renderpipeline entfernt. Dies reduziert die zu behandelnden Dreiecke in den Anschliessenden Prozessschritten und spart Zeit ein.&lt;br /&gt;
&lt;br /&gt;
==Scissor==&lt;br /&gt;
Der Scissor-Prozess wird vor dem Fragmentshader durch geführt, dieser Schritt muss nicht durchgeführt werden. Der Scissor-Test kann über [[glEnable#GL_SCISSOR_TEST]] aktiviert werden und mit Hilfe von [[glScissor]] konfiguriert werden. Genau wie beim Clipping wird die X und Y Koordinate des Bildschirmpixels als Eingabe genommen aber im gegensatz zum Clipping-Test wird im Scissor-Test nur ein X/Y Wertepaar benötigt und nicht 3. Der Test ist daher recht einfach und kann bei komplexeren Shadern immense Summen an Zeit herraus holen. Folgender Code zeigt ein einfachen InBound check.&lt;br /&gt;
&amp;lt;source lang=&amp;quot;cpp&amp;quot;&amp;gt;bool InBoundCheck(const int X, const int Y, const int RectX, const int RectY, const unsigned int RectWidth, const unsigned int RectHeight)&lt;br /&gt;
{&lt;br /&gt;
  if ((X&amp;lt;=RectX+RectWidth) &amp;amp;&amp;amp; (X&amp;gt;=RectX))&lt;br /&gt;
    if ((Y&amp;lt;=RectY+RectHeight) &amp;amp;&amp;amp; (Y&amp;gt;=RectY))&lt;br /&gt;
      return true;&lt;br /&gt;
  return false;&lt;br /&gt;
}&amp;lt;/source&amp;gt;&lt;br /&gt;
Alle Pixel, die den Test bestehen, werden dann an den Fragmentshader weiter gereicht und der rest wird einfach verworfen.&lt;br /&gt;
Wenn ein Shader sehr komplex ist und z.B. mehrere Texelzugriffe macht, AntiAliasing aktiviert ist und/oder komplexe Berechnungen im Fragmentshader getan werden, dann kann durch das Verwerfen von Pixeln viel Zeit eingespart werden.&lt;br /&gt;
&lt;br /&gt;
==Tiefen-Test==&lt;br /&gt;
Der Tiefen-Test wird nach dem Scissor-Test ausgeführt und soll die Anzahl der zu verarbeitenden Pixel reduzieren und Dreiecksüberschneidungen korrekt darstellen. &lt;br /&gt;
Wenn man in einen Artikel, Blog oder Forum von Overdraw redet, dann hat dies mit dem Tiefen-Test zu tun. Overdraw ist der Zustand, wenn ein Bildschirmpixel mehrfach gezeichnet wird, also mehrere Dreiecke die gleiche X-,Y-Koordinate auf dem Bildschirm haben.&lt;br /&gt;
Der Tiefen-Test betrachtet die Z-Koordinate von dem Bildschirmpixel und schaut in einen Tiefenpuffer nach, ob das Fragment(aktueller Pixel vom Dreieck) sichtbar wäre. Jedes Fragment, welches durch ein Dreieck in der Pipeline verarbeitet wird, besitzt einen Tiefenwert Z und dieser wird in dem Tiefenpuffer Hinterlegt. Wenn man mit [[glEnable#GL_DEPTH_TEST]] den Tiefen-Test aktiviert, dann wird jedes Fragment mit einer definierten Funktion verarbeitet. Diese Funktion kann über [[glDepthFunc]] fest gelegt werden. Wenn die Funktion erfolgreich ist und true zurück gibt, dann wird der Z Wert in den Tiefenpuffer eingetragen und wird anschliessend vom Fragmentshader verarbeitet. Sollte der Test negativ ausfallen, dann wird der Tiefenwert nicht geschrieben und das Fragment verworfen.&lt;br /&gt;
Es ist sinnvoll, die Tiefen-Test Funktion nur auf kleinere oder gleiche Z, als im Tiefenpuffer, fest zu legen. Wenn man nun seine Dreiecke von vorne nach hinten sortiert und rendert, dann werden nur die vordersten Fragmente, der Dreiecke gezeichnet. Sollten man die Dreiecke von hinten nach vorne zeichnen, dann wird jedes Fragment in der Szene durch den Fragmentshader geschliffen und die Framerate bricht stark ein. &lt;br /&gt;
&lt;br /&gt;
{{Hinweis|Nvidia und ATI empfehlen das Rendern in 2 Schritten zu vollziehen. Im ersten Schritt wird mit Hilfe von [[glColorMask]] alle Kanälle ab geschalten, der Tiefentest aktiviert, der Tiefen- und Farbpuffer geleert, die Texturen deaktivert([[glDisable#GL_TEXTURE_2D]]) und die nicht Transparente Geometry gezeichnet. Dieser Schritt ist zum erfassen der Z-Koordinaten. Anschliessend aktiviert man wieder alle Farbkanälle, Texturen und zeichnet nun ganz normal seine nicht Transparente Geometry und dann die Transparente. Dieses 2 Schritt verfahren ist um ein vielfaches schneller und wird immer schneller, des so komplexer die Shader und Geometry wird.}}&lt;/div&gt;</summary>
		<author><name>Tak2004</name></author>	</entry>

	</feed>