corrected typos

Author: rasql

.gitignore

@@ -1,2 +1 @@
-
-.vscode/settings.json
+.vscode/settings.json

05-cube.rst

@@ -304,9 +304,9 @@ indices (I did it for you):
 
 .. code:: python
 
-    O = [0,1, 1,2, 2,3, 3,0,
+    O = np.array([0,1, 1,2, 2,3, 3,0,
          4,7, 7,6, 6,5, 5,4,
-         0,5, 1,6, 2,7, 3,4 ]
+         0,5, 1,6, 2,7, 3,4 ], dtype=np.uint32)
     O = O.view(gloo.IndexBuffer)
 
 We then need to draw the cube twice. One time using triangles and the indices

06-anti-grain.rst

@@ -167,7 +167,7 @@ the image, this corresponds to the grey areas that give us direct access to the
 final color of the pixel (more precisely, the percentage of the color we have
 to mix with the background color or any other object in the vicinity).
 Unfortunately, such method is not possible to enforce in a full 3D scene
-because all the transformations and differen occlusuins would make the
+because all the transformations and different occlusions would make the
 computation of the final shape too complex. In two dimensions however, this is
 probably the best method we can use and this is also the method that is used in
 the `Anti-grain geometry
@@ -278,11 +278,11 @@ border (with some tolerance or we won't see anything).
        const float epsilon = 0.005;
        float d = distance(v_position, vec2(0.0), 0.5);
        if (d > +epsilon)
-           gl_FragColor = vec4(abs(d), 0.0, 0.0, 1.0);
+           gl_FragColor = vec4(1.0-abs(d), 0.0, 0.0, 1.0);
        else if (d < -epsilon)
-           gl_FragColor = vec4(0.0, 0.0, abs(d), 1.0);
+           gl_FragColor = vec4(0.0, 0.0, 1.0-abs(d), 1.0);
        else 
-           gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
+           gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
    }
    
 
@@ -674,8 +674,8 @@ We have our signed distance functions but we need to exploit them in order to
 do the proper antialiasing. If you remember that a SDF function gives the
 distance to the border of the shape, we still need to compute the right color
 according to this distance. When we are fully inside or outside the shape, it
-is easy: let's say black for the inside and white for the oustide (or nothing
-using the transaprency level). The interesting part is located in the vicinity
+is easy: let's say black for the inside and white for the outside (or nothing
+using the transparency level). The interesting part is located in the vicinity
 of the border, it is not fully black nor fully white but grey. What amount of
 grey you might ask? Well, it is directly correlated with the distance to the
 border. But first, let's have a look at the figure below that show the

07-points.rst

@@ -107,7 +107,7 @@ without taking care of the normalized device coordinate (this transformation
 has been done in the vertex shader above). We now have one problem to solve. A
 GL point is made from a single vertex and the apparent size of the resulting
 quad is controlled by the `gl_PointSize` variable resulting in several
-fragments. How things are interpolated between vertices knowing there is ony
+fragments. How things are interpolated between vertices knowing there is only
 one vertex? The answer is that there is no interpolation. If we want to know
 the position of a fragment relatively to the center, we have to find it
 ourself. Luckily, there is one interesting variable `gl_FragCoord` that gives
@@ -280,13 +280,13 @@ Flat sphere
    A lit sphere
 
 If you look closely at a sphere, you'll see that that the projected shape on
-screen is actualy as disc as shown on the figure on the right. This is actually
+screen is actually a disc as shown on the figure on the right. This is actually
 true independently of the viewpoint and we can take advantage of it. A long
 time ago (with the fixed pipeline), rendering a sphere meant tesselating the
 sphere with a large number of triangles. The larger the number of triangles,
 the higher the quality of the sphere and the slower the rendering. However,
-with the advent of shaders, things have changeg dramatically and we can use
-fake spheres, i.e. discs thar are painted such as to appear as spheres. This is
+with the advent of shaders, things have changed dramatically and we can use
+fake spheres, i.e. discs that are painted such as to appear as spheres. This is
 known as "impostors". If you look again at the image, you might realize that
 the appeareance of the sphere is given by the shading that is not uniform and
 suggests instead a specific lighting that seems to come from the upper right
@@ -331,7 +331,7 @@ for a sphere is very easy. We can simply use the `p=(x,y)` coordinates inside th
 fragment shader and compute the `z` coordinate. How? you might ask
 yourself. This is actually correlated to the distance `d` to the center such
 that `z = 1-d`. If you want to convice yourself, just look at the figure on
-the right that show a side view of half a sphere on the xz plane. The z
+the right that shows a side view of half a sphere on the xz plane. The z
 coordinate is maximal in the center and null on the border.
 
 We're ready to simulate lighting on our disc using the `Phong model

17-bibliography.rst

@@ -8,7 +8,7 @@ Bibliography
    :class: toc chapter-17
 
 
-This is a curated list of some computer graphics resources (peoole, articles,
+This is a curated list of some computer graphics resources (people, articles,
 books & tutorials) addressing different aspects. Some are very specific to
 OpenGL while some others offer a broader view on computer graphics and
 geometry.
@@ -42,7 +42,7 @@ People
 Tutorials
 ---------
 
-.. |tutorial-1| replace:: Open GL tutorial (C)
+.. |tutorial-1| replace:: OpenGL tutorial (C)
 .. _tutorial-1: http://www.opengl-tutorial.org
 
 .. |tutorial-2| replace:: Learn OpenGL (C)