You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Copy file name to clipboardExpand all lines: docs/1-introduction/1-3-basics/1-3-3-setting-up-3d-rendering.md
+105-6Lines changed: 105 additions & 6 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -1,8 +1,19 @@
1
1
# Setting up 3D Rendering
2
2
3
+
Now that we know how to work with simple predefined 2D geometry, it's time to take the next step.
4
+
5
+
Here we're dive into the 3rd dimension, but before we do that, we need to explain some things we're going to need in order to properly display a 3D object.
6
+
7
+
In this chapter we'll talk about the following items:
8
+
9
+
- Math ( The matrix compositions we need to get from 3D to our screen (2D) )
10
+
- Constant Buffers
11
+
3
12
Even though the API is called "Direct 3D 11" weirdly enough we can't just simply render a bunch of vertices and have it show up as we expect it to look.
4
13
Because our screen is 2D, we need to be able to "transform" our 3D model into a 2D space.
5
14
15
+
## The Math
16
+
6
17
For this we'll need to take a light dive into "Matrix Math", whilst understanding the math behind it all can be really helpful (especially once you start doing more advanced stuff), We'll use a library for all of this and only stick to top-level concepts as not to make this tutorial a math-lesson.
7
18
8
19
The "Transformation" we're concerned with is composed out of a set of multiple matrices:
@@ -33,6 +44,27 @@ Multiplying these two matrices together results in our "ViewProjection matrix" o
33
44
Now that we have our Model matrix and ViewProjection we can make our final matrix, the "world matrix" which we get by multiplying them together: `WorldMatrix = ModelMatrix * ViewProjection`
34
45
This matrix is what we transform every vertex with in order to get our 3D object on our 2D screen.
35
46
47
+
The code to do all of this looks like this:
48
+
49
+
Our camera will be defined by the view and projection matrix:
Because all these main matrix multiplications happen infrequently enough, we "can" do this on the CPU, we only have to recalculate the matrices of 3D objects when/if they move/scale/rotate which for most level geometry is almost never. However...
37
69
38
70
The only exception is the camera, which tends to move almost every frame, however we tend to only have 1 of them (or an insignificant amount in other cases).
@@ -41,17 +73,84 @@ The keen readers might realize that because of the the fact that we recalculate
41
73
What we cannot do however (or well, not with high-poly objects) is transform every vertex on the CPU with the world matrix, luckily GPU's are practically built for this and thus are very good at it.
42
74
But that means we need a way to get the matrix we need over there somehow.
43
75
76
+
## Constant Buffers
77
+
44
78
In D3D11 we have a thing called "Constant Buffers", this is special buffer to contain values that the GPU can expect not to change during a draw call, this means the values are "constant" or "uniform" for the entire shader invocation.
45
79
This is a great place to put our matrix.
46
80
47
-
!!! error
48
-
explain and create Constant Buffers
81
+
In `CreateConstantBuffers()` we create our buffer pretty much the same as we did our vertex buffer back in Hello Triangle, except now in the BindFlags, we specify D3D11_BIND_FLAG::BIND_CONSTANT_BUFFER
Note that we create two buffers, this is because it is best practice to update constant buffers as little as possible.
95
+
96
+
So we have one that we adjust every frame, and one that we 'ideally' never have to update (or very little), an example of this could be static geometry as it'll still need a model matrix but we never have to update it after initial creation.
97
+
98
+
In `Update()` we will update the contents of our constantbuffers :
These functions will take the data in our "...ConstantBufferData" members and upload it to the GPU.
110
+
111
+
The last thing we need to do is make our vertex shader aware of these buffers, easily done by calling ID3D11DeviceContext::VSSetConstantBuffers, note that we can set both slots at once by doing the following:
add to shader, do vertex multiplication with worldmatrix (or model \* camera) there.
121
+
That's all we need to do in order to get some data usable on the GPU, finally we now just need to have our vertex shader aware of this data and apply it.
122
+
123
+
The syntax for this is a little bit different than we're used to in C/C++ but simple enough:
124
+
125
+
cbuffer PerFrame : register(b0)
126
+
{
127
+
row_major matrix viewprojection;
128
+
};
129
+
130
+
cbuffer PerObject : register(b1)
131
+
{
132
+
row_major matrix modelmatrix;
133
+
};
134
+
135
+
We basically declare and define our structure in a single line, `cbuffer` tells the shader it will be a Constant Buffer (and expect the structure like layout), followed by the name of the object `PerFrame`/`PerObject` and lastly which slot to expect it on `: register(b0)`
136
+
after that we just tell it to expect a single row_major matrix in both buffers.
137
+
138
+
Now we're free to use the data in the shader.
139
+
140
+
matrix world = mul(modelmatrix, viewprojection);
141
+
142
+
First we get our World Matrix by multiplying the model matrix with the viewproject as we noted before, then all that's left is to transform every vertex we get as an input and output that.
That's all we need to do in order to get our 3D object onto the screen!
147
+
148
+
149
+
150
+
However since it's still a single triangle, it won't be very obvious if it were static, so in `Update()` we're actually rotating it around by increasing the rotation we have every frame:
151
+
_yRotation += _deltaTime;
52
152
53
-
!!! error
54
-
end up with triangle in 3D space before we move on to next chapter
0 commit comments