## [Sticky] ------- (OLD) Lessons Indexed

The Partridge Family were neither partridges nor a family. Discuss.
LuX
Posts: 1492
Joined: April 22nd, 2012, 12:33 pm
Location: Finland

### [Sticky] ------- (OLD) Lessons Indexed

INDEX

Note: Original version made by user "Conflictus", thanks and credits to this fella!
Send improvements / mistakes / corrections to me, as a PM
ʕ •ᴥ•ʔ

LuX
Posts: 1492
Joined: April 22nd, 2012, 12:33 pm
Location: Finland

### Re: [Sticky] ------- Lessons Indexed

Beginner lessons:

Lesson 1: Video - Material || ( lo-spec ) Material
General Introduction
Requirements for following along with the tutorials

Homework: Mess around with PutPixel() and figure out what each number represents

Lesson 2: Video
Review of homework from lesson 1
General explanation of functions and objects
Introduction to Intellisense, Auto-Completion and Tooltips

Homework: Translate the coordinates of the PutPixel() composition to the lower right portion of the screen

Lesson 3: Video
Review of homework from lesson 2
The int data type
Arithmetic operators // + -

Homework: Offset the Y-Coordinate values with a variable

Lesson 4: Video
Review of homework from lesson 3
Whitespace and code format
if statements
Keyboard input (up, down, left, right, space and enter)
The bool data type

Homework: Add keyboard input for each direction and change the color to red if space is pressed

Lesson 5: Video
Review of homework from lesson 4
Scope of variables
Introduction to constructors // the initializer list
Find and replace // Ctrl + F

Homework: Change the speed that the reticle moves around the screen
Space = 1 pixel per frame
No key pressed = 3 pixels per frame
Enter = 8 pixels per frame

Lesson 6: Video
Review of homework from lesson 5
Collision with the window borders
Comparison operators // < >

Homework: Change the color of the reticle from white to teal when within a rectangular area at the center of the screen

Lesson 7: Video
Review of homework from lesson 6
Nested if statements
Logical operators // &&
Bounding box collision
The equivalence // == and assignment operator // =
Review of all operators learned so far // = + - < > == &&

Homework: Make a 2nd reticle that moves by itself in a rectangular pattern around the screen

Lesson 8: Video - Material
Review of homework from lesson 7
Introduction to the debugger
Declaring and defining a function to draw reticles
The Pooface game, which uses everything learned thus far
else statements
The not operator // !

Homework: 'like' Chili's youtube tutorial videos

Lesson 9: Video
Change the default window location in windows.cpp
while loops
Increment operator // ++
Draw a line looping PutPixel() calls

Homework: Draw a square and move it around with arrow keys and re-size it if holding down space. Additionally, if inclined to do so you can add a color pattern to the square.
Homework solution: http://www.planetchili.net/forum/viewto ... ?f=3&t=943

Lesson 10: Video
Review of homework from lesson 9
for loops
Linear equations
More fun with the debugger
The float data type
Explicit type conversion // ( )
Absolute value function ( abs() ) // <stdlib.h>
Swapping variable values
DrawLine() for drawing lines

Lesson 11: Video
Pythagorean theorem
Square root function ( sqrt() ) // <math.h>
DrawCircle() for drawing circles

Lesson 12: Video - Material
Enumerations ( enum )
switch-case statements
return values from a function
Constant variables ( const )
Read a single key press when a key is held down
Generate random numbers ( rand() ) and seed them ( srand() ) // <stdlib.h> with time ( time() ) // <time.h>
do-while loops
Modulus operator // %
Create a Tic-Tac-Toe game using what we've learned

Homework: Improve the AI and have the computer move the cursor

Lesson 13: Video - Material
Arrays
Memory allocation
Pre-processor directives // #define
Implicit type conversion
Dividing logic and drawing into separate functions
Updating the framework to improve PutPixel()
Memory mapped I/O
Updating the Pooface game to include things learned recently

Homework: Change the objective of the Pooface game to collecting yellow circles while avoiding poo. Each yellow circle collected generates more poo until the maximum is reached. The poo should all move at variable speeds and change direction randomly.

Lesson 14: Video
Review of homework from lesson 13
DrawDisc() to create filled in circles
Circle collision

"Mädchen auf der Fensterbank,
putzt die Scheibe blitzeblank.
Alle Leute blieben stehn,
ihr Scheuerbürstel war zu sehn!"

Lesson 15: Video
Structures ( struct )
Returning multiple values
MidPoint() to draw a circle between the face and goal
Global functions
Forward declaration

( Appetizer: "Binky Pointer Fun Video" )
Lesson 16: Video - Material
Pointers
The stack
Scope of functions
Dereference operator // *
Mouse control

Lesson 17: Video
Creating console applications
The char data type
Initialize an array with numbers, character literals and string literals
Pointer arithmetic
Escape characters
Introduction to Const correctness
Storage capacity of data types
getchar() and putchar() to read and write numbers to the screen // <stdio.h>
PutString() to output a string of characters

Homework: Simple - Create a function with the signature void GetString( char* buf, int maxLen)
Normal - Input a string from the keyboard and reverse it
Hard - Prompt the user to input a number of dice and output the sum of the rolls.
Create int StrToInt( const char*) and void IntToStr( int num, char* buf, buflen) to handle the conversion.

Lesson 18: Video
Review of homework from lesson 17
Text input and output with printf() and scanf() // <stdio.h>
Format output to a specific decimal place

Lesson 19: Video - Material
Writing to files with fprintf() and fwrite() // <stdio.h>
Reading and writing text files and raw binary data
The sizeof() operator
Destructors // saving the score when the game closes
Moving the file pointer with fseek() // <stdio.h>
Working with Pooface EX+alpha to implement a save & load function and keep track of the top 10 highscores

Lesson 20: Video - Material
Create the .h and .cpp files associated with loading and drawing 24-bit bitmaps
Ensure headers are only included once with #pragma once
The short data type
Namespace collision
Use assertions ( assert() ) to aid debugging // <assert.h>
Macros // D3DCOLOR_XRGB()
Create an alternate version of PutPixel() to accept D3DCOLOR values
Insert padding bytes into the images to display them properly
Change the background color from black to white in D3DGraphics.cpp
Combine dereferencing and member access with -> // sprite->height is the same as (*sprite).height
Drawing images with and without a color key for transparency
Animating sprites
Format the filename to include numbers with sprintf() // <stdio.h>
Create several instances of a sprite that start in random locations and on separate frames

"It's WalkinDude, not WalkingDude" -Hermione

Lesson 21: Video - Material
Rendering fixed width fonts
DrawChar() and DrawString() to output text from the bitmap
Benchmarking with timer.GetTimeMilli(), timer.StartWatch() and timer.StopWatch() // <timer.h>

Lesson 22: Video
Stack (static) allocation vs Heap (dynamic) allocation
Allocate memory with malloc() and free it with free() // <stdlib.h>

Homework: Convert the font functions to use dynamic memory allocation
ʕ •ᴥ•ʔ

LuX
Posts: 1492
Joined: April 22nd, 2012, 12:33 pm
Location: Finland

### Re: [Sticky] ------- Lessons Indexed

Intermediate lessons:

Lesson 1: Video - Material
class vs object
private and public access specifiers
The self-referencing this pointer
The new and delete operators // new calls the constructor unlike malloc()
Recursion
Use fgetc() to set the EOF indicator for feof() when checking for end of file // <stdio.h>
String manipulation ( strcpy() and strlen() ) // <string.h>
Use the scope resolution operator to access a global definition // ::

Lesson 2: Video - Material
Bit twiddling
Binary and hexidecimal numbers
Bitwise operators // & | ~
Bit shift operators // << >>
Load libraries from within source code with #pragma comment( lib, "name_of_library" )
Load and draw png files with the GDI+ library
Alpha blending

Lesson 3: Video
Function pointers
References
More const correctness
Global and static variables
The qsort() function // <stdlib.h>
Use pre-existing variables from another translation unit with extern

Homework: Create an array of structs that contain a student name and number then sort with qsort()

Lesson 4: Video
Direct3D API
Review of hardware history
Page flipping (between the front and back buffer) and chain flipping
Scene tearing
Pointers to pointers

Lesson 5: Video
Windows
The keyboard and mouse objects

Lesson 6: Video - Material
Move the benchmarking into a class
Copy blocks of memory with memcpy() and fill blocks of memory with a value using memset()
Improve alpha blending

Lesson 7: Video
Introduction to the Standard Template Library
Namespaces
Events
Queue STL Container // <queue>
Improved keyboard input (all keys)

Lesson 8: Video - Material
Create a class to draw surfaces to the back buffer
STL string class ( string() and wstring() ) // <string>
Get the larger of two values with max() and smaller of two values with min()

Lesson 9: Video
Change surface to accept a color key on a per surface basis
Introduction to inheritance
protected access specifier
String streams // <sstream>
Format strings with setw() and setfill() // <iomanip>

Lesson 10: Video - Material
Polymorphism ( virtual functions )
More inheritance
Introduction to finite-state machines
Tiles

Lesson 11: Video - Material
( After finally getting a working one up... )
State machines

Lesson 12: Video - Material
Tiles, their states 'n' tilemapping

Lesson 13: Video
Sprite draw sequencing; gotta catch ém all!

Lesson 14: Video
Modding the keyboard ( Key up/down )
Beginning character movement

Lesson 15: Video
Further character movement ( movement to the right )

Homework: Implement movement to the left

Lesson 16: Video
Movement to the left and bug fixes

Lesson 17: Video
Jumping
Find out what "exccellery" means

Lesson 18: Video
Refine jumping
Movement acceleration

Lesson 19: Video
Beginning collision:
Character bounding box

Lesson 20: Video
Collision tutorial

Lesson 21: Video
Scrolling map
Camera / Viewport design pattern
ʕ •ᴥ•ʔ

LuX
Posts: 1492
Joined: April 22nd, 2012, 12:33 pm
Location: Finland

### Re: [Sticky] ------- Lessons Indexed

Lesson 1: Video - Material
Setup & basics of vectors (math)
Templates

Lesson 2: Video - Material 1/2, Material 2/2
Previous Lesson 1 framework fixed.
2D geometry, Vertices,...
Initializer list

Lesson 3: Video
Angles, Cosine, Sine...
Unit circle
Rotation of vertices

Lesson 4: Video - Material
Line clipping
Lambda Functions
Mouse scrollwheel

It looks like a huge...

Lesson 5: Video
Matrices

Lesson 6: Video
Camera

Lesson 7: Video: 1:28:30
Rotation

Lesson 8: Video
Collision

Lesson 9: Video
Triangles

Lesson 10: Video
More triangles, vectors,...
ʕ •ᴥ•ʔ

albinopapa
Posts: 4370
Joined: February 28th, 2013, 3:23 am
Location: Oklahoma, United States

### Re: [Sticky] ------- Lessons Indexed

SSE Lesson 1: Video: 49m:51sec
Discusses memory alignment and _mm_store_si128.
How to debug and view Assembly using __declspec(noinline)
Non-SSE optimizations increasing the pointer instead of using indices.

Covers fading to black, using alpha blending.
_mm_unpackhi_epi8, _mm_unpacklo_epi8
_mm_mullo_epi16
_mm_srli_epi16
_mm_packus_epi16
More disassemble showing how compiler converts divide by 256 to shift right by 8.
Packed arithmetic on integers using masks.

SSE Lesson 3:Shuffle/Instruction Pipeline: 1hr:12min:19sec

More blending, this time between an image and a constant color, tinting; two images, multi-texture blending; and two images, with one image having an alpha channel. Introduces some shuffle instructions. More "tom-foolery" with 16 bit multiplication.

Introduces AVX which have most of the same instructions as SSE2, but handles 256 bits at a time instead of 128 bits.

Briefly talks about __cpuid, an instrinsic used to check for CPU support of features like SSE, SSE2, SSE3, SSSE3, etc.

Discusses latency and throughput: latency is how many CPU cycles an instruction takes to return the result of the operation, while throughput is how many cycles before calling the same instruction again.

Instructions covered:
SSE2
_mm_shufflehi_epi16
_mm_shufflelo_epi16
_mm_mulhi_epi16
_mm_set1_epi16
_mm_setzero_epi16

SSSE3
_mm_shuffle_epi8
If you think paging some data from disk into RAM is slow, try paging it into a simian cerebrum over a pair of optical nerves. - gameprogrammingpatterns.com