Chilipedia - User contributions [en]

Beginner C++ Game Programming Tutorial 7

2022-05-05T04:26:30Z

Chili: Text replacement - "http://www.planetchili.net/" to "https://www.planetchili.net/"

Mr. DeBugger is a real sir.

== Concepts Taught ==
* Using the Visual Studio debugger

== Chili's Dank Meta Nugs ==
* Don't binge watch the tutorials--space that shit out
* Practice and experiment with C++ on your own initiative

== Video Timestamp Index ==
* Intro [https://www.youtube.com/watch?v=h2l2D0ud7DY&t=0m0s 0:00]
* Introducing the Debugger [https://www.youtube.com/watch?v=h2l2D0ud7DY&t=0m31s 0:31]
* Setting up the debugger [https://www.youtube.com/watch?v=h2l2D0ud7DY&t=1m41s 1:41]
* Running in debug mode [https://www.youtube.com/watch?v=h2l2D0ud7DY&t=2m25s 2:25]
* The call stack [https://www.youtube.com/watch?v=h2l2D0ud7DY&t=2m45s 2:45]
* Finding debug windows [https://www.youtube.com/watch?v=h2l2D0ud7DY&t=3m17s 3:17]
* Release vs Debug mode: assertions [https://www.youtube.com/watch?v=h2l2D0ud7DY&t=3m50s 3:50]
* Autos [https://www.youtube.com/watch?v=h2l2D0ud7DY&t=4m56s 4:56]
* Debugging second solution: setting your own breakpoints, stepping over and stepping into [https://www.youtube.com/watch?v=h2l2D0ud7DY&t=6m38s 6:38]
* Locals [https://www.youtube.com/watch?v=h2l2D0ud7DY&t=9m30s 9:30]
* Step out [https://www.youtube.com/watch?v=h2l2D0ud7DY&t=10m39s 10:39]
* Continue [https://www.youtube.com/watch?v=h2l2D0ud7DY&t=11m33s 11:33]
* Advice from Chili [https://www.youtube.com/watch?v=h2l2D0ud7DY&t=12m10s 12:10]
* Chili's Dank Meta Nugs [https://www.youtube.com/watch?v=h2l2D0ud7DY&t=12m45s 12:45]
* Homework [https://www.youtube.com/watch?v=h2l2D0ud7DY&t=16m35s 16:35]

== Homework ==
There are three problems to solve in three separate solutions. The solutions are all based on the code used in the tutorial video (the code from the Tutorial 6 homework) Download the zip of the solutions below in the Downloads section.
# Assertion fails! Find the bug! Also, there's another bug hiding if you solve the first one. Try making the boxes collide and see what happens (or what doesn't happen...). Note that I don't talk about this second bug in the solution video. Check out the Solution Errata below for the answer.
# Assertion fails! Find the bug!
# Moving the cursor to the bottom of the screen is bad news bears...

The solution is given in [https://www.youtube.com/watch?v=reTJUqZspYs this video].

=== Solution Errata ===
Read the below (click Expand) only after attempting the problem yourself.

<div class="mw-collapsed mw-collapsible" style="width:700px">
In the solution video, we see that the bug in the second homework problem is actually the same bug as in the tutorial video. The reason for this is that Chili fucked up and put the bug he intended to go in the second problem into the first problem. So the first problem has two bugs, and the second problem only has the bug from the tutorial.

Now the bug in the second problem is something that Chili has mentioned before. It is a mix-up between the <code>=</code> and <code>==</code> operators. Specifically, it is as follows (error on line 64 of Game.cpp):

<source lang="cpp" line start="64">
colliding ==
OverlapTest( x_fixed0,y_fixed0,x_mobile,y_mobile ) ||
OverlapTest( x_fixed1,y_fixed1,x_mobile,y_mobile ) ||
OverlapTest( x_fixed2,y_fixed2,x_mobile,y_mobile ) ||
OverlapTest( x_fixed3,y_fixed3,x_mobile,y_mobile );
</source>

</div>

== Downloads ==

* [https://www.planetchili.net/downloads/T7-TutCode.zip Tutorial 7 Code]
* [https://www.planetchili.net/downloads/T7-Homework.zip Tutorial 7 Homework Solution Code]

== See also ==
* [[Beginner C++ Game Programming Tutorial 8|Next in series (Tutorial 8)]]
* [[Beginner C++ Game Programming Series]]

Intermediate C++ Game Programming Tutorial 12

2022-05-05T04:26:30Z

Chili: Text replacement - "http://www.planetchili.net/" to "https://www.planetchili.net/"

In this tutorial Chili shows us an example of how to create a class for an animated sprite, and how to use a collection of these animated sprites to create a walking character class.

== Topics Covered ==
* Animated sprite class design
* Walking character class design

== Notes ==
The technique we use of storing a reference to <code>Surface</code> in each <code>Animation</code> object will work for now, but it will cause us a pain in the dick in the future when we start using our characters in containers like <code>std::vector</code>. The reason for this is because you cannot assign a reference to refer something else after it has been bound, and so the compiler cannot generate copy assign for us by default. We will fix this problem when it becomes an issue for us (in the Action RPG Project).

== Video Timestamp Index ==
[https://youtu.be/KXn7-5zg3J4 Tutorial 12]
* Introducing the <code>Character</code> and <code>Animation</code> classes [https://youtu.be/KXn7-5zg3J4?t=0m20s 0:20]
* Creating header file for the <code>Animation</code> class [https://youtu.be/KXn7-5zg3J4?t=0m49s 0:49]
* Implementing the <code>Animation</code> class [https://youtu.be/KXn7-5zg3J4?t=3m30s 3:30], constructor implementation at [https://youtu.be/KXn7-5zg3J4?t=5m15s 5:15]
* Copy the FrameTimer class used in earlier tutorials [https://youtu.be/KXn7-5zg3J4?t=7m35s 7:35]
* Give it a test run: have an animated sprite follow the cursor [https://youtu.be/KXn7-5zg3J4?t=8m00s 8:00]
* Creating header file for the <code>Character</code> class [https://youtu.be/KXn7-5zg3J4?t=11m05s 11:05]
* Using an <code>enum class</code>, namecode the different animation sequences [https://youtu.be/KXn7-5zg3J4?t=11m49s 11:49]
* Implementing the <code>Character</code> class [https://youtu.be/KXn7-5zg3J4?t=13m08s 13:08]
* Add an operator in the <code>Vec2</code> class that applies explicit conversion (cast) of a float position pair into an int position pair [https://youtu.be/KXn7-5zg3J4?t=17m20s 17:20]
* Create the <code>SetDirection</code> function that sets the direction of motion and the animation sequence [https://youtu.be/KXn7-5zg3J4?t=18m24s 18:24]
* Test the <code>Character</code> class by applying it in the <code>Game</code> class [https://youtu.be/KXn7-5zg3J4?t=20m48s 20:48]
* Disclaimer for the approach presented in this tutorial [https://youtu.be/KXn7-5zg3J4?t=23m42s 23:42]

== Source Code ==
[https://github.com/planetchili/sprite Sprite Repo]

== Download Materials ==
* [https://www.planetchili.net/downloads/I12-Images.zip Tutorial Images]

== Homework ==
None!

== See also ==
* [[Intermediate C++ Game Programming Tutorial 13|Next in series (Tutorial 13)]]
* [[Intermediate C++ Game Programming Series]]

Beginner C++ Game Programming Tutorial 8

2022-05-05T04:26:30Z

Chili: Text replacement - "http://www.planetchili.net/" to "https://www.planetchili.net/"

We make our first game. So goddamn sweet. Not shitty at all.

== Concepts Taught ==
* <code>+=</code> and <code>-=</code> operators
* Writing code in a constructor
* <code>#include <header></code>
* Using <code>std::mt19973</code> and <code>std::uniform_int_distribution<int></code> to generate random numbers

== Errata ==
At [https://youtu.be/7yqV2hyv9Cc?list=PLqCJpWy5FohcehaXlCIt8sVBHBFFRVWsx&t=650 10:50] in the video, there is a note saying that <code>isEaten = IsColliding( ... );</code> would have also been a valid approach, but this is incorrect. With direct assignment, once the condition becomes false, the <code>isEaten</code> flag gets reset (which is not the desired behavior). With the <code>if</code> statement, once the flag is set it remains <code>true</code> regardless of what <code>IsColliding( ... )</code> returns on subsequent frames.

== Video Timestamp Index ==
* Intro [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=0m0s 0:00]
* Basic game plan [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=0m30s 0:30]
* Setting up member variables for entities: dude and poo [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=0m50s 0:50]
* Dude and poo graphics [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=2m20s 2:20]
* Creating Draw functions for Dude and Poo [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=4m8s 4:08]
* Quick note on sprite coordinate origins [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=5m20s 5:20]
* Screen clamping functions [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=6m20s 6:20]
* Movement code for Dude [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=8m9s 8:09]
* Collision test code [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=9m3s 9:03]
* Win condition and Gameover screen [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=11m54s 11:54]
* Title Screen [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=13m20s 13:20]
* Randomizing poo positions [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=15m7s 15:07]
* A little bit on constructors [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=16m11s 16:11]
* Creating random number generator object [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=16m50s 16:50]
* Specifying a range for random numbers [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=18m23s 18:23]
* Random device: The importance of a seed [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=20m55s 20:55]
* Why we don't use random device as a random number generator [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=22m9s 22:09]
* Summing up what we have learned [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=23m4s 23:04]
* An important message from the power rangers [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=23m50s 23:50]
* Homework [https://www.youtube.com/watch?v=7yqV2hyv9Cc&t=26m33s 26:33]

== Homework ==
Make the poos move around the screen and rebound when they hit the edges.

The solution is given in [https://youtu.be/KIw8MX7HfqU this video].

== Image to PutPixel Tools ==

* [https://www.planetchili.net/forum/viewtopic.php?f=3&t=925#p1011 fukbmp] - a barebones tool by Chili
* [https://www.planetchili.net/forum/viewtopic.php?f=3&t=991 Custom Sprites 1.5] - a nicer tool by LuX
* [http://forum.planetchili.net/viewtopic.php?f=3&t=3612 Tristan's PutPixel Puker] - another sexy tool by Tristan

== Downloads ==

* [https://www.planetchili.net/downloads/Chili%20DirectX%20Framework.zip Framework Download]
* [https://www.planetchili.net/downloads/T8-Goodies.zip PutPixel Sprites]
* [https://planetchili.net/downloads/apworks/8/Beginner%20Tutorial%208%20Code.zip Tutorial 8 Code]
* [https://planetchili.net/downloads/apworks/8/Beginner%20Tutorial%208%20HW%20Code.zip Tutorial 8 Homework Solution Code]

== See also ==
* [https://www.patreon.com/planetchili Planet Chili Patreon]
* [[Beginner C++ Game Programming Tutorial 9|Next in series (Tutorial 9)]]
* [[Beginner C++ Game Programming Series]]

Intermediate C++ Game Programming Tutorial 10

2022-05-05T04:26:30Z

Chili: Text replacement - "http://www.planetchili.net/" to "https://www.planetchili.net/"

The promised day has come. We're finally going to be loading images from bitmap files into memory and drawing them as sprites on the screen. This is where all that stuff we've been learning--data types, pointers, memory management, file access, etc.--is going to pay off bigtime. Also, get fukt massive PutPixel sprite functions; die in a garbage fire.

== Topics Covered ==
* <code>Surface</code> class for storing image data in memory
* Parsing Windows bitmap file headers and loading pixel data
* Calculating padding
* Drawing sprites (pixel blocks) from a <code>Surface</code> to the screen

== Notes ==
=== Channel Byte Order ===
There is a rather large issue with the order in which the color channels are loaded from the bitmap file, but due to a freak of coincidence, the code works regardless. Still, we must address this buttfuckery.

The way the channels are laid out in the file is (in order of low offset to high offset) |B| |G| |R|. Now the line of code that simultaneously reads the 3 bytes of the 3 color channels, constructs a Color object, and writes it into the Surface is: <code>PutPixel( x,y,Color( file.get(),file.get(),file.get() ) );</code>. The function prototype of the Color constructor is <code>Color( unsigned char r,unsigned char g,unsigned char b )</code>, so the order here is RGB, and we would expect that our code would be messed up (the R and B channels would be swapped). But this is not the case. What gives?

Well you might (understandably) assume that our function call to the ctor evaluates the <code>get()</code> parameter expressions in the following order <code>Color( file.get()<sub>first(B)</sub>,file.get()<sub>second(G)</sub>,file.get()<sub>third(R)</sub> )</code>, that is to say, the list of parameter expressions being evaluated in left-to-right order. In actuality, the compiler evaluates them in right-to-left order, i.e. <code>Color( file.get()<sub>third(R)</sub>,file.get()<sub>second(G)</sub>,file.get()<sub>first(B)</sub> )</code>, and this is why our code happens to work!

Even stranger is the fact that <big>'''the C++ standard does not specify the order in which the parameter expressions are evaluated!'''</big> So it is possible that a different compiler could generate code that gives a different permutation of the color channels. In actuality, we can expect most compilers to do it right-to-left because of the way parameters will be pushed onto the stack (which ''is'' mandated), but still, it is terrible practice to rely on this unspecified behavior to always be the way we wish it to be.

The following code fixes this problem. It will be applied (in later downstream commits) to the Sprite repo and the Twin repo on GitHub.
<syntaxhighlight lang="cpp" line start="54" >
const unsigned char b = file.get();
const unsigned char g = file.get();
const unsigned char r = file.get();
PutPixel( x,y,{ r,g,b } );
</syntaxhighlight>

=== Self Assignment ===
We definitely should be checking for self assignment (<code>mySurf = mySurf;</code>) in the assignment operator for <code>Surface</code>. See [[Intermediate C++ Game Programming Tutorial 6#Errata|the Errata of Intermediate 6]] for more details.

== Video Timestamp Index ==
[https://youtu.be/0z3uCzitO7Y Tutorial 10]
* Creating a datatype (<code>Surface</code> class) to hold image data [https://youtu.be/0z3uCzitO7Y?t=0m13s 0:13]
* Add member function <code>DrawSprite</code> to <code>Graphics</code> class to draw a <code>Surface</code> object to the screen [https://youtu.be/0z3uCzitO7Y?t=5m03s 5:03]
* Test the code with a funky sprite design [https://youtu.be/0z3uCzitO7Y?t=7m43s 7:43]
* Load sprites in a <code>Surface</code> object from a Bitmap file [https://youtu.be/0z3uCzitO7Y?t=9m09s 9:09]
* Exploring the Bitmap Filetype [https://youtu.be/0z3uCzitO7Y?t=9m18s 9:18]
* Load the Bitmap file header <code>BITMAPFILEHEADER</code> [https://youtu.be/0z3uCzitO7Y?t=10m54s 10:54]
* Load the DIB Header <code>BITMAPINFOHEADER</code> [https://youtu.be/0z3uCzitO7Y?t=15m08s 15:08]
* Load 8-bit RBG values of the Bitmap File into pixel array of a <code>Surface</code> object [https://youtu.be/0z3uCzitO7Y?t=17m00s 17:00]
* Calculate padding at the end of a bitmap row [https://youtu.be/0z3uCzitO7Y?t=18m40s 18:40]
* Do a test run, loading a Bitmap file and drawing it to the screen [https://youtu.be/0z3uCzitO7Y?t=22m32s 22:32]
* Test the order of the color channels [https://youtu.be/0z3uCzitO7Y?t=24m46s 24:46]
* Using <code>assert</code>, add a test to see if file loading succeeded [https://youtu.be/0z3uCzitO7Y?t=25m21s 25:21]
* Homework assignment [https://youtu.be/0z3uCzitO7Y?t=27m21s 27:21]

== Source Code ==
[https://github.com/planetchili/sprite Sprite Repo]<br />

== Download Materials ==
* [https://www.planetchili.net/downloads/I10-Images.zip Tutorial and Homework Bitmaps]

== Homework ==
The homework is to improve the bitmap loading routine to support 32-bit RGB format and to support bitmaps with reverse row order.
*[https://youtu.be/84C5RYLyWLc Homework solution video]

== See also ==
* [[Intermediate C++ Game Programming Tutorial 11|Next in series (Tutorial 11)]]
* [[Intermediate C++ Game Programming Series]]

Beginner C++ Game Programming Tutorial 11

2022-05-05T04:26:30Z

Chili: Text replacement - "http://www.planetchili.net/" to "https://www.planetchili.net/"

References are sweet because they let us control our shit from far away. Remember the days when we had to actually get up to change the channel on the TV? Remember TV? Fuck that shit! Also, const correctness is for big dick gangstas that don't give any fucks.

== Concepts Taught ==
* References
* Passing by reference
* <code>[[const]]</code> correctness (redux)

== Const Correctness ==
The use of <code>const</code> as a means of communication by code and as method to prevent you and other people from shooting you (your code / themselves) in the dick is something that Chili finds cromulent. For some info on how <code>const</code> makes your code less shitty, check [https://isocpp.org/wiki/faq/const-correctness#const-and-type-safety this]. If you're still not sold (I happen to like being a human dumpster fire, thank you very much Chili), here is a video showing how using <code>const</code> can make your code a fuck of a lot faster: [https://www.youtube.com/watch?v=zBkNBP00wJE&feature=youtu.be&t=1455 cool beans].

== Video Timestamp Index ==
* Intro [https://www.youtube.com/watch?v=VzXco2FqpT8&t=0m0s 0:00]
* Drawing rect function [https://www.youtube.com/watch?v=VzXco2FqpT8&t=0m41s 0:41]
* Creating a Color object [https://www.youtube.com/watch?v=VzXco2FqpT8&t=4m32s 4:32]
* Controlling the rectangle with the mouse [https://www.youtube.com/watch?v=VzXco2FqpT8&t=6m46s 6:46]
* Extending DrawRect function to account for the "flip over" on the x and y, when x1 or y1 < x0 or y0 [https://www.youtube.com/watch?v=VzXco2FqpT8&t=8m23s 8:23]
* Test and swap x0,y0 and x1,y1 [https://www.youtube.com/watch?v=VzXco2FqpT8&t=10m19s 10:19]
* Shit don't work, references to the rescue! [https://www.youtube.com/watch?v=VzXco2FqpT8&t=10m19s 12:16]
* Making Test and swap work! [https://www.youtube.com/watch?v=VzXco2FqpT8&t=17m45s 17:45]
* Refactoring DrawRect [https://www.youtube.com/watch?v=VzXco2FqpT8&t=20m36s 20:36]
* Poo game: Moving poo drawing code from Game class into Poo class [https://www.youtube.com/watch?v=VzXco2FqpT8&t=21m35s 21:35]
* Process Consumption refactoring (args): passing Dude object by reference [https://www.youtube.com/watch?v=VzXco2FqpT8&t=25m48s 25:48]
* Const correctness: passing by const reference [https://www.youtube.com/watch?v=VzXco2FqpT8&t=28m25s 28:25]
* Const correctness: Making member functions const [https://www.youtube.com/watch?v=VzXco2FqpT8&t=30m40s 30:40]
* Recap [https://www.youtube.com/watch?v=VzXco2FqpT8&t=32m1s 32:01]
* Homework [https://www.youtube.com/watch?v=VzXco2FqpT8&t=34m5s 34:05]

== Homework ==
# Move the drawing code for <code>Dude</code> from <code>Game</code> into the <code>Dude</code> class.
# Make a second <code>DrawRect</code> function that takes a single point (top left corner) and the dimensions as parameters.

The solution is given in [https://youtu.be/MOhF8Z2jW0k this] video.

== Downloads ==

* [https://www.planetchili.net/downloads/T11-Poo.zip Poo Starting Code]
* [https://www.planetchili.net/downloads/T11-Rect.zip Rect Starting Code]
* [https://planetchili.net/downloads/apworks/11/Beginner%20Tutorial%2011%20Poo%20Code.zip Beginner Tutorial 11 Poo Code]
* [https://planetchili.net/downloads/apworks/11/Beginner%20Tutorial%2011%20Rect%20Code.zip Beginner Tutorial 11 Rect Code]
* [https://planetchili.net/downloads/apworks/11/Beginner%20Tutorial%2011%20Poo%20HW%20Code.zip Beginner Tutorial 11 Poo HW Code]
* [https://planetchili.net/downloads/apworks/11/Beginner%20Tutorial%2011%20Rect%20HW%20Code.zip Beginner Tutorial 11 Rect HW Code]

== See also ==
* [https://www.patreon.com/planetchili Planet Chili Patreon]
* [[Beginner C++ Game Programming Tutorial 12|Next in series (Tutorial 12)]]
* [[Beginner C++ Game Programming Series]]

Chili Sound Pack

2022-05-05T04:26:30Z

Chili: Text replacement - "http://www.planetchili.net/" to "https://www.planetchili.net/"

The Chili Sound Pack is an optional pack of code and .dlls you can add to [[Chili Framework]] projects to enable the use of sound effects.

== Tutorial ==
Here is a [https://youtu.be/lxBpKjAaUOI link to a video] explaining how to integrate the sound module into a framework solution and how to use the <code>Sound</code> and <code>SoundEffect</code> classes. Check the [[#Downloads|downloads]] section below for the necessary stuff to follow along. (Note that newer versions of the framework already have the sound stuff included by default.)

==== Extra Notes / Errata ====

* In the tutorial video, the constructor for <code>SoundEffect</code> is not fully explained. There are 3 parameters. The first parameter is, as shown in the video, a list of <code>std::wstring</code>s which are the names of .wav files to be loaded. The second parameter is a <code>bool</code>, and if passed in as true, it allows the loading of .wav files to soft-fail (failure to load the file will cause a silent <code>Sound</code> object to be used instead). The third parameter is a <code>float</code> which is the standard deviation used to generate the pitch shift for each playback. Larger values create more dramatic swings in pitch.

* In the portion where I demonstrate soft-fail loading of a <code>Sound</code> with a <code>try</code> ... <code>catch</code> block, in the body of the <code>catch</code> I assign a default-constructed <code>Sound</code> object, but this is unnecessary (if the constructor <code>throw</code>s, the object will be put into a default-constructed, i.e. empty sound, state).

* Never '''''EVER''''' create a <code>Sound</code> (or a <code>SoundEffect</code>) object in the global scope. If you do so, the <code>SoundSystem</code> object will end up getting destroyed before the Sound object, and then you're FUCKED. I warned you.

== Downloads ==
Here is the [https://www.planetchili.net/downloads/Chili-Sound-Pack.zip sound module zip file] with the code and .dll files for the sound module.

To follow the tutorial on the sound module, you will need the following zip files as well:
* The test [https://www.planetchili.net/downloads/Sound-Tutorial-Poo.zip solution zip]
* The test [https://www.planetchili.net/downloads/Test-Sounds.zip sound files zip]

== Inner Workings of the Module ==

The inner workings of the XAudio2 code are explained in the H.U.G.S. series. The code discussed there is somewhat different than the code in the sound pack, but the fundamentals are the same. If you want the details, see the video links below. Note that these tutorials assume a relatively strong command of the C++ language.

* [https://www.youtube.com/watch?v=T51Eqbbald4 HUGS - Tutorial 11]
* [https://www.youtube.com/watch?v=ck2XpEZYLYs HUGS - Tutorial 12]
* [https://www.youtube.com/watch?v=hTEL49jCruw HUGS - Tutorial 17]

Intermediate C++ Game Programming Tutorial 16

2022-05-05T04:26:30Z

Chili: Text replacement - "http://www.planetchili.net/" to "https://www.planetchili.net/"

In the video we take a look at a couple of bangers from <code><algorithm></code>, and we learn what lambda functions are and how to use them.

== Topics Covered ==
* Algorithms <code>std::sort</code> and <code>std::remove_if</code>
* Concepts (as in, type concepts like Comparable)
* <code><functional></code> functors as predicates
* Lambda functions

== <span style="color:red">Errata</span> ==
In the video Chili states that std::remove does not preserve the relative order of elements in the container, but this is fake news! Relative order is preserved: [https://en.cppreference.com/w/cpp/algorithm/remove]

In the homework solution there is a part where Chili uses an iterator into a <code>stringstream</code> [https://youtu.be/_1-iES-Eytc?t=626]. This code no longer works due to changes (improvements) to the Visual Studio compiler. Basically, you cannot pass a temporary stream into the iterator constructor. See this: [https://stackoverflow.com/questions/23714445/passing-temporary-istringstream-object-to-istream-iteratorstring]

== Video Timestamp Index ==
[https://youtu.be/3J1Pz30IE4Q Tutorial 16]
<div class="mw-collapsible mw-collapsed"><br />
* Generic Algorithms: how Templates and Iterators make Algorithms independent of Data Types and Containers [https://youtu.be/3J1Pz30IE4Q?t=17s 0:17]
* The <code>std::sort</code> algorithm and its requirements [https://youtu.be/3J1Pz30IE4Q?t=43s 0:43]
* Sorting a (forward) list <code>std::list</code>, using its member function <code>std::list::sort()</code> [https://youtu.be/3J1Pz30IE4Q?t=2m16s 2:16]
* Introducing Concepts / named requirements of types (e.g., the <code>Compare</code> requirement of <code>std::sort</code>) [https://youtu.be/3J1Pz30IE4Q?t=2m54s 2:54]
* Modyfing sorting order by passing a comparison function object (functor) as a predicate, like so:<br /><code>std::sort(vec.begin(),vec.end(),std::greater<int>{});</code> [https://youtu.be/3J1Pz30IE4Q?t=3m17s 3:17]<br />Note: vec is a std::vector of integers
* Sort custom types, example code for sorting a custom class object by creating a functor, called like so: <br /><code>std::sort(vecObj.begin(),vecObj.end(),Obj::YLess{});</code> [https://youtu.be/3J1Pz30IE4Q?t=4m07s 4:07]
* Removing items from a container, <code>std::remove</code> and <code>std::remove_if</code> [https://youtu.be/3J1Pz30IE4Q?t=6m11s 6:11]
<div class="mw-collapsible-content">
** Create a functor as a unary predicate for the <code>std::remove</code> function to remove elements using a threshold variable [https://youtu.be/3J1Pz30IE4Q?t=8m28s 8:28]
** Use container member function <code>erase()</code> to correct the endpoint of the container after the remove operation [https://youtu.be/3J1Pz30IE4Q?t=9m51s 9:51]
</div>
* Introducing Lambda functions to replace custom functors [https://youtu.be/3J1Pz30IE4Q?t=11m51s 11:51]
* Using the Lambda capture to bring in variables into the Lambda function [https://youtu.be/3J1Pz30IE4Q?t=13m34s 13:34]
<div class="mw-collapsible-content">
** Capture syntax explained: <code>[var]</code>,<code>[&var]</code>,<code>[=]</code>,<code>[&]</code>,<code>[newvar=var+10]</code>,<code>[this]</code>, capture multiple variables, mix&match capture modes
** Stateful Lambdas; changing captured lambda variables using the <code>mutable</code> flag [https://youtu.be/3J1Pz30IE4Q?t=15m59s 15:59]
</div>
* Some anxiety-reducing consolation by Chili [https://youtu.be/3J1Pz30IE4Q?t=16m40s 16:40]
* Syntax for a callable Lambda function [https://youtu.be/3J1Pz30IE4Q?t=17m03s 17:03]
<div class="mw-collapsible-content">
** Make it callable once: <code>[...](...){...}(vec.front());</code>, functor is destroyed immediately
** Keep the functor using <code>auto mylamb = [...](...){...};</code>, which can be called by <code>bool result = mylamb(vec.front());</code>, or <code>std::remove_if(...,...,mylamb);</code>
</div>
* The power of C++ is in its flexibility. Example code for converting a string to lowercase:<br /><code>std::transform(str.begin(),str.end(),str.begin(),::tolower);</code>[https://youtu.be/3J1Pz30IE4Q?t=17m49s 17:49]
* Homework assignment [https://youtu.be/3J1Pz30IE4Q?t=18m39s 18:39]
* Introducing the Algorithm [[STD Gems]] series that takes a deep dive into its functionality [https://youtu.be/3J1Pz30IE4Q?t=19m20s 19:20]
</div>

== Homework ==
Solve the problems in Source.cpp attached below using the <algorithm> library and other parts of the standard library as extensively as possible. As a bonus problem, implement the sprite drawing effect shown at the end of the video using a lambda function.

* [https://www.planetchili.net/downloads/I16-HW.zip Source.cpp (homework file)]
* [https://github.com/planetchili/sprite Sprite Repo (for bonus problem)]

The homework solution video can be found [https://youtu.be/_1-iES-Eytc here]

== Related Series ==
For an in-depth look into the <algorithm> library and beyond, check out [[STD Gems]].

== Links ==
[http://en.cppreference.com/w/cpp/algorithm Algorithms Library]<br />

== See also ==
* [[Intermediate C++ Game Programming Tutorial 17|Next in series (Tutorial 17)]]
* [[Intermediate C++ Game Programming Series]]

Beginner C++ Game Programming Tutorial 9

2022-05-05T04:26:30Z

Chili: Text replacement - "http://www.planetchili.net/" to "https://www.planetchili.net/"

In this video we make our first class and Chili teaches us about the birds and the bees and the static constexpr.

== Concepts Taught ==
* Creating a <code>class</code>
* <code>public</code> vs. <code>private</code> access
* <code>static</code> member variables
* <code>constexpr</code> variables

== Video Timestamp Index ==
* Intro [https://www.youtube.com/watch?v=Wwgyw69MiEU&t=0m0s 0:00]
* ClampScreen code recap [https://www.youtube.com/watch?v=Wwgyw69MiEU&t=0m18s 0:18]
* The issue of the current Game data organization: [https://www.youtube.com/watch?v=Wwgyw69MiEU&t=1m38s 1:38]
* Classes: OOP to the rescue [https://www.youtube.com/watch?v=Wwgyw69MiEU&t=1m38s 2:25]
* Creating our own class [https://www.youtube.com/watch?v=Wwgyw69MiEU&t=3m21s 3:21]
* Header guard: <code>#pragma once</code> [https://www.youtube.com/watch?v=Wwgyw69MiEU&t=3m40s 3:40]
* Letting other files know about our class: including headers [https://www.youtube.com/watch?v=Wwgyw69MiEU&t=5m52s 5:52]
* Refactoring game code related to poo [https://www.youtube.com/watch?v=Wwgyw69MiEU&t=6m56s 6:56]
* A little trick: Advanced find + replace with regex enabled [https://www.youtube.com/watch?v=Wwgyw69MiEU&t=7m8s 7:08]
* Adding an implementation file (.cpp) for Poo class [https://www.youtube.com/watch?v=Wwgyw69MiEU&t=9m5s 9:05]
* Advantages of the new poo object oriented code [https://www.youtube.com/watch?v=Wwgyw69MiEU&t=12m7s 12:07]
* Initializing poos' velocities [https://www.youtube.com/watch?v=Wwgyw69MiEU&t=14m12s 14:12]
* Factoring out common attributes from class objects: <code>static</code> and <code>constexpr</code> [https://www.youtube.com/watch?v=Wwgyw69MiEU&t=14m41s 14:41]
* Difference between <code>constexpr</code> and <code>const</code> [https://www.youtube.com/watch?v=Wwgyw69MiEU&t=16m8s 16:08]
* Accessing static class members [https://www.youtube.com/watch?v=Wwgyw69MiEU&t=16m40s 16:40]
* Class member access restrictions: <code>public</code> vs <code>private</code> [https://www.youtube.com/watch?v=Wwgyw69MiEU&t=17m20s 17:20]
* Summing up what we have learned and a couple of tips [https://www.youtube.com/watch?v=Wwgyw69MiEU&t=19m12s 19:12]
* Homework [https://www.youtube.com/watch?v=Wwgyw69MiEU&t=20m3s 20:03]

== Homework ==
Make the Dude entity into a <code>class</code> as well. It's up to you to decide what member functions you should give it. Might want to add another function to <code>Poo</code> as well (hint hint hint!).

The solution is given in [https://youtu.be/b4FjV2R9jy0 this video].

== Downloads ==

* [https://www.planetchili.net/downloads/T9-Starting-Code.zip T9 Starting Code]
* [https://planetchili.net/downloads/apworks/9/Beginner%20Tutorial%209%20Code.zip Tutorial 9 Code]
* [https://planetchili.net/downloads/apworks/9/Beginner%20Tutorial%209%20HW%20Code.zip Tutorial 9 Homework Solution Code]

== See also ==
* [https://www.patreon.com/planetchili Planet Chili Patreon]
* [[Beginner C++ Game Programming Tutorial 10|Next in series (Tutorial 10)]]
* [[Beginner C++ Game Programming Series]]

Intermediate C++ Game Programming Tutorial 13

2022-05-05T04:26:29Z

Chili: Text replacement - "http://www.planetchili.net/" to "https://www.planetchili.net/"

In this tutorial we learn how to draw text to the screen. Now we can make anime sex games.

== Topics Covered ==
* Bitmap font sheet
* Text rendering
* Color replacement sprite effect

== Video Timestamp Index ==
[https://youtu.be/kpp7mxFUwSg Tutorial 13]

== Source Code ==
[https://github.com/planetchili/sprite Sprite Repo]

== Download Materials ==
* [https://www.planetchili.net/downloads/I13-Font-Sheets.zip Font Sheets]

== Homework ==
Modify the <code>Animation</code> class so that it draws the sprite frames with a translucent "ghost" effect.
* [https://youtu.be/KkJ3MU402ek Homework Solution]

== See also ==
* [[Intermediate C++ Game Programming Tutorial 14|Next in series (Tutorial 14)]]
* [[Intermediate C++ Game Programming Series]]

Intermediate C++ Game Programming Tutorial 11

2022-05-05T04:26:29Z

Chili: Text replacement - "http://www.planetchili.net/" to "https://www.planetchili.net/"

In this tutorial we learn how to draw parts (subregions) of images, we learn how to clip our shit so that it don't go off the screen (or off of any arbitrary rectangle we define in fact), and we learn to draw sprites with transparent pixels.

== Topics Covered ==
* Drawing image subregions
* Clipping sprites
* Drawing sprites with chroma keying (transparent pixels)

== Video Timestamp Index ==
[https://youtu.be/uHZmTmTRdkA Tutorial 11]
* Drawing subregions of a sprite sheet [https://youtu.be/uHZmTmTRdkA?t=57s 0:57]
* Using a <code>RectI clip</code> object, clip a (subregion of a) sprite [https://youtu.be/uHZmTmTRdkA?t=6m45s 6:45]
* Chili's Dank Meta Nugs - teacher's advice [https://youtu.be/uHZmTmTRdkA?t=13m16s 13:16]
* Code clean up. Have different overloaded definitions of <code>DrawSprite()</code> call the most advanced version with clipping [https://youtu.be/uHZmTmTRdkA?t=13m57s 13:57]
* Implement <code>DrawSprite</code> functions that apply chroma keying (transparent pixels) [https://youtu.be/uHZmTmTRdkA?t=15m03s 15:03]
* Adding <code>operator==</code> and <code>operator!=</code> member functions (comparison operators) to the <code>Color</code> class [https://youtu.be/uHZmTmTRdkA?t=17m37s 17:37]
* Homework assignment [https://youtu.be/uHZmTmTRdkA?t=19m00s 19:00]

== Source Code ==
[https://github.com/planetchili/sprite Sprite Repo]<br />
[https://github.com/planetchili/poo_game Poo Game Repo]

== Download Materials ==
* [https://www.planetchili.net/downloads/I11-Images.zip Tutorial and Homework Images]

== Homework ==
The homework is to use the images provided in the above zip file to upgrade the Poo Game to no longer use compiled sprites.
* [https://youtu.be/BPExmXz0Luk Homework solution video ]

== See also ==
* [[Intermediate C++ Game Programming Tutorial 12|Next in series (Tutorial 12)]]
* [[Intermediate C++ Game Programming Series]]

Chili Framework

2022-05-05T04:26:29Z

Chili: Text replacement - "http://www.planetchili.net/" to "https://www.planetchili.net/"

The Chili Framework is designed as a vehicle to make it fun and easy to learn C++ in a graphical context. It lightly wraps a bunch of pain-in-the-ass WinAPI and Direct3D bullshit giving us direct access to the framebuffer for manipulating screen pixels. This allows us to explore basic graphical concepts at the same time that we are learning the fundamentals of the C++ language. Our research shows that this results in a 69% lower incidence of learners shitting themselves to death out of sheer boredom.

== Core Classes ==

=== Game ===
:''Main article: [[Game (Chili Framework)]]''<br />

{{#lsth:Game (Chili Framework)}}

=== Graphics ===
:''Main article: [[Graphics (Chili Framework)]]''<br />

{{#lsth:Graphics (Chili Framework)}}

=== MainWindow ===
:''Main article: [[MainWindow (Chili Framework)]]''<br />

{{#lsth:MainWindow (Chili Framework)}}

=== Keyboard ===
:''Main article: [[Keyboard (Chili Framework)]]''<br />

{{#lsth:Keyboard (Chili Framework)}}

=== Mouse ===
:''Main article: [[Mouse (Chili Framework)]]''<br />

{{#lsth:Mouse (Chili Framework)}}

=== Color ===
<code>Color</code> represents a 32-bit RGBA color value (or a single pixel if you like), and gives you member functions to access the (fudge) packed channels. There is also a <code>Colors</code> namespace with predefined colors, like <code>Colors::Aqua</code> (not to be confused with Aqua, the majestic Danish eurodance group).

== Other Bullshit Components ==

=== Main ===
The <code>Main.cpp</code> file contains the function <code>wWinMain()</code>, which is the entry point for the program (where the whole shebang starts). It creates the <code>MainWindow</code> object, creates the <code>Game</code> object, and repeatedly performs the steps a) process all pending windows messages and b) process a game frame, until it is time for the big sleep. There is also a bunch of exception catching code to catch any stray exceptions and display their error information via a message box.

=== ChiliException ===
The class <code>ChiliException</code> forms the basis for all exceptions that will be generated by the framework or the game code. <code>Graphics::Exception</code> and <code>MainWindow::Exception</code> are specific types that inherit from <code>ChiliException</code>. If you want to <code>throw</code> your own exceptions, you should inherit from <code>ChiliException</code>, but that's kind of an advanced topic, so don't sweat it Broseph.

=== ChiliWin ===
This file should be included in lieu of <code><Windows.h></code>. It includes <code><Windows.h></code>, but before doing so it defines some preprocessor switches which set the target minimum version of Windows (Vista) and cut some unused bullshit from the included Windows code, saving on compilation time. If you somehow end up using weird WinAPI bullshit, you might need to modify this file to re-enable that code.

=== Framebuffer Shaders ===
Since D3D11 is a little bitch and won't let us touch its goodies (i.e. the backbuffer), we have to copy our composed frame over to a texture and then draw that texture to the backbuffer. Therefore, we need pixel and vertex shaders. Note that the solution is set up to first compile the shader sources to C++ header files (extension <code>*.shh</code>, which I just pulled out of my ass by the way) and then compile the C++ source files. <code>Graphics.cpp</code> includes the <code>*.shh</code> files, so when browsing the code of a fresh/cleaned solution you may notice errors in <code>Graphics.cpp</code>, but that's probably just because the <code>*.shh</code> files don't exist yet. Build once and those errors should disappear.

=== Resource ===
<code>ChiliFramework.rc</code> is the resource script for baking the icon <code>Chili.ico</code> into the executable, and <code>Resource.h</code> contains the ID number used to load the icon from the executable at runtime.

=== DXErr ===
Some code written by a guy at Microsoft that translates DirectX error codes into something with a little more ''je ne sais quoi''. Used to be part of the SDK, but whatever I guess. Licensing status not really clear.

== Miscellaneous ==

=== Criticisms ===
Some people resent a custom framework being used in the tutorials, because they feel that following the tutorials will "lock them into" someone else's proprietary framework, or because they want to start from an empty project. If you're one of these people, just chill out my dawg. The framework is pretty tiny and lightweight in the grand scheme of things, so you're not even going to invest enough time learning it to feel "locked in". This series is about learning C++, graphics, and games, not about learning a framework.<br />

The framework is just an accelerator that allows us to manipulate pixels directly, giving us intimate, carnal knowledge of how graphics works. The end goal is to work with Direct3D directly, so SDL, SFML, Unity, etc. are all overkill and would distract us from our main goal. The training wheels will come off when the time is right, and until then, the framework will allow us to focus on the most important topics first without a lot of bullshit that would just slow us down and maybe cause you to lose interest.

== How to Get the Framework ==
The the zipped Framework solution folder can be downloaded directly from [https://www.planetchili.net/downloads/Chili%20DirectX%20Framework.zip here]. You can also clone the [https://github.com/planetchili/chili_framework repository on GitHub]. Bone ape tit.

Beginner C++ Game Programming Tutorial 10

2022-05-05T04:26:29Z

Chili: Text replacement - "http://www.planetchili.net/" to "https://www.planetchili.net/"

In this video we learn how to loop our shit. Fuckoff copy and paste. Die in a gasoline fire (just kidding, don't leave me baby!)

== Concepts Taught ==
* <code>while</code> loop
* <code>for</code> loop
* <code>do</code> ... <code>while</code> loop
* Preincrement <code>++x</code> and postincrement <code>x++</code> operators

== Video Timestamp Index ==
* Intro [https://www.youtube.com/watch?v=rwJ0sOmBK6E&t=0m0s 0:00]
* The roadmap [https://www.youtube.com/watch?v=rwJ0sOmBK6E&t=0m20s 0:20]
* Loops: <code>while() {...}</code> [https://www.youtube.com/watch?v=rwJ0sOmBK6E&t=1m39s 1:39]
* Loops: <code>for() {...}</code> [https://www.youtube.com/watch?v=rwJ0sOmBK6E&t=8m20s 8:20]
* Increment/decrement unary operator [https://www.youtube.com/watch?v=rwJ0sOmBK6E&t=10m51s 10:51]
* Fun Chili fact for the day: the origins of the "C++" language name [https://www.youtube.com/watch?v=rwJ0sOmBK6E&t=11m51s 11:51]
* Loops: <code>do {...} while ()</code> [https://www.youtube.com/watch?v=rwJ0sOmBK6E&t=12m36s 12:36]
* Loop differences, when to use <code>for(){}</code>, <code>while(){}</code>, or <code>do{} while()</code> (if you are kinda weird) [https://www.youtube.com/watch?v=rwJ0sOmBK6E&t=13m15s 13:15]
* Chili's Dank Meta Nugs [https://www.youtube.com/watch?v=rwJ0sOmBK6E&t=15m6s 15:06]
* Homework [https://www.youtube.com/watch?v=rwJ0sOmBK6E&t=18m23s 18:23]

== Homework ==
# Write a routine to draw a rectangle on the screen.
# Make it so that you can control the position of the rectangle with the arrow keys and the size of the rectangle with the WASD keys. For info on querying keyboard input for alphanumeric keys, see the section "Virtual Key Codes" on [[Keyboard (Chili Framework)#Virtual_Key_Codes|this page]].

The solution is given in a [https://youtu.be/lWTwNXfU-Nc this] video.

== Downloads ==

* [https://www.planetchili.net/downloads/Chili%20DirectX%20Framework.zip Framework Download]
* [https://planetchili.net/downloads/apworks/10/Beginner%20Tutorial%2010%20Code.zip Tutorial 10 Code]
* [https://planetchili.net/downloads/apworks/10/Beginner%20Tutorial%2010%20HW%20Code.zip Tutorial 10 Homework Solution Code]

== See also ==
* [https://www.patreon.com/planetchili Planet Chili Patreon]
* [[Beginner C++ Game Programming Tutorial 11|Next in series (Tutorial 11)]]
* [[Beginner C++ Game Programming Series]]

Beginner C++ Game Programming Tutorial 13

2022-05-05T04:26:29Z

Chili: Text replacement - "http://www.planetchili.net/" to "https://www.planetchili.net/"

In this lesson we learn about the bomb-ass data structure known as the array, the granddaddy of them all. We also learn about boring shit like the automatically-generated default constructor (BOOOOORIIIIING! NEEEEEERRRD!).

== Concepts Taught ==
* Arrays
* Default Constructor
* Using <code>assert</code>s

== Video Timestamp Index ==
* Intro [https://www.youtube.com/watch?v=U4IdBkegBuY&t=0m0s 0:00]
* Mean average code example: local variables analysis in debugger [https://www.youtube.com/watch?v=U4IdBkegBuY&t=0m54s 0:54]
* Arrays visualization in memory, arrays anatomy [https://www.youtube.com/watch?v=U4IdBkegBuY&t=2m37s 2:37]
* Declaring an array in C++ [https://www.youtube.com/watch?v=U4IdBkegBuY&t=5m19s 5:19]
* Array size must be known at compile time [https://www.youtube.com/watch?v=U4IdBkegBuY&t=7m20s 7:20]
* What's so good about arrays: Using arrays in loops [https://www.youtube.com/watch?v=U4IdBkegBuY&t=8m23s 8:23]
* Array size limit [https://www.youtube.com/watch?v=U4IdBkegBuY&t=11m22s 11:22]
* Refactoring Poo Game: Using arrays [https://www.youtube.com/watch?v=U4IdBkegBuY&t=13m20s 13:20]
* Useful logic pattern for determining if all elements "return true" [https://www.youtube.com/watch?v=U4IdBkegBuY&t=15m25s 15:25]
* Constructing array of objects: default constructor [https://www.youtube.com/watch?v=U4IdBkegBuY&t=18m30s 18:30]
* Note: There are special member functions in C++ [https://www.youtube.com/watch?v=U4IdBkegBuY&t=19m54s 19:54]
* Initializing poos [https://www.youtube.com/watch?v=U4IdBkegBuY&t=21m39s 21:39]
* Disadvantage of initializing poos this way (<code>Init()</code> funciton): breaks encapsulation [https://www.youtube.com/watch?v=U4IdBkegBuY&t=23m53s 23:53]
* Making it a little better: [https://www.youtube.com/watch?v=U4IdBkegBuY&t=25m7s 25:07]
* Another, bigger disadvantage of initializing poos using <code>Init()</code> funciton: <code>Init()</code> is separate from object construction, and thus could be easily desynchronized. [https://www.youtube.com/watch?v=U4IdBkegBuY&t=28m18s 28:18]
* Solving above issue [https://www.youtube.com/watch?v=U4IdBkegBuY&t=29m7s 29:07]
* Safety checks: Is it worth it? [https://www.youtube.com/watch?v=U4IdBkegBuY&t=30m28s 30:28]
* In the future we will learn about vectors, a better solution for above problems [https://www.youtube.com/watch?v=U4IdBkegBuY&t=31m5s 31:05]
* Homework [https://www.youtube.com/watch?v=U4IdBkegBuY&t=31m41s 31:41]

== Homework ==
# Make it so that touching the poo is game over and the goal is to reach a square.
# Make the square's color pulsate and make a meter that keeps track of how many times the goal was reached.

The solution is given in [https://www.youtube.com/watch?v=g4Xwf8XK2Ew this] video.

== Downloads ==

* The starting code for Tutorial 13 is [https://www.planetchili.net/downloads/T13-Poo.zip here].
* [https://planetchili.net/downloads/apworks/13/Beginner%20Tutorial%2013%20Code.zip Tutorial 13 Code]
* [https://planetchili.net/downloads/apworks/13/Beginner%20Tutorial%2013%20HW%20Code.zip Tutorial 13 Homework Solution Code]

== See also ==
* [https://www.patreon.com/planetchili Planet Chili Patreon]
* [[Beginner C++ Game Programming Tutorial 14|Next in series (Tutorial 14)]]
* [[Beginner C++ Game Programming Series]]

Beginner C++ Game Programming Tutorial 14

2022-05-05T04:23:29Z

Chili: Text replacement - "http://www.planetchili.net/" to "https://www.planetchili.net/"

This is a two-part tutorial in which we tackle a game with a little more substance--the Snake Game. Grids and arrays galore. Majestic.

== Super Important NOTE(S) ==
The Snek game is a little more complicated than the Poo game. Don't get butthurt and give up if you can't make it work. Just make sure you understand the Main Concepts Taught listed below. <span style="color:pink">You can always move on to the next tutorials and come back to the Snek game later when you've got a little more experience under your belt.</span> And as usual, if you're lost or just have some lingering questions, the forum is a great place to go for help. Here is a forum discussion about the Snek game code: [https://www.planetchili.net/forum/viewtopic.php?f=3&t=3838 Snek Talk]. Feel free to chime in and add info or ask questions! You can also @mention me on the [https://www.planetchili.net/discord Discord] and maybe we can talk in real time (timezone diffs might make this hard thoough).

If you are going to attempt to finish the game off by yourself at the end of T14a (good on you mate), there is something you should be aware of. The function <code>Snake::Grow()</code> does not set the position of the "new" segment when it grows the snake. So you '''absolutely must''' call <code>Snake::MoveBy(...)</code> '''''before''''' you draw the snake. If you attempt to draw the snake after growing, but without moving first, the last segment will have an invalid <code>loc</code>, and trying to draw it in that state will most likely crash the program.

Also, there is a bug in the <code>Snake::Grow()</code> function at the end of 14a. See if you can figure out what it is, and how to fix it... :)

== Main Concepts Taught ==
* Managing used/unused sections of an array
* <code>struct</code> vs <code>class</code>
* Inner (nested) <code>class</code>es
* <code>operator</code> overloading
* Special functions: copy constructor and copy assignment (briefly)
* The <code>%</code> (modulus) operator (in the solution video)
* The <code>std::max()</code> function (in the solution video)

== Other New(ish) Things ==

There was a bunch of other newish bullshit that Chili used, some of which he didn't go into much depth on. For those of you who give a shit, here is some extra info.

==== Aggregate Initialization <code>{}</code> ====
With the <code>struct Location</code> (and later, <code>class</code>), we didn't define any constructors, so all we had was the default do-nothing constructor that is generated by the compiler. In order to initialize a <code>Location</code> at one point in the video, Chili used something like <code>Location loc = {69,69};</code>. This is allowed, but the data type being initialized must satisfy certain conditions. Namely, it must have only <code>public</code> data members and it must have no constructors defined. For the full details on the requirements, see [http://en.cppreference.com/w/cpp/language/aggregate_initialization this page]. The brace <code>{}</code> initialization can be used for <code>class</code>es etc. that have constructors as well, but then the parameters have to conform to the constructor(s) and it will just call the applicable constructor.

==== Compiler-Generated Copy Constructor and Copy Assignment <code>operator</code> ====
In the tutorial, we assign <code>Location</code> objects to one another, and we construct a <code>Location</code> by copying an existing one. These operations actually call member functions that are defined for the <code>class</code> (or <code>struct</code>), and if you do not supply these member functions, the compiler will generate them by default (as is the case in this tutorial).

* <code>ClassName::ClassName( const ClassName& )</code>
This is the default copy constructor, and its behavior is to, in turn, copy construct each of the members of the object under construction using the corresponding member in the object being passed in.
* <code>ClassName& ClassName::operator=( const ClassName& )</code>
This is the default copy assignment operator, and its behavior is to, in turn, copy assign each of the members of the object under assignment using the corresponding member in the object being passed in. It also returns a reference to the object under assignment.

== Video Timestamp Index ==
[https://youtu.be/KTyemy82Zqk Tutorial 14a]

[https://youtu.be/DoO_NEksf3c Tutorial 14b]

== Homework ==
The homework is to add some polish to the Snek Game. The following features are suggested and will be covered in the solution video.
* Adjustable board position
* Border drawn around board
* Padding between board tiles
* Display title screen
* Give the Snek a pattern of colors for its segments
* Make it so the Snek speeds up over time

In addition, it is suggested that you extend the Snek game by adding some new mechanics to spice things up. One suggestion is making randomly spawning obstacles that accrue on the game board. Note that this extra challenge will not be covered in the solution video. If you are attempting it (or some other feature) and need some help, you can seek help on the [[Planet_Chili_Forums|forum]] or the [http://www.planetchili.net Discord].

The solution video is [https://www.youtube.com/watch?v=aE9fGMRRe6U here].

== Downloads ==

* [https://www.planetchili.net/downloads/T14-Snek-Start.zip Snek Starting Solution]
* [https://github.com/planetchili/snek GitHub Repo Containing Finished Snek Game]

== See also ==
* [https://www.patreon.com/planetchili Planet Chili Patreon]
* [[Beginner C++ Game Programming Tutorial 15|Next in series (Tutorial 15)]]
* [[Beginner C++ Game Programming Series]]

Planet Chili Forums

2022-05-05T04:23:20Z

Chili: Text replacement - "http://www.planetchili.net/" to "https://www.planetchili.net/"

The [http://forum.planetchili.net Forum] is the heart of the PlanetChili.net community. This is the best place to ask for help with the tutorials, connect with like-minded programmers and bounce ideas, or just generally shitpost. If you want to talk to and receive a reply from the Chili himself, your best bet is on the Forums.

== <span style="color:red">How to Ask for Coding Help</span> ==
Coding and troubleshooting help is given via the Forum or on Discord.

Whenever possible, '''always''' attach your complete Visual Studio solution with any request for help. Asking someone to debug your code without giving them the code so that they can run the debugger on it is simply not the done thing. The solution folder should be '''cleaned''' and zipped before posting it. Alternatively, consider submitting solutions via GitHub.
=== Cleaning a Solution ===
Visual Studio maintains a bunch of cached data in the solution folder that pushes the total size to 50 MB or more, and that shit is gonna be too big to share. What you need to do is delete those files before you zip the folder. A properly cleaned solution (without any large files like audio) should definitely be less than 500 kb in size (maybe up to a couple of MB if you got a ton of huge putpixel functions).
The following files and folders should be deleted if they exist (some of them will be hidden, so you need to change your windows settings to show hidden files and folders):
* engine\debug\
* engine\release\
* engine\x64\
* engine\*.shh
* engine\resource.aps
* .git\ <small>''(this one will be hidden)''</small>
* .vs\ <small>''(this one will be hidden)''</small>
* debug\
* release\
* x64\
* .gitattributes
* .gitignore
* chili framework 2016.vc.db
If you are using source control (git), make sure you make a copy of the solution folder before deleting these files, as you will lose your git repo if you do not operate on a copy.


== How to Register an Account ==
To combat the evil spamlords, I put in a weird captcha thing to separate the men from the bots. There are two categories, one on the top and one on the bottom. Shit that sounds good, and shit that sounds terrible (want and do not want). Just drag the list items down (or up) and organize the list into good shit and bad shit. It's that easy. If you're still having trouble, check out [https://youtu.be/XalB8Wcf4Bk?t=4m43s this video].

== Link to the Forum ==
* [http://forum.planetchili.net Planet Chili Forum]

Beginner C++ Game Programming Tutorial 12

2022-05-05T04:20:34Z

Chili: Text replacement - "http://www.planetchili.net/" to "https://www.planetchili.net/"

Here we learn about the concept of encapsulation (ask your mom where she keeps the Vicodin!), which is the main principle behind object oriented programming (so listen the fuck up eh?). We also learn how to construct shit, and how to make our shit private.

== <span style="color:pink">Important Note</span> ==
Visual Studio has a <cool feature> wherein when you use "quick actions... -> move definition location" on a constructor, it adds a goddamn <code>inline</code> keyword which fucks the whole goddamn works up! D:< This is fixed in the homework solution, but if you are attempting the homework before peeking (as you should be), then this could fuck you up royally. Keep it in mind.

== Concepts Taught ==
* Encapsulation and data hiding
* How to create a constructor
* How do initialize embedded objects (class initializer list)
* How to control member access (<code>private</code> keyword)

== Encapsulation ==
[http://stackoverflow.com/questions/18300953/why-encapsulation-is-an-important-feature-of-oop-languages/18301027#18301027 This page] has some interesting discussion on why we bother with all this encapsulation bullshit.

== Video Timestamp Index ==
* Intro [https://www.youtube.com/watch?v=QUBiAUKfVhM&t=0m0s 0:00]
* Encapsulation: Difference between <code>public</code> and <code>private</code> data members [https://www.youtube.com/watch?v=QUBiAUKfVhM&t=0m55s 0:55]
* Poo class: Making member data private [https://www.youtube.com/watch?v=QUBiAUKfVhM&t=2m43s 2:43]
* Important note on "Getters" and "Setters" [https://www.youtube.com/watch?v=QUBiAUKfVhM&t=5m0s 5:00]
* Advantages of <code>private</code> member data with a getter and setter, as opposed to just <code>public</code> member data [https://www.youtube.com/watch?v=QUBiAUKfVhM&t=7m7s 7:07]
* Constructors: setting values during object initialization [https://www.youtube.com/watch?v=QUBiAUKfVhM&t=9m30s 9:30]
* Class initializer list: Initializing embedded objects (Poo objects inside a Game object) [https://www.youtube.com/watch?v=QUBiAUKfVhM&t=12m34s 12:34]
* Class initializer list order must correspond to the order of data member declaraion [https://www.youtube.com/watch?v=QUBiAUKfVhM&t=17m10s 17:10]
* Visual Studio tricks: Quick actions -> Move definition location, but with a little brainfucky surprize you will learn about very soon [https://www.youtube.com/watch?v=QUBiAUKfVhM&t=19m59s 19:59]
* Reasons to properly encapsulate class member data [https://www.youtube.com/watch?v=QUBiAUKfVhM&t=20m52s 20:52]
* Homework [https://www.youtube.com/watch?v=QUBiAUKfVhM&t=30m10s 30:10]

== Homework ==
# Encapsulate the fuck out of the <code>Dude</code> class.
# Increase the number of <code>Poo</code> objects from 3 to 9.

The solution is given in [https://youtu.be/8Lb-E4g0lpc this video].

== Downloads ==

* The starting code for Tutorial 12 is [https://www.planetchili.net/downloads/T12-Poo.zip here].
* [https://planetchili.net/downloads/apworks/12/Beginner%20Tutorial%2012%20Code.zip Tutorial 12 Code]
* [https://planetchili.net/downloads/apworks/12/Beginner%20Tutorial%2012%20HW%20Code.zip Tutorial 12 Homework Solution Code]

== See also ==
* [https://www.patreon.com/planetchili Planet Chili Patreon]
* [[Beginner C++ Game Programming Tutorial 13|Next in series (Tutorial 13)]]
* [[Beginner C++ Game Programming Series]]

ASM and Chill with Chili 1

2022-04-12T01:54:41Z

Chili:

In this video Chili reacquaints himself with TASM and x86 assembly, going over the basics of setting up a .asm source file, and calling some system services (BIOS int 10h, int 16h, DOS int 21h). We then mess with some looping and counting, defining some global data and getting pointers (offsets), and then we go all the way in and do some real calculations, fucking shit up real good along the way. But debug.exe has got our back, and we squash the bugs while also showing you guys the machine code being executed instruction by instruction by the CPU, and how it affects the state of the registers and RAM.

== Stuff ==

Knowledge bombs will go here if there is demand for them / I have the time to jam it in (gurl).

== Tools ==

Here is the zip file containing DOSBox and TASM all set up for ya [https://www.planetchili.net/downloads/DOSBox-Chili.zip Tool Download].

== Links ==

* The list of ASM and Chill vids: [[Patreon Exclusive Content#ASM and Chill with Chili|the swag list]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]

Main Page

2021-04-25T01:56:32Z

Chili:

[[File:Cplogo-big.png|right|caption]]
<p style="color:#BFB;font-size:180%;font-weight:bold;">Welcome to Chilipedia!</p>
<p>This is Chilipedia. You can do anything at Chilipedia, anything at all. The only limit is yourself. The infinite is possible at Chilipedia. The unattainable is unknown at Chilipedia. Welcome to Chilipedia.</p>
<p>If this is your first time at Chilipedia, might I recommend the [[Beginner C++ Game Programming Series]] page, it is ''especially'' derpy and unprofessional today. If you're looking for something a little spicier, check out the [[Intermediate C++ Game Programming Series]] and the [[Advanced C++ Programming Series]], or for something with a little more depth, check out the [[3D Fundamentals Series]] and its sequel, the [[Hardware 3D Series (C++ DirectX Graphics)]]. Also [[STD Gems]] is a thing. Or you can always order à la carte from among our [[Special:AllPages|extensive selection of pure garbage]] (<span style="color:red">PSST! try out the search feature (top right of this page)!</span>). A list of [[Tools & Resources]] that were found helpful by the Chili community.</p>
<p>For all other things that are Chili-related, check out the [http://www.planetchili.net Planet Chili Nexus].
</p>
<p>Also if you are a patreon, I have some stuff for you on the [http://wiki.planetchili.net/index.php?title=Patreon_Exclusive_Content Patreon Exclusive Content] page.</p>

Beginner C++ Game Programming Tutorial 14

2021-04-02T12:12:38Z

Chili:

This is a two-part tutorial in which we tackle a game with a little more substance--the Snake Game. Grids and arrays galore. Majestic.

== Super Important NOTE(S) ==
The Snek game is a little more complicated than the Poo game. Don't get butthurt and give up if you can't make it work. Just make sure you understand the Main Concepts Taught listed below. <span style="color:pink">You can always move on to the next tutorials and come back to the Snek game later when you've got a little more experience under your belt.</span> And as usual, if you're lost or just have some lingering questions, the forum is a great place to go for help. Here is a forum discussion about the Snek game code: [http://www.planetchili.net/forum/viewtopic.php?f=3&t=3838 Snek Talk]. Feel free to chime in and add info or ask questions! You can also @mention me on the [http://www.planetchili.net/discord Discord] and maybe we can talk in real time (timezone diffs might make this hard thoough).

If you are going to attempt to finish the game off by yourself at the end of T14a (good on you mate), there is something you should be aware of. The function <code>Snake::Grow()</code> does not set the position of the "new" segment when it grows the snake. So you '''absolutely must''' call <code>Snake::MoveBy(...)</code> '''''before''''' you draw the snake. If you attempt to draw the snake after growing, but without moving first, the last segment will have an invalid <code>loc</code>, and trying to draw it in that state will most likely crash the program.

Also, there is a bug in the <code>Snake::Grow()</code> function at the end of 14a. See if you can figure out what it is, and how to fix it... :)

== Main Concepts Taught ==
* Managing used/unused sections of an array
* <code>struct</code> vs <code>class</code>
* Inner (nested) <code>class</code>es
* <code>operator</code> overloading
* Special functions: copy constructor and copy assignment (briefly)
* The <code>%</code> (modulus) operator (in the solution video)
* The <code>std::max()</code> function (in the solution video)

== Other New(ish) Things ==

There was a bunch of other newish bullshit that Chili used, some of which he didn't go into much depth on. For those of you who give a shit, here is some extra info.

==== Aggregate Initialization <code>{}</code> ====
With the <code>struct Location</code> (and later, <code>class</code>), we didn't define any constructors, so all we had was the default do-nothing constructor that is generated by the compiler. In order to initialize a <code>Location</code> at one point in the video, Chili used something like <code>Location loc = {69,69};</code>. This is allowed, but the data type being initialized must satisfy certain conditions. Namely, it must have only <code>public</code> data members and it must have no constructors defined. For the full details on the requirements, see [http://en.cppreference.com/w/cpp/language/aggregate_initialization this page]. The brace <code>{}</code> initialization can be used for <code>class</code>es etc. that have constructors as well, but then the parameters have to conform to the constructor(s) and it will just call the applicable constructor.

==== Compiler-Generated Copy Constructor and Copy Assignment <code>operator</code> ====
In the tutorial, we assign <code>Location</code> objects to one another, and we construct a <code>Location</code> by copying an existing one. These operations actually call member functions that are defined for the <code>class</code> (or <code>struct</code>), and if you do not supply these member functions, the compiler will generate them by default (as is the case in this tutorial).

* <code>ClassName::ClassName( const ClassName& )</code>
This is the default copy constructor, and its behavior is to, in turn, copy construct each of the members of the object under construction using the corresponding member in the object being passed in.
* <code>ClassName& ClassName::operator=( const ClassName& )</code>
This is the default copy assignment operator, and its behavior is to, in turn, copy assign each of the members of the object under assignment using the corresponding member in the object being passed in. It also returns a reference to the object under assignment.

== Video Timestamp Index ==
[https://youtu.be/KTyemy82Zqk Tutorial 14a]

[https://youtu.be/DoO_NEksf3c Tutorial 14b]

== Homework ==
The homework is to add some polish to the Snek Game. The following features are suggested and will be covered in the solution video.
* Adjustable board position
* Border drawn around board
* Padding between board tiles
* Display title screen
* Give the Snek a pattern of colors for its segments
* Make it so the Snek speeds up over time

In addition, it is suggested that you extend the Snek game by adding some new mechanics to spice things up. One suggestion is making randomly spawning obstacles that accrue on the game board. Note that this extra challenge will not be covered in the solution video. If you are attempting it (or some other feature) and need some help, you can seek help on the [[Planet_Chili_Forums|forum]] or the [http://www.planetchili.net Discord].

The solution video is [https://www.youtube.com/watch?v=aE9fGMRRe6U here].

== Downloads ==

* [https://www.planetchili.net/downloads/T14-Snek-Start.zip Snek Starting Solution]
* [https://github.com/planetchili/snek GitHub Repo Containing Finished Snek Game]

== See also ==
* [https://www.patreon.com/planetchili Planet Chili Patreon]
* [[Beginner C++ Game Programming Tutorial 15|Next in series (Tutorial 15)]]
* [[Beginner C++ Game Programming Series]]

Beginner C++ Game Programming Tutorial 0

2020-12-17T10:24:14Z

Chili:

This tutorial introduces the [[Beginner C++ Game Programming Series]] and walks you through the setup required to follow along with Chili. It also explains who the series is intended for, the goals and outline of the series, and tips on how to succeed, but you can skip all that bullshit if you have crippling ADD. For a detailed list of what is covered in Beginner, see [[Beginner C++ Game Programming Series#Topics Covered|this page]].

== <span style="color:#FF0000">IMPORTANT NOTE!</span> ==
Since this video was recorded, Microsoft has released Visual Studio 2017 Community and Visual Studio 2019 Community. You can still download VS2015 and use it for the tutorials, and this might make things a little simpler (<u>2015 is actually a lot better for learning C++ at this point than the newer releases of Visual Studio</u>), but the new Visual Studio 2017 and Visual Studio 2019 can also be used in the tutorials. However, the installation processes for VS2017 and VS2019 are different, and when you open a [[Chili Framework|Framework]] solution in newer releases of VS for the first time, there is an automatic dialog that you need to handle in order to upgrade the solution to VS2017 or VS2019 (And sometimes, even if you handle the dialog properly, you still get fucked over and have to fix things manually. Thanks Obama!).

Check out [https://youtu.be/39IsItNIoQs <big>THIS VIDEO</big>] for details on the installation of VS2017 and the process of opening a framework solution in VS2017.

A separate video on getting started with VS2019 is gonna get pooped out soon.

== Concepts Taught ==
* How to install [[Microsoft Visual Studio|Visual Studio 2015 Community]]
* How to [[compiler|compile]] and run a solution in Visual Studio

== Video Timestamp Index ==
* Intro [https://youtu.be/PwuIEMUFUnQ 0:00]
* Why C++ [https://youtu.be/PwuIEMUFUnQ?t=0m55s 0:55]
* Overview of entire curriculum [https://youtu.be/PwuIEMUFUnQ?t=1m57s 1:57]
* Required software, hardware, and knowledge [https://youtu.be/PwuIEMUFUnQ?t=2m44s 2:44]
* Setup of Visual Studio and [[Chili Framework|the Framework]] [https://youtu.be/PwuIEMUFUnQ?t=3m26s 3:26]
* Don't freak out about the Framework [https://youtu.be/PwuIEMUFUnQ?t=4m22s 6:05]
* Talk about the solution folder and source files [https://youtu.be/PwuIEMUFUnQ?t=7m52s 7:52]
* Configuration of the Visual Studio UI [https://youtu.be/PwuIEMUFUnQ?t=8m57s 8:57]
* First compile and run [https://youtu.be/PwuIEMUFUnQ?t=9m52s 9:52]
* Yo where the .exe at tho? [https://youtu.be/PwuIEMUFUnQ?t=11m13s 11:13]
* First line of code and challenge (Homework) [https://youtu.be/PwuIEMUFUnQ?t=12m07s 12:07]
* How to interact with Chili / get programming help on the [[Planet Chili Forums|Forum]] [https://youtu.be/PwuIEMUFUnQ?t=14m27s 14:27]

== Homework ==
The homework for this lesson is to experiment with the [[Graphics (Chili Framework)#PutPixel()|<code>PutPixel()</code>]] function and deduce the meanings of the five function parameters. The solution to this challenge is given at the beginning of the next tutorial.

== Download Links ==
* [https://visualstudio.microsoft.com/vs/older-downloads/ Visual Studio 2015 Community Download]

* [https://www.visualstudio.com/thank-you-downloading-visual-studio/?sku=Community&rel=15 Visual Studio 2017 Community Download]

* [https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community&rel=16 Visual Studio 2019 Community Download]

* [https://planetchili.net/downloads/Chili%20DirectX%20Framework.zip Framework Download]

== See also ==
* [[Beginner C++ Game Programming Tutorial 1|Next in series (Tutorial 1)]]
* [[Beginner C++ Game Programming Series]]
* [[Planet Chili Forums]]

Hardware 3D Series (C++ DirectX Graphics)

2020-09-25T05:06:09Z

Chili:

The Hardware 3D series (HW3D) teaches the Direct3D 11 API and HLSL (High Level Shader Language). This includes basic instruction in the Windows API for the purposes of creating a window and processing input messages. The goal of this seriesis to give the student the skills necessary to create a basic 3D engine in Direct3D in C++ from scratch. This series builds upon the concepts introduced in previous series.

== List of Tutorials ==
{| style="border:1px solid grey;border-collapse:collapse;width=100%;"
|- style="border:1px solid grey;background-color:#DDF;color:black;font-weight:bold;text-align:center;"
| style="width:10%;border:1px solid grey;"|Tutorial Number
| style="width:60%;border:1px solid grey;"|Title
| style="width:16%;border:1px solid grey;"|Release Date
| style="width:14%;border:1px solid grey;"|Runtime
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|0
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 0|Hardware 3D [Introduction]]]
| style="border:1px solid grey;"|December 16, 2018
| style="border:1px solid grey;"|7:48
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 0}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|1
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 1|Hardware 3D [WinMain]]]
| style="border:1px solid grey;"|December 20, 2018
| style="border:1px solid grey;"|10:49
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 1}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|2
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 2|Hardware 3D [Window Creation]]]
| style="border:1px solid grey;"|December 22, 2018
| style="border:1px solid grey;"|18:42
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 2}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|3
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 3|Hardware 3D [Message Loop / WndProc]]]
| style="border:1px solid grey;"|December 27, 2018
| style="border:1px solid grey;"|17:18
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 3}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|4
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 4|Hardware 3D [Windows Messages]]]
| style="border:1px solid grey;"|December 30, 2018
| style="border:1px solid grey;"|13:30
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 4}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|5
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 5|Hardware 3D [WM_CHAR / Mouse]]]
| style="border:1px solid grey;"|January 5, 2019
| style="border:1px solid grey;"|10:28
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 5}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|6
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 6|Hardware 3D [Window Framework]]]
| style="border:1px solid grey;"|January 11, 2019
| style="border:1px solid grey;"|28:14
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 6}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|7
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 7|Hardware 3D [Error Handling / Custom Icons]]]
| style="border:1px solid grey;"|January 18, 2019
| style="border:1px solid grey;"|25:18
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 7}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|8
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 8|Hardware 3D [Keyboard / WM_SYSKEYDOWN]]]
| style="border:1px solid grey;"|January 26, 2019
| style="border:1px solid grey;"|19:05
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 8}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|9
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 9|Hardware 3D [Mouse / Mouse Capture]]]
| style="border:1px solid grey;"|January 31, 2019
| style="border:1px solid grey;"|18:05
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 9}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|10
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 10|Hardware 3D [App class / PeekMessage]]]
| style="border:1px solid grey;"|February 3, 2019
| style="border:1px solid grey;"|11:47
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 10}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|11
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 11|Hardware 3D [COM (Component Object Model)]]]
| style="border:1px solid grey;"|February 8, 2019
| style="border:1px solid grey;"|37:05
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 11}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|12
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 12|Hardware 3D [D3D Architecture / Swap Chain]]]
| style="border:1px solid grey;"|February 16, 2019
| style="border:1px solid grey;"|17:45
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 12}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|13
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 13|Hardware 3D [Device Init / Fill Screen / Present]]]
| style="border:1px solid grey;"|February 22, 2019
| style="border:1px solid grey;"|19:06
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 13}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|14
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 14|Hardware 3D [Debug Layer Diagnostics]]]
| style="border:1px solid grey;"|March 2, 2019
| style="border:1px solid grey;"|17:42
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 14}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|15
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 15|Hardware 3D [ComPtr Smart Pointer]]]
| style="border:1px solid grey;"|March 6, 2019
| style="border:1px solid grey;"|10:50
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 15}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|16
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 16|Hardware 3D [First Triangle]]]
| style="border:1px solid grey;"|March 9, 2019
| style="border:1px solid grey;"|31:43+
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 16}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|17
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 17|Hardware 3D [Pipeline Exploration]]]
| style="border:1px solid grey;"|March 23, 2019
| style="border:1px solid grey;"|24:23
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 17}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|18
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 18|Hardware 3D [Constant Buffers]]]
| style="border:1px solid grey;"|March 30, 2019
| style="border:1px solid grey;"|15:56
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 18}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|19
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 19|Hardware 3D [DirectXMath]]]
| style="border:1px solid grey;"|April 6, 2019
| style="border:1px solid grey;"|18:57
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 19}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|20
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 20|Hardware 3D [3D Cube / Z-Buffer]]]
| style="border:1px solid grey;"|April 13, 2019
| style="border:1px solid grey;"|23:03
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 20}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|21
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 21|Hardware 3D [Bindable / Drawable System]]]
| style="border:1px solid grey;"|April 20, 2019
| style="border:1px solid grey;"|24:32+
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 21}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|22
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 22|Hardware 3D [Texture Mapping]]]
| style="border:1px solid grey;"|May 4, 2019
| style="border:1px solid grey;"|22:48
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 22}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|23
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 23|Hardware 3D [Test GUI (imgui) / Camera]]]
| style="border:1px solid grey;"|May 11, 2019
| style="border:1px solid grey;"|25:20
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 23}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|24
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 24|Hardware 3D [Dynamic Lighting / Graphics Debugger]]]
| style="border:1px solid grey;"|May 18, 2019
| style="border:1px solid grey;"|28:56+
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 24}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|25
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 25|Hardware 3D [Mesh Loading Assimp / Git History Fixing]]]
| style="border:1px solid grey;"|June 8, 2019
| style="border:1px solid grey;"|23:12
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 25}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|26
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 26|Hardware 3D [Dynamic Vertex / Template Metaprogramming Bullshit]]]
| style="border:1px solid grey;"|June 16, 2019
| style="border:1px solid grey;"|43:48
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 26}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|27
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 27|Hardware 3D [Scene Graph]]]
| style="border:1px solid grey;"|June 28, 2019
| style="border:1px solid grey;"|27:50
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 27}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|28
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 28|Hardware 3D [Node Tree / Transform Propagation]]]
| style="border:1px solid grey;"|July 6, 2019
| style="border:1px solid grey;"|29:40
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 28}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|29
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 29|Hardware 3D [Cursor Hide / Cursor Confine]]]
| style="border:1px solid grey;"|July 13, 2019
| style="border:1px solid grey;"|13:33
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 29}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|30
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 30|Hardware 3D [Raw Mouse Input]]]
| style="border:1px solid grey;"|July 21, 2019
| style="border:1px solid grey;"|13:38
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 30}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|31
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 31|Hardware 3D [First Person Camera]]]
| style="border:1px solid grey;"|July 27, 2019
| style="border:1px solid grey;"|17:05
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 31}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|32
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 32|Hardware 3D [Material Loading]]]
| style="border:1px solid grey;"|August 4, 2019
| style="border:1px solid grey;"|26:50
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 32}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|33
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 33|Hardware 3D [Bindable Codex]]]
| style="border:1px solid grey;"|August 12, 2019
| style="border:1px solid grey;"|32:53
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 33}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|34
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 34|Hardware 3D [Normal Mapping Part 1]]]
| style="border:1px solid grey;"|August 27, 2019
| style="border:1px solid grey;"|26:40+
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 34}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|35
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 35|Hardware 3D [Extreme Goblin Energy]]]
| style="border:1px solid grey;"|September 21, 2019
| style="border:1px solid grey;"|33:45
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 35}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|36
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 36|Hardware 3D [Renormalization]]]
| style="border:1px solid grey;"|September 29, 2019
| style="border:1px solid grey;"|34:45
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 36}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|37
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 37|Hardware 3D [Sponza Test Map]]]
| style="border:1px solid grey;"|October 12, 2019
| style="border:1px solid grey;"|32:26
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 37}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|38
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 38|Hardware 3D [Mipmapping / Anisotropic Filtering]]]
| style="border:1px solid grey;"|October 26, 2019
| style="border:1px solid grey;"|22:58
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 38}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|39
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 39|Hardware 3D [Alpha Blending / Transparency]]]
| style="border:1px solid grey;"|November 17, 2019
| style="border:1px solid grey;"|37:06
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 39}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|40
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 40|Hardware 3D [DirectXTex / JSON Batch]]]
| style="border:1px solid grey;"|December 1, 2019
| style="border:1px solid grey;"|25:06
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 40}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|41
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 41|Hardware 3D [Dynamic Constant Buffer]]]
| style="border:1px solid grey;"|December 13, 2019
| style="border:1px solid grey;"|1:18:02
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 41}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|42
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 42|Hardware 3D [Stencil Buffer Outline Effect]]]
| style="border:1px solid grey;"|December 28, 2019
| style="border:1px solid grey;"|23:05
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 42}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|43
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 43|Hardware 3D [Render Queue System]]]
| style="border:1px solid grey;"|January 18, 2020
| style="border:1px solid grey;"|36:10
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 43}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|44
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 44|Hardware 3D ["Visitor" Probe / Static Meta "Bridge"]]]
| style="border:1px solid grey;"|February 1, 2020
| style="border:1px solid grey;"|21:43
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 44}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|45
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 45|Hardware 3D [Dynamic Technique Composition]]]
| style="border:1px solid grey;"|February 16, 2020
| style="border:1px solid grey;"|30:00
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 45}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|46
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 46|Hardware 3D [Fullscreen Filters (Blur)]]]
| style="border:1px solid grey;"|February 29, 2020
| style="border:1px solid grey;"|31:18
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 46}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|47
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 47|Hardware 3D [Separated Gaussian Filter]]]
| style="border:1px solid grey;"|March 15, 2020
| style="border:1px solid grey;"|24:10+
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 47}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|48
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 48|Hardware 3D [Render Graph]]]
| style="border:1px solid grey;"|March 28, 2020
| style="border:1px solid grey;"|51:39
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 48}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|49
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 49|Hardware 3D [Input Layout Incredulity]]]
| style="border:1px solid grey;"|April 5, 2020
| style="border:1px solid grey;"|25:10
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 49}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|50
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 50|Hardware 3D [Multi Camera Wireframe]]]
| style="border:1px solid grey;"|April 18, 2020
| style="border:1px solid grey;"|29:10
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 50}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|51
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 51|Hardware 3D [Shadow Mapping Theory]]]
| style="border:1px solid grey;"|May 10, 2020
| style="border:1px solid grey;"|26:40
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 51}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|52
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 52|Hardware 3D [Shadow Mapping Code]]]
| style="border:1px solid grey;"|May 17, 2020
| style="border:1px solid grey;"|37:00
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 52}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|53
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 53|Hardware 3D [Shadow Bias / Self Shadowing]]]
| style="border:1px solid grey;"|May 31, 2020
| style="border:1px solid grey;"|28:50
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 53}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|54
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 54|Hardware 3D [Peter Panning / Shadow PCF]]]
| style="border:1px solid grey;"|June 9, 2020
| style="border:1px solid grey;"|28:29
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 54}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|55
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 55|Hardware 3D [Hardware PCF / Slope-scaling]]]
| style="border:1px solid grey;"|June 15, 2020
| style="border:1px solid grey;"|27:33
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 55}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|56
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 56|Hardware 3D [Slope-scaled Shadow Sandbox]]]
| style="border:1px solid grey;"|June 27, 2020
| style="border:1px solid grey;"|33:14
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 56}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|57
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 57|Hardware 3D [Cube Map Skybox]]]
| style="border:1px solid grey;"|July 6, 2020
| style="border:1px solid grey;"|31:05
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 57}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|58
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 58|Hardware 3D [Cube Map Shadow Mapping]]]
| style="border:1px solid grey;"|August 15, 2020
| style="border:1px solid grey;"|35:36
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 58}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|59
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 59|Hardware 3D [Debugging Shadow Cube]]]
| style="border:1px solid grey;"|Sept 13, 2020
| style="border:1px solid grey;"|38:22
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 59}}
|}

Hardware 3D (C++ DirectX Graphics) Tutorial 58

2020-09-25T05:04:49Z

Chili: Undo revision 3318 by Chili (talk)

Applying the cubemap technique to shadow mapping of a point light to capture an omni-directional shadow map.

== Topics Covered ==
* Cubemap shadowmap bindable
* Camera vector generation etc. in ShadowMappingPass
* Pythagorean distance as depth for shadowmap
* Fixing code to dump cubemap texture-based DepthStencil
* Fixing viewport for shadowmap generation
* Fixing transformation matrix for shadowmap generation
* Fixing projection matrix for shadowmap generation

== Video Timestamp Index ==
* [https://youtu.be/pprGpbdmhSI Tutorial 58]

== Source Code ==
* [https://github.com/planetchili/hw3d 3D GitHub Repo]

== See also ==
* [[Hardware 3D (C++ DirectX Graphics) Tutorial 59|Next in series (Tutorial 59)]]
* [[Hardware 3D Series (C++ DirectX Graphics)]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]

Hardware 3D (C++ DirectX Graphics) Tutorial 59

2020-09-25T05:03:51Z

Chili: Created page with "Diagnosing and fixing the issue with point-to-point distance shadow depth, with a little help from Python. == Topics Covered == * More shader debugging in Visual Studio Graph..."

Diagnosing and fixing the issue with point-to-point distance shadow depth, with a little help from Python.

== Topics Covered ==
* More shader debugging in Visual Studio Graphics Debugger
* Dumping textures to Numpy file and analyzing in Python
* Proper interpolation/calculation of point-to-point distance shadow depth

== Video Timestamp Index ==
* [https://youtu.be/nmtyLdt1Z1M Tutorial 59]

== Source Code ==
* [https://github.com/planetchili/hw3d 3D GitHub Repo]

== See also ==
* [[Hardware 3D (C++ DirectX Graphics) Tutorial 60|Next in series (Tutorial 60)]]
* [[Hardware 3D Series (C++ DirectX Graphics)]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]

Hardware 3D (C++ DirectX Graphics) Tutorial 58

2020-09-25T05:03:23Z

Chili:

Hardware 3D (C++ DirectX Graphics) Tutorial 28

2020-09-25T00:24:36Z

Chili: /* Video Timestamp Index */

In this video we explore the tree structure of the hierarchy of nodes (using ImGui stuff), and we explore how transforms propagate down that tree. We also look into loading model file formats other than .obj (.gtlf), and we upgrade our Assimp dependency to a version that isn't COMPLETELY BROKEN.

== Topics Covered ==
* ImGui <code>TreeNode</code> and <code>TreeNodeEx</code>
* ImGui window columns
* Adjustable window size / graphics resolution

== Notes ==
There is a bug in the Tree widget relating to how the IDs are allocated. It will be addressed in Tutorial 29.

== Video Timestamp Index ==
* [https://youtu.be/K7VqSmCiGiM Tutorial 28]

== Source Code ==
* [https://github.com/planetchili/hw3d 3D GitHub Repo]

== See also ==
* [[Hardware 3D (C++ DirectX Graphics) Tutorial 29|Next in series (Tutorial 29)]]
* [[Hardware 3D Series (C++ DirectX Graphics)]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]

Hardware 3D Series (C++ DirectX Graphics)

2020-09-15T05:20:06Z

Chili:

Hardware 3D (C++ DirectX Graphics) Tutorial 22

2020-08-19T04:53:20Z

Chili:

In this video we add texture mapping to our arsenal of <code>Bindable</code> abilities. It takes two (<code>Binable</code>s) to dance the texturing tango (you need a <code>Texture</code> (view) and a <code>Sampler</code>). We also add some code from previous tutorials for the loading of image files.

== Topics Covered ==
* <code>Surface</code> for loading images via GDI+
* <code>Bindable</code> for creating texture and texture view
* <code>Bindable</code> for creating sampler state
* Different <code>Sampler</code> settings (wrap mode and filter)
* Skinning a cube

== Video Timestamp Index ==
* [https://youtu.be/daKJcSGqrIU Tutorial 22]

== Errata ==
There is a sporadic error that can occur in this codebase. When we created the SkinnedBox, we neglected to add a static Sampler Bindable there. The reason why this only crashes sometimes is, the Sheet does have a Sampler, so as long as a Sheet is drawn before any SkinnedCube, the Sampler will remain bound for the skinned cube draw as well and all will be OK.

== Resources ==
* [https://www.youtube.com/watch?v=X9nLrjUQVQw Project TWIN video on GDI+ image loading for Surface]

== Source Code ==
* [https://github.com/planetchili/hw3d 3D GitHub Repo]

== See also ==
* [[Hardware 3D (C++ DirectX Graphics) Tutorial 23|Next in series (Tutorial 23)]]
* [[Hardware 3D Series (C++ DirectX Graphics)]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]

Hardware 3D (C++ DirectX Graphics) Tutorial 58

2020-08-15T08:31:58Z

Chili: Created page with "Applying the cubemap technique to shadow mapping of a point light to capture an omni-directional shadow map. == Topics Covered == * Cubemap shadowmap bindable * Camera vector..."

Hardware 3D (C++ DirectX Graphics) Tutorial 57

2020-07-05T10:30:24Z

Chili: /* Video Timestamp Index */

Learning about the cube map texture resource and how to use it to implement a skybox.

== Topics Covered ==
* Cube map texture
* 3D vector sampling
* Dealing with skybox depth issues
* Sampling vector generating geometry
* Mapping 2D textures to the cube map "faces"

== Video Timestamp Index ==
* [https://youtu.be/J_s-ID7pc7g Tutorial 57]

== Source Code ==
* [https://github.com/planetchili/hw3d 3D GitHub Repo]

== See also ==
* [[Hardware 3D (C++ DirectX Graphics) Tutorial 58|Next in series (Tutorial 58)]]
* [[Hardware 3D Series (C++ DirectX Graphics)]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]

Hardware 3D Series (C++ DirectX Graphics)

2020-07-05T10:25:54Z

Chili:

Hardware 3D (C++ DirectX Graphics) Tutorial 57

2020-07-05T10:24:52Z

Chili: Created page with "Learning about the cube map texture resource and how to use it to implement a skybox. == Topics Covered == * Cube map texture * 3D vector sampling * Dealing with skybox depth..."

Learning about the cube map texture resource and how to use it to implement a skybox.

== Topics Covered ==
* Cube map texture
* 3D vector sampling
* Dealing with skybox depth issues
* Sampling vector generating geometry
* Mapping 2D textures to the cube map "faces"

== Video Timestamp Index ==
* [https://youtu.be/pZ1_19-0z5g Tutorial 57]

== Source Code ==
* [https://github.com/planetchili/hw3d 3D GitHub Repo]

== See also ==
* [[Hardware 3D (C++ DirectX Graphics) Tutorial 58|Next in series (Tutorial 58)]]
* [[Hardware 3D Series (C++ DirectX Graphics)]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]

Hardware 3D (C++ DirectX Graphics) Tutorial 56

2020-06-27T07:21:38Z

Chili:

Sixth and final part in a mini-series on basic dynamic occlusion shadows with shadow mapping. This video implements slope-scaled depth biasing, makes a shadow effect that is fully runtime-configurable, and discusses some additional techniques.

== Topics Covered ==
* Slope-scaled depth biasing using rasterizer settings
* Fully configurable shadow effect (use this to explore the impact of different technqiues)
* Bilinear filtering effect in different sampling modes
* Trick using loops and branches to dynamically control a compile-time parameter in HLSL
* Rendering backfaces to prevent self-shadowing without needing large biases
* Receiver plane depth biasing

== Video Timestamp Index ==
* [https://youtu.be/pZ1_19-0z5g Tutorial 56]

== Source Code ==
* [https://github.com/planetchili/hw3d 3D GitHub Repo]

== See also ==
* [[Hardware 3D (C++ DirectX Graphics) Tutorial 57|Next in series (Tutorial 57)]]
* [[Hardware 3D Series (C++ DirectX Graphics)]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]

Hardware 3D (C++ DirectX Graphics) Tutorial 56

2020-06-27T07:06:10Z

Chili:

Sixth and final part in a mini-series on basic dynamic occlusion shadows with shadow mapping. This video implements slope-scaled depth biasing, makes a shadow effect that is fully runtime-configurable, and discusses some additional techniques.

== Topics Covered ==
* Slope-scaled depth biasing using rasterizer settings
* Fully configurable shadow effect (use this to explore the impact of different technqiues)
* Bilinear filtering effect in different sampling modes
* Trick using loops and branches to dynamically control a compile-time parameter in HLSL
* Rendering backfaces to prevent self-shadowing without needing large biases
* Receiver plane depth biasing

== Video Timestamp Index ==
* [https://youtu.be/tRsJ-b2 Tutorial 56]

== Source Code ==
* [https://github.com/planetchili/hw3d 3D GitHub Repo]

== See also ==
* [[Hardware 3D (C++ DirectX Graphics) Tutorial 57|Next in series (Tutorial 57)]]
* [[Hardware 3D Series (C++ DirectX Graphics)]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]

Hardware 3D Series (C++ DirectX Graphics)

2020-06-27T07:01:01Z

Chili:

Hardware 3D Series (C++ DirectX Graphics)

2020-06-27T04:49:14Z

Chili:

The Hardware 3D series (HW3D) teaches the Direct3D 11 API and HLSL (High Level Shader Language). This includes basic instruction in the Windows API for the purposes of creating a window and processing input messages. The goal of this seriesis to give the student the skills necessary to create a basic 3D engine in Direct3D in C++ from scratch. This series builds upon the concepts introduced in previous series.

== List of Tutorials ==
{| style="border:1px solid grey;border-collapse:collapse;width=100%;"
|- style="border:1px solid grey;background-color:#DDF;color:black;font-weight:bold;text-align:center;"
| style="width:10%;border:1px solid grey;"|Tutorial Number
| style="width:60%;border:1px solid grey;"|Title
| style="width:16%;border:1px solid grey;"|Release Date
| style="width:14%;border:1px solid grey;"|Runtime
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|0
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 0|Hardware 3D [Introduction]]]
| style="border:1px solid grey;"|December 16, 2018
| style="border:1px solid grey;"|7:48
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 0}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|1
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 1|Hardware 3D [WinMain]]]
| style="border:1px solid grey;"|December 20, 2018
| style="border:1px solid grey;"|10:49
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 1}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|2
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 2|Hardware 3D [Window Creation]]]
| style="border:1px solid grey;"|December 22, 2018
| style="border:1px solid grey;"|18:42
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 2}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|3
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 3|Hardware 3D [Message Loop / WndProc]]]
| style="border:1px solid grey;"|December 27, 2018
| style="border:1px solid grey;"|17:18
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 3}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|4
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 4|Hardware 3D [Windows Messages]]]
| style="border:1px solid grey;"|December 30, 2018
| style="border:1px solid grey;"|13:30
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 4}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|5
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 5|Hardware 3D [WM_CHAR / Mouse]]]
| style="border:1px solid grey;"|January 5, 2019
| style="border:1px solid grey;"|10:28
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 5}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|6
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 6|Hardware 3D [Window Framework]]]
| style="border:1px solid grey;"|January 11, 2019
| style="border:1px solid grey;"|28:14
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 6}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|7
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 7|Hardware 3D [Error Handling / Custom Icons]]]
| style="border:1px solid grey;"|January 18, 2019
| style="border:1px solid grey;"|25:18
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 7}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|8
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 8|Hardware 3D [Keyboard / WM_SYSKEYDOWN]]]
| style="border:1px solid grey;"|January 26, 2019
| style="border:1px solid grey;"|19:05
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 8}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|9
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 9|Hardware 3D [Mouse / Mouse Capture]]]
| style="border:1px solid grey;"|January 31, 2019
| style="border:1px solid grey;"|18:05
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 9}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|10
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 10|Hardware 3D [App class / PeekMessage]]]
| style="border:1px solid grey;"|February 3, 2019
| style="border:1px solid grey;"|11:47
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 10}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|11
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 11|Hardware 3D [COM (Component Object Model)]]]
| style="border:1px solid grey;"|February 8, 2019
| style="border:1px solid grey;"|37:05
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 11}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|12
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 12|Hardware 3D [D3D Architecture / Swap Chain]]]
| style="border:1px solid grey;"|February 16, 2019
| style="border:1px solid grey;"|17:45
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 12}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|13
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 13|Hardware 3D [Device Init / Fill Screen / Present]]]
| style="border:1px solid grey;"|February 22, 2019
| style="border:1px solid grey;"|19:06
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 13}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|14
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 14|Hardware 3D [Debug Layer Diagnostics]]]
| style="border:1px solid grey;"|March 2, 2019
| style="border:1px solid grey;"|17:42
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 14}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|15
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 15|Hardware 3D [ComPtr Smart Pointer]]]
| style="border:1px solid grey;"|March 6, 2019
| style="border:1px solid grey;"|10:50
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 15}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|16
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 16|Hardware 3D [First Triangle]]]
| style="border:1px solid grey;"|March 9, 2019
| style="border:1px solid grey;"|31:43+
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 16}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|17
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 17|Hardware 3D [Pipeline Exploration]]]
| style="border:1px solid grey;"|March 23, 2019
| style="border:1px solid grey;"|24:23
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 17}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|18
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 18|Hardware 3D [Constant Buffers]]]
| style="border:1px solid grey;"|March 30, 2019
| style="border:1px solid grey;"|15:56
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 18}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|19
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 19|Hardware 3D [DirectXMath]]]
| style="border:1px solid grey;"|April 6, 2019
| style="border:1px solid grey;"|18:57
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 19}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|20
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 20|Hardware 3D [3D Cube / Z-Buffer]]]
| style="border:1px solid grey;"|April 13, 2019
| style="border:1px solid grey;"|23:03
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 20}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|21
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 21|Hardware 3D [Bindable / Drawable System]]]
| style="border:1px solid grey;"|April 20, 2019
| style="border:1px solid grey;"|24:32+
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 21}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|22
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 22|Hardware 3D [Texture Mapping]]]
| style="border:1px solid grey;"|May 4, 2019
| style="border:1px solid grey;"|22:48
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 22}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|23
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 23|Hardware 3D [Test GUI (imgui) / Camera]]]
| style="border:1px solid grey;"|May 11, 2019
| style="border:1px solid grey;"|25:20
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 23}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|24
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 24|Hardware 3D [Dynamic Lighting / Graphics Debugger]]]
| style="border:1px solid grey;"|May 18, 2019
| style="border:1px solid grey;"|28:56+
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 24}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|25
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 25|Hardware 3D [Mesh Loading Assimp / Git History Fixing]]]
| style="border:1px solid grey;"|June 8, 2019
| style="border:1px solid grey;"|23:12
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 25}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|26
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 26|Hardware 3D [Dynamic Vertex / Template Metaprogramming Bullshit]]]
| style="border:1px solid grey;"|June 16, 2019
| style="border:1px solid grey;"|43:48
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 26}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|27
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 27|Hardware 3D [Scene Graph]]]
| style="border:1px solid grey;"|June 28, 2019
| style="border:1px solid grey;"|27:50
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 27}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|28
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 28|Hardware 3D [Node Tree / Transform Propagation]]]
| style="border:1px solid grey;"|July 6, 2019
| style="border:1px solid grey;"|29:40
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 28}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|29
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 29|Hardware 3D [Cursor Hide / Cursor Confine]]]
| style="border:1px solid grey;"|July 13, 2019
| style="border:1px solid grey;"|13:33
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 29}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|30
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 30|Hardware 3D [Raw Mouse Input]]]
| style="border:1px solid grey;"|July 21, 2019
| style="border:1px solid grey;"|13:38
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 30}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|31
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 31|Hardware 3D [First Person Camera]]]
| style="border:1px solid grey;"|July 27, 2019
| style="border:1px solid grey;"|17:05
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 31}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|32
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 32|Hardware 3D [Material Loading]]]
| style="border:1px solid grey;"|August 4, 2019
| style="border:1px solid grey;"|26:50
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 32}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|33
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 33|Hardware 3D [Bindable Codex]]]
| style="border:1px solid grey;"|August 12, 2019
| style="border:1px solid grey;"|32:53
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 33}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|34
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 34|Hardware 3D [Normal Mapping Part 1]]]
| style="border:1px solid grey;"|August 27, 2019
| style="border:1px solid grey;"|26:40+
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 34}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|35
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 35|Hardware 3D [Extreme Goblin Energy]]]
| style="border:1px solid grey;"|September 21, 2019
| style="border:1px solid grey;"|33:45
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 35}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|36
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 36|Hardware 3D [Renormalization]]]
| style="border:1px solid grey;"|September 29, 2019
| style="border:1px solid grey;"|34:45
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 36}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|37
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 37|Hardware 3D [Sponza Test Map]]]
| style="border:1px solid grey;"|October 12, 2019
| style="border:1px solid grey;"|32:26
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 37}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|38
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 38|Hardware 3D [Mipmapping / Anisotropic Filtering]]]
| style="border:1px solid grey;"|October 26, 2019
| style="border:1px solid grey;"|22:58
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 38}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|39
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 39|Hardware 3D [Alpha Blending / Transparency]]]
| style="border:1px solid grey;"|November 17, 2019
| style="border:1px solid grey;"|37:06
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 39}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|40
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 40|Hardware 3D [DirectXTex / JSON Batch]]]
| style="border:1px solid grey;"|December 1, 2019
| style="border:1px solid grey;"|25:06
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 40}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|41
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 41|Hardware 3D [Dynamic Constant Buffer]]]
| style="border:1px solid grey;"|December 13, 2019
| style="border:1px solid grey;"|1:18:02
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 41}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|42
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 42|Hardware 3D [Stencil Buffer Outline Effect]]]
| style="border:1px solid grey;"|December 28, 2019
| style="border:1px solid grey;"|23:05
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 42}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|43
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 43|Hardware 3D [Render Queue System]]]
| style="border:1px solid grey;"|January 18, 2020
| style="border:1px solid grey;"|36:10
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 43}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|44
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 44|Hardware 3D ["Visitor" Probe / Static Meta "Bridge"]]]
| style="border:1px solid grey;"|February 1, 2020
| style="border:1px solid grey;"|21:43
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 44}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|45
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 45|Hardware 3D [Dynamic Technique Composition]]]
| style="border:1px solid grey;"|February 16, 2020
| style="border:1px solid grey;"|30:00
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 45}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|46
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 46|Hardware 3D [Fullscreen Filters (Blur)]]]
| style="border:1px solid grey;"|February 29, 2020
| style="border:1px solid grey;"|31:18
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 46}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|47
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 47|Hardware 3D [Separated Gaussian Filter]]]
| style="border:1px solid grey;"|March 15, 2020
| style="border:1px solid grey;"|24:10+
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 47}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|48
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 48|Hardware 3D [Render Graph]]]
| style="border:1px solid grey;"|March 28, 2020
| style="border:1px solid grey;"|51:39
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 48}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|49
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 49|Hardware 3D [Input Layout Incredulity]]]
| style="border:1px solid grey;"|April 5, 2020
| style="border:1px solid grey;"|25:10
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 49}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|50
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 50|Hardware 3D [Multi Camera Wireframe]]]
| style="border:1px solid grey;"|April 18, 2020
| style="border:1px solid grey;"|29:10
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 50}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|51
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 51|Hardware 3D [Shadow Mapping Theory]]]
| style="border:1px solid grey;"|May 10, 2020
| style="border:1px solid grey;"|26:40
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 51}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|52
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 52|Hardware 3D [Shadow Mapping Code]]]
| style="border:1px solid grey;"|May 17, 2020
| style="border:1px solid grey;"|37:00
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 52}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|53
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 53|Hardware 3D [Shadow Bias / Self Shadowing]]]
| style="border:1px solid grey;"|May 31, 2020
| style="border:1px solid grey;"|28:50
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 53}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|54
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 54|Hardware 3D [Peter Panning / Shadow PCF]]]
| style="border:1px solid grey;"|June 9, 2020
| style="border:1px solid grey;"|28:29
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 54}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|55
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 55|Hardware 3D [Hardware PCF / Slope-scaling]]]
| style="border:1px solid grey;"|June 15, 2020
| style="border:1px solid grey;"|27:33
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 55}}
|- style="border:1px solid grey;background-color:#667;color:#c1c1c1;text-align:center;"
| style="border:1px solid grey;"|56
| style="border:1px solid grey;text-align:left;"|[[Hardware 3D (C++ DirectX Graphics) Tutorial 56|Hardware 3D [Slope-scaled depth biasing sandbox]]]
| style="border:1px solid grey;"|June 27, 2020
| style="border:1px solid grey;"|33:14
|- style="background-color:#333;color:#c1c1c1;"
| style="border:1px solid grey;padding:8px;" colspan="4" | {{#lsth:Hardware 3D (C++ DirectX Graphics) Tutorial 56}}
|}

Hardware 3D (C++ DirectX Graphics) Tutorial 56

2020-06-27T04:47:41Z

Chili: Created page with "Sixth and final part in a mini-series on basic dynamic occlusion shadows with shadow mapping. This video implements slope-scaled depth biasing, makes a shadow effect that is f..."

Sixth and final part in a mini-series on basic dynamic occlusion shadows with shadow mapping. This video implements slope-scaled depth biasing, makes a shadow effect that is fully runtime-configurable, and discusses some additional techniques.

== Topics Covered ==
* Slope-scaled depth biasing using rasterizer settings
* Fully configurable shadow effect (use this to explore the impact of different technqiues)
* Trick using loops and branches to dynamically control a compile-time parameter in HLSL
* Rendering backfaces to prevent self-shadowing without needing large biases
* Receiver plane depth biasing

== Video Timestamp Index ==
* [https://youtu.be/tRsJ-b2 Tutorial 56]

== Source Code ==
* [https://github.com/planetchili/hw3d 3D GitHub Repo]

== See also ==
* [[Hardware 3D (C++ DirectX Graphics) Tutorial 57|Next in series (Tutorial 57)]]
* [[Hardware 3D Series (C++ DirectX Graphics)]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]

Hardware 3D Series (C++ DirectX Graphics)

2020-06-27T04:24:20Z

Chili:

Hardware 3D (C++ DirectX Graphics) Tutorial 55

2020-06-27T04:20:32Z

Chili: Created page with "Fifth part in a mini-series on basic dynamic occlusion shadows with shadow mapping. This video implements hardware PCF comparison, discusses the concept of soft shadows, and i..."

Fifth part in a mini-series on basic dynamic occlusion shadows with shadow mapping. This video implements hardware PCF comparison, discusses the concept of soft shadows, and introduces the theory behind an adaptive biasing technique called "slope-scaled depth biasing".

== Topics Covered ==
* Sampler comparison mode
* Comparison sampling in HLSL
* Dynamic HLSL loops vs. statically unrolled ones
* Soft shadows and area lights
* Slope-scaled depth biasing

== Video Timestamp Index ==
* [https://youtu.be/tRsJ-b2ngIQ Tutorial 55]

== Source Code ==
* [https://github.com/planetchili/hw3d 3D GitHub Repo]

== See also ==
* [[Hardware 3D (C++ DirectX Graphics) Tutorial 56|Next in series (Tutorial 56)]]
* [[Hardware 3D Series (C++ DirectX Graphics)]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]

Intermediate C++ Game Programming Tutorial 16

2020-06-27T04:10:24Z

Chili: /* Errata */

In the video we take a look at a couple of bangers from <code><algorithm></code>, and we learn what lambda functions are and how to use them.

== Topics Covered ==
* Algorithms <code>std::sort</code> and <code>std::remove_if</code>
* Concepts (as in, type concepts like Comparable)
* <code><functional></code> functors as predicates
* Lambda functions

== <span style="color:red">Errata</span> ==
In the video Chili states that std::remove does not preserve the relative order of elements in the container, but this is fake news! Relative order is preserved: [https://en.cppreference.com/w/cpp/algorithm/remove]

In the homework solution there is a part where Chili uses an iterator into a <code>stringstream</code> [https://youtu.be/_1-iES-Eytc?t=626]. This code no longer works due to changes (improvements) to the Visual Studio compiler. Basically, you cannot pass a temporary stream into the iterator constructor. See this: [https://stackoverflow.com/questions/23714445/passing-temporary-istringstream-object-to-istream-iteratorstring]

== Video Timestamp Index ==
[https://youtu.be/3J1Pz30IE4Q Tutorial 16]
<div class="mw-collapsible mw-collapsed"><br />
* Generic Algorithms: how Templates and Iterators make Algorithms independent of Data Types and Containers [https://youtu.be/3J1Pz30IE4Q?t=17s 0:17]
* The <code>std::sort</code> algorithm and its requirements [https://youtu.be/3J1Pz30IE4Q?t=43s 0:43]
* Sorting a (forward) list <code>std::list</code>, using its member function <code>std::list::sort()</code> [https://youtu.be/3J1Pz30IE4Q?t=2m16s 2:16]
* Introducing Concepts / named requirements of types (e.g., the <code>Compare</code> requirement of <code>std::sort</code>) [https://youtu.be/3J1Pz30IE4Q?t=2m54s 2:54]
* Modyfing sorting order by passing a comparison function object (functor) as a predicate, like so:<br /><code>std::sort(vec.begin(),vec.end(),std::greater<int>{});</code> [https://youtu.be/3J1Pz30IE4Q?t=3m17s 3:17]<br />Note: vec is a std::vector of integers
* Sort custom types, example code for sorting a custom class object by creating a functor, called like so: <br /><code>std::sort(vecObj.begin(),vecObj.end(),Obj::YLess{});</code> [https://youtu.be/3J1Pz30IE4Q?t=4m07s 4:07]
* Removing items from a container, <code>std::remove</code> and <code>std::remove_if</code> [https://youtu.be/3J1Pz30IE4Q?t=6m11s 6:11]
<div class="mw-collapsible-content">
** Create a functor as a unary predicate for the <code>std::remove</code> function to remove elements using a threshold variable [https://youtu.be/3J1Pz30IE4Q?t=8m28s 8:28]
** Use container member function <code>erase()</code> to correct the endpoint of the container after the remove operation [https://youtu.be/3J1Pz30IE4Q?t=9m51s 9:51]
</div>
* Introducing Lambda functions to replace custom functors [https://youtu.be/3J1Pz30IE4Q?t=11m51s 11:51]
* Using the Lambda capture to bring in variables into the Lambda function [https://youtu.be/3J1Pz30IE4Q?t=13m34s 13:34]
<div class="mw-collapsible-content">
** Capture syntax explained: <code>[var]</code>,<code>[&var]</code>,<code>[=]</code>,<code>[&]</code>,<code>[newvar=var+10]</code>,<code>[this]</code>, capture multiple variables, mix&match capture modes
** Stateful Lambdas; changing captured lambda variables using the <code>mutable</code> flag [https://youtu.be/3J1Pz30IE4Q?t=15m59s 15:59]
</div>
* Some anxiety-reducing consolation by Chili [https://youtu.be/3J1Pz30IE4Q?t=16m40s 16:40]
* Syntax for a callable Lambda function [https://youtu.be/3J1Pz30IE4Q?t=17m03s 17:03]
<div class="mw-collapsible-content">
** Make it callable once: <code>[...](...){...}(vec.front());</code>, functor is destroyed immediately
** Keep the functor using <code>auto mylamb = [...](...){...};</code>, which can be called by <code>bool result = mylamb(vec.front());</code>, or <code>std::remove_if(...,...,mylamb);</code>
</div>
* The power of C++ is in its flexibility. Example code for converting a string to lowercase:<br /><code>std::transform(str.begin(),str.end(),str.begin(),::tolower);</code>[https://youtu.be/3J1Pz30IE4Q?t=17m49s 17:49]
* Homework assignment [https://youtu.be/3J1Pz30IE4Q?t=18m39s 18:39]
* Introducing the Algorithm [[STD Gems]] series that takes a deep dive into its functionality [https://youtu.be/3J1Pz30IE4Q?t=19m20s 19:20]
</div>

== Homework ==
Solve the problems in Source.cpp attached below using the <algorithm> library and other parts of the standard library as extensively as possible. As a bonus problem, implement the sprite drawing effect shown at the end of the video using a lambda function.

* [http://www.planetchili.net/downloads/I16-HW.zip Source.cpp (homework file)]
* [https://github.com/planetchili/sprite Sprite Repo (for bonus problem)]

The homework solution video can be found [https://youtu.be/_1-iES-Eytc here]

== Related Series ==
For an in-depth look into the <algorithm> library and beyond, check out [[STD Gems]].

== Links ==
[http://en.cppreference.com/w/cpp/algorithm Algorithms Library]<br />

== See also ==
* [[Intermediate C++ Game Programming Tutorial 17|Next in series (Tutorial 17)]]
* [[Intermediate C++ Game Programming Series]]

Hardware 3D Series (C++ DirectX Graphics)

2020-06-08T17:16:08Z

Chili:

Hardware 3D (C++ DirectX Graphics) Tutorial 54

2020-06-08T17:13:19Z

Chili: /* Video Timestamp Index */

Fourth part in a mini-series on basic dynamic occlusion shadows with shadow mapping. This video covers the concept of "peter panning" and self-shadowing due to sampling error in the depth map.

== Topics Covered ==
* The mechanics of peter panning and how to fix it
* Nonlinear depth woes
* PCF filtering to fix pixelated (aliased) shadow boundaries
* Self shadowing mediated by depth sampling frequency (resolution) and depth slope of the receiving surface

== Video Timestamp Index ==
* [https://youtu.be/EPHjOUQ4rC8 Tutorial 54]

== Source Code ==
* [https://github.com/planetchili/hw3d 3D GitHub Repo]

== See also ==
* [[Hardware 3D (C++ DirectX Graphics) Tutorial 55|Next in series (Tutorial 55)]]
* [[Hardware 3D Series (C++ DirectX Graphics)]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]

Hardware 3D (C++ DirectX Graphics) Tutorial 54

2020-06-08T16:38:34Z

Chili:

Fourth part in a mini-series on basic dynamic occlusion shadows with shadow mapping. This video covers the concept of "peter panning" and self-shadowing due to sampling error in the depth map.

== Topics Covered ==
* The mechanics of peter panning and how to fix it
* Nonlinear depth woes
* PCF filtering to fix pixelated (aliased) shadow boundaries
* Self shadowing mediated by depth sampling frequency (resolution) and depth slope of the receiving surface

== Video Timestamp Index ==
* [https://youtu.be/CIGNP71FiG0 Tutorial 54]

== Source Code ==
* [https://github.com/planetchili/hw3d 3D GitHub Repo]

== See also ==
* [[Hardware 3D (C++ DirectX Graphics) Tutorial 55|Next in series (Tutorial 55)]]
* [[Hardware 3D Series (C++ DirectX Graphics)]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]

Hardware 3D (C++ DirectX Graphics) Tutorial 54

2020-06-08T16:10:26Z

Chili: Created page with "Fourth part in a mini-series on basic dynamic occlusion shadows with shadow mapping. This video covers the concept of "peter panning" and self-shadowing due to sampling error..."

Fourth part in a mini-series on basic dynamic occlusion shadows with shadow mapping. This video covers the concept of "peter panning" and self-shadowing due to sampling error in the depth map.

== Topics Covered ==
* The mechanics of peter panning and how to fix it
* Nonlinear depth woes
* Self shadowing mediated by depth sampling frequency and depth slope of the receiving surface

== Video Timestamp Index ==
* [https://youtu.be/CIGNP71FiG0 Tutorial 54]

== Source Code ==
* [https://github.com/planetchili/hw3d 3D GitHub Repo]

== See also ==
* [[Hardware 3D (C++ DirectX Graphics) Tutorial 55|Next in series (Tutorial 55)]]
* [[Hardware 3D Series (C++ DirectX Graphics)]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]

Hardware 3D (C++ DirectX Graphics) Tutorial 53

2020-06-08T15:26:06Z

Chili: Created page with "Third part in a mini-series on basic dynamic occlusion shadows with shadow mapping. This video covers goes into detail about the concept of self-shadowing (shadow acne) and sh..."

Third part in a mini-series on basic dynamic occlusion shadows with shadow mapping. This video covers goes into detail about the concept of self-shadowing (shadow acne) and shadow biasing. We get our shadow mapping shader code working for all of the models.

== Topics Covered ==
* Self-shadowing (shadow acne)
* Depth biasing
* Perspective divide must be done in the pixel shader
* Dealing with exceptions and exception specifiers during debugging
* Resources that are bound at different times as both shader input and output

== Video Timestamp Index ==
* [https://youtu.be/Xc2G_tvXmnQ Tutorial 53]

== Source Code ==
* [https://github.com/planetchili/hw3d 3D GitHub Repo]

== See also ==
* [[Hardware 3D (C++ DirectX Graphics) Tutorial 54|Next in series (Tutorial 54)]]
* [[Hardware 3D Series (C++ DirectX Graphics)]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]

Hardware 3D (C++ DirectX Graphics) Tutorial 52

2020-05-17T14:07:31Z

Chili: /* Video Timestamp Index */

Second part in a mini-series on basic dynamic occlusion shadows with shadow mapping. This video covers the basic implementation of the shadow mapping technique and its support code.

== Topics Covered ==
* Camera attached to point light
* Depth stencil usages <code>DepthStencil</code> and <code>ShadowDepth</code>
* Saving depth to image file
* Linearlizing depth for visualization
* Technique channel bit mask
* Camera binding and light space camera transform
* Shadow map sampler
* Shadow mapping in vertex and pixel shaders
* Shadow map generation <code>Technique</code>

== Video Timestamp Index ==
* [https://youtu.be/CIGNP71FiG0 Tutorial 52]

== Source Code ==
* [https://github.com/planetchili/hw3d 3D GitHub Repo]

== See also ==
* [[Hardware 3D (C++ DirectX Graphics) Tutorial 53|Next in series (Tutorial 53)]]
* [[Hardware 3D Series (C++ DirectX Graphics)]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]

Hardware 3D Series (C++ DirectX Graphics)

2020-05-17T13:01:26Z

Chili:

Hardware 3D (C++ DirectX Graphics) Tutorial 52

2020-05-17T13:00:11Z

Chili: Created page with "Second part in a mini-series on basic dynamic occlusion shadows with shadow mapping. This video covers the basic implementation of the shadow mapping technique and its support..."

Second part in a mini-series on basic dynamic occlusion shadows with shadow mapping. This video covers the basic implementation of the shadow mapping technique and its support code.

== Topics Covered ==
* Camera attached to point light
* Depth stencil usages <code>DepthStencil</code> and <code>ShadowDepth</code>
* Saving depth to image file
* Linearlizing depth for visualization
* Technique channel bit mask
* Camera binding and light space camera transform
* Shadow map sampler
* Shadow mapping in vertex and pixel shaders
* Shadow map generation <code>Technique</code>

== Video Timestamp Index ==
* [https://youtu.be/St2uayQ Tutorial 52]

== Source Code ==
* [https://github.com/planetchili/hw3d 3D GitHub Repo]

== See also ==
* [[Hardware 3D (C++ DirectX Graphics) Tutorial 53|Next in series (Tutorial 53)]]
* [[Hardware 3D Series (C++ DirectX Graphics)]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]

Hardware 3D (C++ DirectX Graphics) Tutorial 51

2020-05-10T08:17:48Z

Chili: /* Video Timestamp Index */

First part in a mini-series on basic dynamic occlusion shadows with shadow mapping. This video covers the fundamental theory behind the shadow mapping technique.

== Topics Covered ==
* Occlusion shadows
* Shadow map depth lookup and comparison
* Transforming to light space from the render shader
* Omnidirectional shadow mapping and frustum clipping
* Render submission channels

== Video Timestamp Index ==
* [https://youtu.be/St2uayQ5KQo Tutorial 51]

== Source Code ==
* [https://github.com/planetchili/hw3d 3D GitHub Repo]

== See also ==
* [[Hardware 3D (C++ DirectX Graphics) Tutorial 52|Next in series (Tutorial 52)]]
* [[Hardware 3D Series (C++ DirectX Graphics)]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]

Hardware 3D Series (C++ DirectX Graphics)

2020-05-10T07:40:25Z

Chili:

Hardware 3D (C++ DirectX Graphics) Tutorial 51

2020-05-10T07:38:01Z

Chili: /* See also */

First part in a mini-series on basic dynamic occlusion shadows with shadow mapping. This video covers the fundamental theory behind the shadow mapping technique.

== Topics Covered ==
* Occlusion shadows
* Shadow map depth lookup and comparison
* Transforming to light space from the render shader
* Omnidirectional shadow mapping and frustum clipping
* Render submission channels

== Video Timestamp Index ==
* [https://youtu.be/5SAqIOTi Tutorial 51]

== Source Code ==
* [https://github.com/planetchili/hw3d 3D GitHub Repo]

== See also ==
* [[Hardware 3D (C++ DirectX Graphics) Tutorial 52|Next in series (Tutorial 52)]]
* [[Hardware 3D Series (C++ DirectX Graphics)]]
* [https://www.patreon.com/planetchili Planet Chili Patreon]