[-1 ; 1] x [-1 ; 1] x [0 ; 1] mentioned in the tutorial refers to the canonical view volume. It is the final coordinate space vertex data gets mapped to before everything is rasterized to your screen. To understand what exactly this means, it helps to take a look at what a rendering pipeline typically looks like.
A coordinate space refers to the coordinate system you use to define the positions of vertices within it. As a real-life example, imagine you have a desk with a keyboard on top of it and you want to express the position of the keyboard. You could define the front left corner of the desk to be position
(0, 0, 0) — this is called the origin —, the X-axis to be along the length of the desk (left to right), the Y-axis to be along the depth of the desk (near to far), and the Z-axis to be vertically upward from the desk. If your keyboard is located 50 centimeters to the right of this corner, and 10 centimeters away from the nearest edge, it is located at position
(50, 10, 0).
Alternatively, you could define the corner of your room to be position
(0, 0, 0). Lets say your desk is located 200 cm from the left wall, 300 cm from the front wall, and the desk is 70cm in height. In this case your desk's top is located at position
(200, 300, 70), and your keyboard is located at
(250, 310, 70).
These are two examples of different coordinate spaces, and how they affect the position coordinates of the objects within them. Similarly, vertex data in a 3D rendering pipeline is transformed across various coordinate spaces before it ends up on your screen.
Coordinate spaces in a 3D rendering pipeline
Individual objects are modelled in 3D software such as Autodesk Maya, Blender ... . They are often modeled centered around the origin. This coordinate space is called model space. If you were to render several objects in model space together, they would all be piled up centered around the origin.
Instead a new coordinate space called world space is defined. Think of this as your game world, with the origin being the center of the world. When transforming model space to world space coordinates, translations, rotations, scaling and other operations are performed. For example if you want to render a keyboard at position
(250, 310, 70) of your world, you would offset all its vertices by this vector. Mathematically speaking, this is done using a transformation matrix. You can apply a different transformation to each individual object to place objects in your game world.
You now have a big pile of vertices where every objects is placed in the correct position. You now need to define what part of the world you want to look at. This is done by moving all vertex data to camera space. An often-employed convention is have the camera positioned in the origin of camera space, to have it look towards the positive Z-axis (the eye-vector) and to have the positive Y-axis point upward (the up-vector). When converting from world space to model space, we thus want to move and rotate all vertex data so that our objects of focus are near the origin and have positive Z-coordinates.
When you look at objects in real life, you will notice a phenomenon called foreshortening. This means objects near you appear bigger (i.e. take up more of your view), while objects far away from you appear smaller (i.e. take up less of your view). We simulate this by applying a perspective transformation, which moves our camera space vertex coordinates to projected space.
Finally, note that we have 3D vertex data, that needs to be rendered on a 2D screen (e.g. 1920 by 1080 pixels). The vertex data in camera space is therefore transformed to screen space. Your graphics API takes care of rendering the screen space vertex data to your screen. The process of converting vertex data to pixels on your screen is called rasterization. But what vertex coordinates end up where on your screen? This is where the canonical view volume comes into play.
DirectX specifies that the X-coordinate of the vertex is mapped to the horizontal position on the screen. Specifically: range
[-1 ; 1] is mapped to
[0 ; 1920] (in case of a 1920 x 1080 screen). The Y-coordinate of the vertex is mapped to the vertical position on the screen. Specifically: range
[-1 ; 1] is mapped to
[0 ; 1080] (in case of a 1920 x 1080 screen). The Z-coordinate is used to determine what vertices need to be rendered in front or behind each other. Specifically, vertices near 0 are near the camera and should be rendered in front. Vertices near 1 are far away from the canera and rendered behind. Vertices with a Z-coordinate smaller than 0 are behind the camera and thus clipped — i.e. not rendered. Vertices with a Z-coordinate larger than 1 are too far away and are clipped as well.
Your perspective transform thus needs to move all vertices you want visible on your screen inside this canonical view volume. In the tutorial you followed, all of these transformations are omitted to keep the tutorial simple. You are thus directly rendering to the canonical view volume. This is why the author says anything outside of range
[-1 ; 1] x [-1 ; 1] x [0 ; 1] is not visible.
For an article with images to illustrate these various coordinate spaces, see World, View and Projection Transformation Matrices by CodingLabs.