Add "Converting from 3D to 2D" blog post

6 files changed, 474 insertions, 4 deletions

diff --git a/html/assets/3d_to_2d.png b/html/assets/3d_to_2d.png
new file mode 100644
index 0000000..f320811
--- /dev/null
+++ b/html/assets/3d_to_2d.png
diff --git a/html/feed.xml b/html/feed.xml
index 8dc41af..732eff6 100644
--- a/html/feed.xml
+++ b/html/feed.xml
@@ -1,5 +1,5 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<rss xmlns:atom="http://www.w3.org/2005/Atom" version="2.0"><channel><title>Fryzek Concepts</title><atom:link href="https://fryzekconcepts.com/feed.xml" rel="self" type="application/rss+xml"/><link>https://fryzekconcepts.com</link><description>Lucas is a developer working on cool things</description><lastBuildDate>Mon, 22 May 2023 23:23:20 -0000</lastBuildDate><item><title>Generating Video</title><link>https://fryzekconcepts.com/notes/generating-video.html</link><description>&lt;p&gt;One thing I’m very interested in is computer graphics. This could be
+<rss xmlns:atom="http://www.w3.org/2005/Atom" version="2.0"><channel><title>Fryzek Concepts</title><atom:link href="https://fryzekconcepts.com/feed.xml" rel="self" type="application/rss+xml"/><link>https://fryzekconcepts.com</link><description>Lucas is a developer working on cool things</description><lastBuildDate>Mon, 25 Sep 2023 19:42:54 -0000</lastBuildDate><item><title>Generating Video</title><link>https://fryzekconcepts.com/notes/generating-video.html</link><description>&lt;p&gt;One thing I’m very interested in is computer graphics. This could be
 complex 3D graphics or simple 2D graphics. The idea of getting a
 computer to display visual data fascinates me. One fundamental part of
 showing visual data is interfacing with a computer monitor. This can be
@@ -1790,4 +1790,116 @@ href="https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/21558"&gt;https:
 &lt;li&gt;&lt;a
 href="https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/20180"&gt;https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/20180&lt;/a&gt;&lt;/li&gt;
 &lt;/ul&gt;
-</description><pubDate>Thu, 11 May 2023 04:00:00 -0000</pubDate><guid>https://fryzekconcepts.com/notes/mesa_23_1_contributions_behind_the_scenes.html</guid></item></channel></rss>
\ No newline at end of file
+</description><pubDate>Thu, 11 May 2023 04:00:00 -0000</pubDate><guid>https://fryzekconcepts.com/notes/mesa_23_1_contributions_behind_the_scenes.html</guid></item><item><title>Converting from 3D to 2D</title><link>https://fryzekconcepts.com/notes/converting_from_3d_to_2d.html</link><description>&lt;p&gt;Recently I’ve been working on a project where I needed to convert an
+application written in OpenGL to a software renderer. The matrix
+transformation code in OpenGL made use of the GLM library for matrix
+math, and I needed to convert the 4x4 matrices to be 3x3 matrices to
+work with the software renderer. There was some existing code to do this
+that was broken, and looked something like this:&lt;/p&gt;
+&lt;pre&gt;&lt;code&gt;glm::mat3 mat3x3 = glm::mat3(mat4x4);&lt;/code&gt;&lt;/pre&gt;
+&lt;p&gt;Don’t worry if you don’t see the problem already, I’m going to
+illustrate in more detail with the example of a translation matrix. In
+3D a standard translation matrix to translate by a vector
+&lt;code&gt;(x, y, z)&lt;/code&gt; looks something like this:&lt;/p&gt;
+&lt;pre&gt;&lt;code&gt;[1 0 0 x]
+[0 1 0 y]
+[0 0 1 z]
+[0 0 0 1]&lt;/code&gt;&lt;/pre&gt;
+&lt;p&gt;Then when we multiply this matrix by a vector like
+&lt;code&gt;(a, b, c, 1)&lt;/code&gt; the result is
+&lt;code&gt;(a + x, b + y, c + z, 1)&lt;/code&gt;. If you don’t understand why the
+matrix is 4x4 or why we have that extra 1 at the end don’t worry, I’ll
+explain that in more detail later.&lt;/p&gt;
+&lt;p&gt;Now using the existing conversion code to get a 3x3 matrix will
+simply take the first 3 columns and first 3 rows of the matrix and
+produce a 3x3 matrix from those. Converting the translation matrix above
+using this code produces the following matrix:&lt;/p&gt;
+&lt;pre&gt;&lt;code&gt;[1 0 0]
+[0 1 0]
+[0 0 1]&lt;/code&gt;&lt;/pre&gt;
+&lt;p&gt;See the problem now? The &lt;code&gt;(x, y, z)&lt;/code&gt; values disappeared!
+In the conversion process we lost these critical values from the
+translation matrix, and now if we multiply by this matrix nothing will
+happen since we are just left with the identity matrix. So if we can’t
+use this simple “cast” function in GLM, what can we use?&lt;/p&gt;
+&lt;p&gt;Well one thing we can do is preserve the last column and last row of
+the matrix. So assume we have a 4x4 matrix like this:&lt;/p&gt;
+&lt;pre&gt;&lt;code&gt;[a b c d]
+[e f g h]
+[i j k l]
+[m n o p]&lt;/code&gt;&lt;/pre&gt;
+&lt;p&gt;Then preserving the last row and column we should get a matrix like
+this:&lt;/p&gt;
+&lt;pre&gt;&lt;code&gt;[a b d]
+[e f h]
+[m n p]&lt;/code&gt;&lt;/pre&gt;
+&lt;p&gt;And if we use this conversion process for the same translation matrix
+we will get:&lt;/p&gt;
+&lt;pre&gt;&lt;code&gt;[1 0 x]
+[0 1 y]
+[0 0 1]&lt;/code&gt;&lt;/pre&gt;
+&lt;p&gt;Now we see that the &lt;code&gt;(x, y)&lt;/code&gt; part of the translation is
+preserved, and if we try to multiply this matrix by the vector
+&lt;code&gt;(a, b, 1)&lt;/code&gt; the result will be
+&lt;code&gt;(a + x, b + y, 1)&lt;/code&gt;. The translation is preserved in the
+conversion!&lt;/p&gt;
+&lt;h2 id="why-do-we-have-to-use-this-conversion"&gt;Why do we have to use
+this conversion?&lt;/h2&gt;
+&lt;p&gt;The reason the conversion is more complicated is hidden in how we
+defined the translation matrix and vector we wanted to translate. The
+vector was actually a 4D vector with the final component set to 1. The
+reason we do this is that we actually want to represent an affine space
+instead of just a vector space. An affine space being a type of space
+where you can have both points and vectors. A point is exactly what you
+would expect it to be just a point in space from some origin, and vector
+is a direction with magnitude but no origin. This is important because
+strictly speaking translation isn’t actually defined for vectors in a
+normal vector space. Additionally if you try to construct a matrix to
+represent translation for a vector space you’ll find that its impossible
+to derive a matrix to do this and that operation is not a linear
+function. On the other hand operations like translation are well defined
+in an affine space and do what you would expect.&lt;/p&gt;
+&lt;p&gt;To get around the problem of vector spaces, mathematicians more
+clever than I figured out you can implement an affine space in a normal
+vector space by increasing the dimension of the vector space by one, and
+by adding an extra row and column to the transformation matrices used.
+They called this a &lt;strong&gt;homogeneous coordinate system&lt;/strong&gt;. This
+lets you say that a vector is actually just a point if the 4th component
+is 1, but if its 0 its just a vector. Using this abstraction one can
+implement all the well defined operations for an affine space (like
+translation!).&lt;/p&gt;
+&lt;p&gt;So using the “homogeneous coordinate system” abstraction, translation
+is an operation that defined by taking a point and moving it by a
+vector. Lets look at how that works with the translation matrix I used
+as an example above. If you multiply that matrix by a 4D vector where
+the 4th component is 0, it will just return the same vector. Now if we
+multiply by a 4D vector where the 4th component is 1, it will return the
+point translated by the vector we used to construct that translation
+matrix. This implements the translation operation as its defined in an
+affine space!&lt;/p&gt;
+&lt;p&gt;If you’re interested in understanding more about homogeneous
+coordinate spaces, (like how the translation matrix is derived in the
+first place) I would encourage you to look at resources like &lt;a
+href="https://books.google.ca/books/about/Mathematics_for_Computer_Graphics_Applic.html?id=YmQy799flPkC&amp;amp;redir_esc=y"&gt;“Mathematics
+for Computer Graphics Applications”&lt;/a&gt;. They provide a much more
+detailed explanation than I am providing here. (The homogeneous
+coordinate system also has some benefits for representing projections
+which I won’t get into here, but are explained in that text book.)&lt;/p&gt;
+&lt;p&gt;Now to finally answer the question about why we needed to preserve
+those final columns and vectors. Based on what we now know, we weren’t
+actually just converting from a “3D space” to a “2D space” we were
+converting from a “3D homogeneous space” to a “2D homogeneous space”.
+The process of converting from a higher dimension matrix to a lower
+dimensional matrix is lossy and some transformation details are going to
+be lost in process (like for example the translation along the z-axis).
+There is no way to tell what kind of space a given matrix is supposed to
+transform just by looking at the matrix itself. The matrix does not
+carry any information about about what space its operating in and any
+conversion function would need to know that information to properly
+convert that matrix. Therefore we need develop our own conversion
+function that preserves the transformations that are important to our
+application when moving from a “3D homogeneous space” to a “2D
+homogeneous space”.&lt;/p&gt;
+&lt;p&gt;Hopefully this explanation helps if you are every working on
+converting 3D transformation code to 2D.&lt;/p&gt;
+</description><pubDate>Mon, 25 Sep 2023 04:00:00 -0000</pubDate><guid>https://fryzekconcepts.com/notes/converting_from_3d_to_2d.html</guid></item></channel></rss>
\ No newline at end of file
diff --git a/html/graphics_feed.xml b/html/graphics_feed.xml
index e86b38f..1b188ef 100644
--- a/html/graphics_feed.xml
+++ b/html/graphics_feed.xml
@@ -1,5 +1,5 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<rss xmlns:atom="http://www.w3.org/2005/Atom" version="2.0"><channel><title>Fryzek Concepts</title><atom:link href="https://fryzekconcepts.com/feed.xml" rel="self" type="application/rss+xml"/><link>https://fryzekconcepts.com</link><description>Lucas is a developer working on cool things</description><lastBuildDate>Mon, 22 May 2023 23:23:21 -0000</lastBuildDate><item><title>2022 Graphics Team Contributions at Igalia</title><link>https://fryzekconcepts.com/notes/2022_igalia_graphics_team.html</link><description>&lt;p&gt;This year I started a new job working with &lt;a
+<rss xmlns:atom="http://www.w3.org/2005/Atom" version="2.0"><channel><title>Fryzek Concepts</title><atom:link href="https://fryzekconcepts.com/feed.xml" rel="self" type="application/rss+xml"/><link>https://fryzekconcepts.com</link><description>Lucas is a developer working on cool things</description><lastBuildDate>Mon, 25 Sep 2023 19:42:55 -0000</lastBuildDate><item><title>2022 Graphics Team Contributions at Igalia</title><link>https://fryzekconcepts.com/notes/2022_igalia_graphics_team.html</link><description>&lt;p&gt;This year I started a new job working with &lt;a
 href="https://www.igalia.com/technology/graphics"&gt;Igalia’s Graphics
 Team&lt;/a&gt;. For those of you who don’t know &lt;a
 href="https://www.igalia.com/"&gt;Igalia&lt;/a&gt; they are a &lt;a
@@ -552,4 +552,116 @@ href="https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/21558"&gt;https:
 &lt;li&gt;&lt;a
 href="https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/20180"&gt;https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/20180&lt;/a&gt;&lt;/li&gt;
 &lt;/ul&gt;
-</description><pubDate>Thu, 11 May 2023 04:00:00 -0000</pubDate><guid>https://fryzekconcepts.com/notes/mesa_23_1_contributions_behind_the_scenes.html</guid></item></channel></rss>
\ No newline at end of file
+</description><pubDate>Thu, 11 May 2023 04:00:00 -0000</pubDate><guid>https://fryzekconcepts.com/notes/mesa_23_1_contributions_behind_the_scenes.html</guid></item><item><title>Converting from 3D to 2D</title><link>https://fryzekconcepts.com/notes/converting_from_3d_to_2d.html</link><description>&lt;p&gt;Recently I’ve been working on a project where I needed to convert an
+application written in OpenGL to a software renderer. The matrix
+transformation code in OpenGL made use of the GLM library for matrix
+math, and I needed to convert the 4x4 matrices to be 3x3 matrices to
+work with the software renderer. There was some existing code to do this
+that was broken, and looked something like this:&lt;/p&gt;
+&lt;pre&gt;&lt;code&gt;glm::mat3 mat3x3 = glm::mat3(mat4x4);&lt;/code&gt;&lt;/pre&gt;
+&lt;p&gt;Don’t worry if you don’t see the problem already, I’m going to
+illustrate in more detail with the example of a translation matrix. In
+3D a standard translation matrix to translate by a vector
+&lt;code&gt;(x, y, z)&lt;/code&gt; looks something like this:&lt;/p&gt;
+&lt;pre&gt;&lt;code&gt;[1 0 0 x]
+[0 1 0 y]
+[0 0 1 z]
+[0 0 0 1]&lt;/code&gt;&lt;/pre&gt;
+&lt;p&gt;Then when we multiply this matrix by a vector like
+&lt;code&gt;(a, b, c, 1)&lt;/code&gt; the result is
+&lt;code&gt;(a + x, b + y, c + z, 1)&lt;/code&gt;. If you don’t understand why the
+matrix is 4x4 or why we have that extra 1 at the end don’t worry, I’ll
+explain that in more detail later.&lt;/p&gt;
+&lt;p&gt;Now using the existing conversion code to get a 3x3 matrix will
+simply take the first 3 columns and first 3 rows of the matrix and
+produce a 3x3 matrix from those. Converting the translation matrix above
+using this code produces the following matrix:&lt;/p&gt;
+&lt;pre&gt;&lt;code&gt;[1 0 0]
+[0 1 0]
+[0 0 1]&lt;/code&gt;&lt;/pre&gt;
+&lt;p&gt;See the problem now? The &lt;code&gt;(x, y, z)&lt;/code&gt; values disappeared!
+In the conversion process we lost these critical values from the
+translation matrix, and now if we multiply by this matrix nothing will
+happen since we are just left with the identity matrix. So if we can’t
+use this simple “cast” function in GLM, what can we use?&lt;/p&gt;
+&lt;p&gt;Well one thing we can do is preserve the last column and last row of
+the matrix. So assume we have a 4x4 matrix like this:&lt;/p&gt;
+&lt;pre&gt;&lt;code&gt;[a b c d]
+[e f g h]
+[i j k l]
+[m n o p]&lt;/code&gt;&lt;/pre&gt;
+&lt;p&gt;Then preserving the last row and column we should get a matrix like
+this:&lt;/p&gt;
+&lt;pre&gt;&lt;code&gt;[a b d]
+[e f h]
+[m n p]&lt;/code&gt;&lt;/pre&gt;
+&lt;p&gt;And if we use this conversion process for the same translation matrix
+we will get:&lt;/p&gt;
+&lt;pre&gt;&lt;code&gt;[1 0 x]
+[0 1 y]
+[0 0 1]&lt;/code&gt;&lt;/pre&gt;
+&lt;p&gt;Now we see that the &lt;code&gt;(x, y)&lt;/code&gt; part of the translation is
+preserved, and if we try to multiply this matrix by the vector
+&lt;code&gt;(a, b, 1)&lt;/code&gt; the result will be
+&lt;code&gt;(a + x, b + y, 1)&lt;/code&gt;. The translation is preserved in the
+conversion!&lt;/p&gt;
+&lt;h2 id="why-do-we-have-to-use-this-conversion"&gt;Why do we have to use
+this conversion?&lt;/h2&gt;
+&lt;p&gt;The reason the conversion is more complicated is hidden in how we
+defined the translation matrix and vector we wanted to translate. The
+vector was actually a 4D vector with the final component set to 1. The
+reason we do this is that we actually want to represent an affine space
+instead of just a vector space. An affine space being a type of space
+where you can have both points and vectors. A point is exactly what you
+would expect it to be just a point in space from some origin, and vector
+is a direction with magnitude but no origin. This is important because
+strictly speaking translation isn’t actually defined for vectors in a
+normal vector space. Additionally if you try to construct a matrix to
+represent translation for a vector space you’ll find that its impossible
+to derive a matrix to do this and that operation is not a linear
+function. On the other hand operations like translation are well defined
+in an affine space and do what you would expect.&lt;/p&gt;
+&lt;p&gt;To get around the problem of vector spaces, mathematicians more
+clever than I figured out you can implement an affine space in a normal
+vector space by increasing the dimension of the vector space by one, and
+by adding an extra row and column to the transformation matrices used.
+They called this a &lt;strong&gt;homogeneous coordinate system&lt;/strong&gt;. This
+lets you say that a vector is actually just a point if the 4th component
+is 1, but if its 0 its just a vector. Using this abstraction one can
+implement all the well defined operations for an affine space (like
+translation!).&lt;/p&gt;
+&lt;p&gt;So using the “homogeneous coordinate system” abstraction, translation
+is an operation that defined by taking a point and moving it by a
+vector. Lets look at how that works with the translation matrix I used
+as an example above. If you multiply that matrix by a 4D vector where
+the 4th component is 0, it will just return the same vector. Now if we
+multiply by a 4D vector where the 4th component is 1, it will return the
+point translated by the vector we used to construct that translation
+matrix. This implements the translation operation as its defined in an
+affine space!&lt;/p&gt;
+&lt;p&gt;If you’re interested in understanding more about homogeneous
+coordinate spaces, (like how the translation matrix is derived in the
+first place) I would encourage you to look at resources like &lt;a
+href="https://books.google.ca/books/about/Mathematics_for_Computer_Graphics_Applic.html?id=YmQy799flPkC&amp;amp;redir_esc=y"&gt;“Mathematics
+for Computer Graphics Applications”&lt;/a&gt;. They provide a much more
+detailed explanation than I am providing here. (The homogeneous
+coordinate system also has some benefits for representing projections
+which I won’t get into here, but are explained in that text book.)&lt;/p&gt;
+&lt;p&gt;Now to finally answer the question about why we needed to preserve
+those final columns and vectors. Based on what we now know, we weren’t
+actually just converting from a “3D space” to a “2D space” we were
+converting from a “3D homogeneous space” to a “2D homogeneous space”.
+The process of converting from a higher dimension matrix to a lower
+dimensional matrix is lossy and some transformation details are going to
+be lost in process (like for example the translation along the z-axis).
+There is no way to tell what kind of space a given matrix is supposed to
+transform just by looking at the matrix itself. The matrix does not
+carry any information about about what space its operating in and any
+conversion function would need to know that information to properly
+convert that matrix. Therefore we need develop our own conversion
+function that preserves the transformations that are important to our
+application when moving from a “3D homogeneous space” to a “2D
+homogeneous space”.&lt;/p&gt;
+&lt;p&gt;Hopefully this explanation helps if you are every working on
+converting 3D transformation code to 2D.&lt;/p&gt;
+</description><pubDate>Mon, 25 Sep 2023 04:00:00 -0000</pubDate><guid>https://fryzekconcepts.com/notes/converting_from_3d_to_2d.html</guid></item></channel></rss>
\ No newline at end of file
diff --git a/html/index.html b/html/index.html
index 91ad380..4164709 100644
--- a/html/index.html
+++ b/html/index.html
@@ -45,6 +45,14 @@
     </a>
 </h2>
 <div class="notes-container">
+        <a href="/notes/converting_from_3d_to_2d.html" class="note-link">
+        <div class="note-box">
+            <img src="/assets/3d_to_2d.png">
+            <h2>Converting from 3D to 2D</h2>
+            <p>Recently I’ve been working on a project where I needed to
+            convert an application written in to a ...</p>
+        </div>
+    </a>
         <a href="/notes/mesa_23_1_contributions_behind_the_scenes.html" class="note-link">
         <div class="note-box">
             <img src="/assets/mesa3d.svg">
diff --git a/html/notes/converting_from_3d_to_2d.html b/html/notes/converting_from_3d_to_2d.html
new file mode 100644
index 0000000..547927d
--- /dev/null
+++ b/html/notes/converting_from_3d_to_2d.html
@@ -0,0 +1,161 @@
+<!doctype html>
+
+<html class="html-note-page" lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+
+    <title>Converting from 3D to 2D</title>
+    <meta name="dcterms.date" content="2023-09-25" />
+
+    <link rel="stylesheet" href="/assets/style.css">
+    <link rel="icon" type="image/x-icon" href="/assets/favicon.svg">
+    <link rel="alternate" type="application/atom+xml" title="Fryzek Concepts" href="/feed.xml"> 
+</head>
+
+<body>
+    <div class="header-bar">
+        <a href="/index.html">
+            <img src="/assets/favicon.svg" alt="frycon logo">
+        </a>
+        <div class="header-links">
+                        <a href="/now.html" class="header-link">Now</a>
+            <a href="/about.html" class="header-link">About</a>
+            <a rel="me" href="https://mastodon.social/@hazematman">Social</a>
+        </div>
+    </div>
+    <main>
+<div class="page-title-header-container">
+    <h1 class="page-title-header">Converting from 3D to 2D</h1>
+        <div class="page-info-container">
+                    <div class="plant-status">
+                    <img src="/assets/budding.svg">
+                    <div class="plant-status-text">
+                    <p>budding</p>
+                    </div>
+                    </div>
+                <div class="page-info-date-container">
+            <p class="page-info-date">Published: 2023-09-25</p>
+            <p class="page-info-date">Last Edited: 2023-09-25</p>
+        </div>
+    </div>
+    </div>
+<div class="note-divider"></div>
+<div class="main-container">
+    <div class="note-body">
+<p>Recently I’ve been working on a project where I needed to convert an
+application written in OpenGL to a software renderer. The matrix
+transformation code in OpenGL made use of the GLM library for matrix
+math, and I needed to convert the 4x4 matrices to be 3x3 matrices to
+work with the software renderer. There was some existing code to do this
+that was broken, and looked something like this:</p>
+<pre><code>glm::mat3 mat3x3 = glm::mat3(mat4x4);</code></pre>
+<p>Don’t worry if you don’t see the problem already, I’m going to
+illustrate in more detail with the example of a translation matrix. In
+3D a standard translation matrix to translate by a vector
+<code>(x, y, z)</code> looks something like this:</p>
+<pre><code>[1 0 0 x]
+[0 1 0 y]
+[0 0 1 z]
+[0 0 0 1]</code></pre>
+<p>Then when we multiply this matrix by a vector like
+<code>(a, b, c, 1)</code> the result is
+<code>(a + x, b + y, c + z, 1)</code>. If you don’t understand why the
+matrix is 4x4 or why we have that extra 1 at the end don’t worry, I’ll
+explain that in more detail later.</p>
+<p>Now using the existing conversion code to get a 3x3 matrix will
+simply take the first 3 columns and first 3 rows of the matrix and
+produce a 3x3 matrix from those. Converting the translation matrix above
+using this code produces the following matrix:</p>
+<pre><code>[1 0 0]
+[0 1 0]
+[0 0 1]</code></pre>
+<p>See the problem now? The <code>(x, y, z)</code> values disappeared!
+In the conversion process we lost these critical values from the
+translation matrix, and now if we multiply by this matrix nothing will
+happen since we are just left with the identity matrix. So if we can’t
+use this simple “cast” function in GLM, what can we use?</p>
+<p>Well one thing we can do is preserve the last column and last row of
+the matrix. So assume we have a 4x4 matrix like this:</p>
+<pre><code>[a b c d]
+[e f g h]
+[i j k l]
+[m n o p]</code></pre>
+<p>Then preserving the last row and column we should get a matrix like
+this:</p>
+<pre><code>[a b d]
+[e f h]
+[m n p]</code></pre>
+<p>And if we use this conversion process for the same translation matrix
+we will get:</p>
+<pre><code>[1 0 x]
+[0 1 y]
+[0 0 1]</code></pre>
+<p>Now we see that the <code>(x, y)</code> part of the translation is
+preserved, and if we try to multiply this matrix by the vector
+<code>(a, b, 1)</code> the result will be
+<code>(a + x, b + y, 1)</code>. The translation is preserved in the
+conversion!</p>
+<h2 id="why-do-we-have-to-use-this-conversion">Why do we have to use
+this conversion?</h2>
+<p>The reason the conversion is more complicated is hidden in how we
+defined the translation matrix and vector we wanted to translate. The
+vector was actually a 4D vector with the final component set to 1. The
+reason we do this is that we actually want to represent an affine space
+instead of just a vector space. An affine space being a type of space
+where you can have both points and vectors. A point is exactly what you
+would expect it to be just a point in space from some origin, and vector
+is a direction with magnitude but no origin. This is important because
+strictly speaking translation isn’t actually defined for vectors in a
+normal vector space. Additionally if you try to construct a matrix to
+represent translation for a vector space you’ll find that its impossible
+to derive a matrix to do this and that operation is not a linear
+function. On the other hand operations like translation are well defined
+in an affine space and do what you would expect.</p>
+<p>To get around the problem of vector spaces, mathematicians more
+clever than I figured out you can implement an affine space in a normal
+vector space by increasing the dimension of the vector space by one, and
+by adding an extra row and column to the transformation matrices used.
+They called this a <strong>homogeneous coordinate system</strong>. This
+lets you say that a vector is actually just a point if the 4th component
+is 1, but if its 0 its just a vector. Using this abstraction one can
+implement all the well defined operations for an affine space (like
+translation!).</p>
+<p>So using the “homogeneous coordinate system” abstraction, translation
+is an operation that defined by taking a point and moving it by a
+vector. Lets look at how that works with the translation matrix I used
+as an example above. If you multiply that matrix by a 4D vector where
+the 4th component is 0, it will just return the same vector. Now if we
+multiply by a 4D vector where the 4th component is 1, it will return the
+point translated by the vector we used to construct that translation
+matrix. This implements the translation operation as its defined in an
+affine space!</p>
+<p>If you’re interested in understanding more about homogeneous
+coordinate spaces, (like how the translation matrix is derived in the
+first place) I would encourage you to look at resources like <a
+href="https://books.google.ca/books/about/Mathematics_for_Computer_Graphics_Applic.html?id=YmQy799flPkC&amp;redir_esc=y">“Mathematics
+for Computer Graphics Applications”</a>. They provide a much more
+detailed explanation than I am providing here. (The homogeneous
+coordinate system also has some benefits for representing projections
+which I won’t get into here, but are explained in that text book.)</p>
+<p>Now to finally answer the question about why we needed to preserve
+those final columns and vectors. Based on what we now know, we weren’t
+actually just converting from a “3D space” to a “2D space” we were
+converting from a “3D homogeneous space” to a “2D homogeneous space”.
+The process of converting from a higher dimension matrix to a lower
+dimensional matrix is lossy and some transformation details are going to
+be lost in process (like for example the translation along the z-axis).
+There is no way to tell what kind of space a given matrix is supposed to
+transform just by looking at the matrix itself. The matrix does not
+carry any information about about what space its operating in and any
+conversion function would need to know that information to properly
+convert that matrix. Therefore we need develop our own conversion
+function that preserves the transformations that are important to our
+application when moving from a “3D homogeneous space” to a “2D
+homogeneous space”.</p>
+<p>Hopefully this explanation helps if you are every working on
+converting 3D transformation code to 2D.</p>
+    </div>
+</div>    </main>
+</body>
+</html>
diff --git a/notes/converting_from_3d_to_2d.md b/notes/converting_from_3d_to_2d.md
new file mode 100644
index 0000000..d711094
--- /dev/null
+++ b/notes/converting_from_3d_to_2d.md
@@ -0,0 +1,77 @@
+---
+layout: post
+title: "Converting from 3D to 2D"
+date: "2023-09-25"
+last_edit: "2023-09-25"
+status: 2
+categories: igalia graphics
+cover_image: "/assets/3d_to_2d.png"
+---
+
+Recently I've been working on a project where I needed to convert an application written in OpenGL to a software renderer. The matrix transformation code in OpenGL made use of the GLM library for matrix math, and I needed to convert the 4x4 matrices to be 3x3 matrices to work with the software renderer. There was some existing code to do this that was broken, and looked something like this:
+
+```
+glm::mat3 mat3x3 = glm::mat3(mat4x4);
+```
+
+Don't worry if you don't see the problem already, I'm going to illustrate in more detail with the example of a translation matrix. In 3D a standard translation matrix to translate by a vector `(x, y, z)` looks something like this:
+
+```
+[1 0 0 x]
+[0 1 0 y]
+[0 0 1 z]
+[0 0 0 1]
+```
+
+Then when we multiply this matrix by a vector like `(a, b, c, 1)` the result is `(a + x, b + y, c + z, 1)`. If you don't understand why the matrix is 4x4 or why we have that extra 1 at the end don't worry, I'll explain that in more detail later.
+
+Now using the existing conversion code to get a 3x3 matrix will simply take the first 3 columns and first 3 rows of the matrix and produce a 3x3 matrix from those. Converting the translation matrix above using this code produces the following matrix:
+
+```
+[1 0 0]
+[0 1 0]
+[0 0 1]
+```
+
+See the problem now? The `(x, y, z)` values disappeared! In the conversion process we lost these critical values from the translation matrix, and now if we multiply by this matrix nothing will happen since we are just left with the identity matrix. So if we can't use this simple "cast" function in GLM, what can we use?
+
+Well one thing we can do is preserve the last column and last row of the matrix. So assume we have a 4x4 matrix like this:
+
+```
+[a b c d]
+[e f g h]
+[i j k l]
+[m n o p]
+```
+
+Then preserving the last row and column we should get a matrix like this:
+
+```
+[a b d]
+[e f h]
+[m n p]
+```
+
+And if we use this conversion process for the same translation matrix we will get:
+
+```
+[1 0 x]
+[0 1 y]
+[0 0 1]
+```
+
+Now we see that the `(x, y)` part of the translation is preserved, and if we try to multiply this matrix by the vector `(a, b, 1)` the result will be `(a + x, b + y, 1)`. The translation is preserved in the conversion!
+
+## Why do we have to use this conversion?
+
+The reason the conversion is more complicated is hidden in how we defined the translation matrix and vector we wanted to translate. The vector was actually a 4D vector with the final component set to 1. The reason we do this is that we actually want to represent an affine space instead of just a vector space. An affine space being a type of space where you can have both points and vectors. A point is exactly what you would expect it to be just a point in space from some origin, and vector is a direction with magnitude but no origin. This is important because strictly speaking translation isn't actually defined for vectors in a normal vector space. Additionally if you try to construct a matrix to represent translation for a vector space you'll find that its impossible to derive a matrix to do this and that operation is not a linear function. On the other hand operations like translation are well defined in an affine space and do what you would expect.
+
+To get around the problem of vector spaces, mathematicians more clever than I figured out you can implement an affine space in a normal vector space by increasing the dimension of the vector space by one, and by adding an extra row and column to the transformation matrices used. They called this a **homogeneous coordinate system**. This lets you say that a vector is actually just a point if the 4th component is 1, but if its 0 its just a vector. Using this abstraction one can implement all the well defined operations for an affine space (like translation!).
+
+So using the "homogeneous coordinate system" abstraction, translation is an operation that defined by taking a point and moving it by a vector. Lets look at how that works with the translation matrix I used as an example above. If you multiply that matrix by a 4D vector where the 4th component is 0, it will just return the same vector. Now if we multiply by a 4D vector where the 4th component is 1, it will return the point translated by the vector we used to construct that translation matrix. This implements the translation operation as its defined in an affine space!
+
+If you're interested in understanding more about homogeneous coordinate spaces, (like how the translation matrix is derived in the first place) I would encourage you to look at resources like ["Mathematics for Computer Graphics Applications"](https://books.google.ca/books/about/Mathematics_for_Computer_Graphics_Applic.html?id=YmQy799flPkC&redir_esc=y). They provide a much more detailed explanation than I am providing here. (The homogeneous coordinate system also has some benefits for representing projections which I won't get into here, but are explained in that text book.)
+
+Now to finally answer the question about why we needed to preserve those final columns and vectors. Based on what we now know, we weren't actually just converting from a "3D space" to a "2D space" we were converting from a "3D homogeneous space" to a "2D homogeneous space". The process of converting from a higher dimension matrix to a lower dimensional matrix is lossy and some transformation details are going to be lost in process (like for example the translation along the z-axis). There is no way to tell what kind of space a given matrix is supposed to transform just by looking at the matrix itself. The matrix does not carry any information about about what space its operating in and any conversion function would need to know that information to properly convert that matrix. Therefore we need develop our own conversion function that preserves the transformations that are important to our application when moving from a "3D homogeneous space" to a "2D homogeneous space".
+
+Hopefully this explanation helps if you are every working on converting 3D transformation code to 2D.