Merge pull request #276 from hsjoihs/patch-3

Fix some obvious typos in 15

15/README.md

@@ -4,11 +4,11 @@
 
 ![](01.jpg)
 
-Graphic cards (GPUs) have special memory types for images. Usually on CPUs images are stores as arrays of bites but on GPUs store images as ```sampler2D``` which is more like a table (or matrix) of floating point vectors. More interestingly is that the values of this *table* of vectors are continously. That means that value between pixels are interpolated in a low level.
+Graphic cards (GPUs) have special memory types for images. Usually on CPUs images are stored as arrays of bytes but GPUs store images as ```sampler2D``` which is more like a table (or matrix) of floating point vectors. More interestingly, the values of this *table* of vectors are continuous. That means that values between pixels are interpolated in a low level.
 
 In order to use this feature we first need to *upload* the image from the CPU to the GPU, to then pass the ```id``` of the texture to the right [```uniform```](../05). All that happens outside the shader.
 
-Once the texture is loaded and linked to a valid ```uniform sampler2D``` you can ask for specific color value at specific coordinates (formated on a [```vec2```](index.html#vec2.md) variable) usin the [```texture2D()```](index.html#texture2D.md) function which will return a color formated on a [```vec4```](index.html#vec4.md) variable.
+Once the texture is loaded and linked to a valid ```uniform sampler2D``` you can ask for specific color value at specific coordinates (formated on a [```vec2```](index.html#vec2.md) variable) using the [```texture2D()```](index.html#texture2D.md) function which will return a color formatted on a [```vec4```](index.html#vec4.md) variable.
 
 ```glsl
 vec4 texture2D(sampler2D texture, vec2 coordinates)  
@@ -18,31 +18,31 @@ Check the following code where we load Hokusai's Wave (1830) as ```uniform sampl
 
 <div class="codeAndCanvas" data="texture.frag" data-textures="hokusai.jpg"></div>
 
-If you pay attention you will note that the coordinates for the texture are normalized! What a surprise right? Textures coordenates are consisten with the rest of the things we had saw and their coordenates are between 0.0 and 1.0 whitch match perfectly with the normalized space coordinates we have been using.
+If you pay attention you will note that the coordinates for the texture are normalized! What a surprise right? Textures coordinates are consistent with the rest of the things we had seen and their coordinates are between 0.0 and 1.0 which match perfectly with the normalized space coordinates we have been using.
 
-Now that you have seen how we load correctly a texture is time to experiment to discover what we can do with it, by trying:
+Now that you have seen how we correctly load a texture, it is time to experiment to discover what we can do with it, by trying:
 
-* Scaling the previus texture by half.
-* Rotating the previus texture 90 degrees.
-* Hooking the mouse position to the coordenates to move it.
+* Scaling the previous texture by half.
+* Rotating the previous texture 90 degrees.
+* Hooking the mouse position to the coordinates to move it.
 
-Why you should be excited about textures? Well first of all forget about the sad 255 values for channel, once your image is trasformed into a ```uniform sampler2D``` you have all the values between 0.0 and 1.0 (depending on what you set the ```precision``` to ). That's why shaders can make really beatiful post-processing effects.
+Why you should be excited about textures? Well first of all forget about the sad 255 values for channel; once your image is transformed into a ```uniform sampler2D``` you have all the values between 0.0 and 1.0 (depending on what you set the ```precision``` to ). That's why shaders can make really beautiful post-processing effects.
 
-Second, the [```vec2()```](index.html#vec2.md) means you can get values even between pixels. As we said before the textures are a continum. This means that if you set up your texture correctly you can ask for values all arround the surface of your image and the values will smoothly vary from pixel to pixel with no jumps!
+Second, the [```vec2()```](index.html#vec2.md) means you can get values even between pixels. As we said before the textures are a continuum. This means that if you set up your texture correctly you can ask for values all around the surface of your image and the values will smoothly vary from pixel to pixel with no jumps!
 
-Finnally, you can setup your image to repeat in the edges, so if you give values over or lower of the normalized 0.0 and 1.0, the values will wrap around starting over.
+Finally, you can set up your image to repeat in the edges, so if you give values over or lower of the normalized 0.0 and 1.0, the values will wrap around starting over.
 
-All this features makes your images more like an infinit spandex fabric. You can streach and shrinks your texture without noticing the grid of bites they originally where compose of or the ends of it. To experience this take a look to the following code where we distort a texture using [the noise function we already made](../11/).
+All these features make your images more like an infinite spandex fabric. You can stretch and shrink your texture without noticing the grid of bytes they are originally composed of or the ends of it. To experience this take a look at the following code where we distort a texture using [the noise function we already made](../11/).
 
 <div class="codeAndCanvas" data="texture-noise.frag" data-textures="hokusai.jpg"></div>
 
 ## Texture resolution
 
-Aboves examples play well with squared images, where both sides are equal and match our squared billboard. But for non-squared images things can be a little more tricky, and unfortunatly centuries of picturical art and photography found more pleasent to the eye non-squared proportions for images.
+Above examples play well with squared images, where both sides are equal and match our squared billboard. But for non-squared images things can be a little more tricky, and unfortunately centuries of pictorial art and photography found more pleasant to the eye non-squared proportions for images.
 
 ![Joseph Nicéphore Niépce (1826)](nicephore.jpg)
 
-How we can solve this problem? Well we need to know the original proportions of the image to know how to streatch the texture correctly in order to have the original [*aspect ratio*](http://en.wikipedia.org/wiki/Aspect_ratio). For that the texture width and height is pass to the shader as an ```uniform```. Which in our example framework are pass as an ```uniform vec2``` with the same name of the texture followed with proposition ```Resolution```. Once we have this information on the shader he can get the aspect ration by dividing the ```width``` for the ```height``` of the texture resolution. Finally by multiplying this ratio to the coordinates on ```y``` we will shrink these axis to match the original proportions.
+How we can solve this problem? Well we need to know the original proportions of the image to know how to stretch the texture correctly in order to have the original [*aspect ratio*](http://en.wikipedia.org/wiki/Aspect_ratio). For that the texture width and height are passed to the shader as an ```uniform```, which in our example framework are passed as an ```uniform vec2``` with the same name of the texture followed with proposition ```Resolution```. Once we have this information on the shader we can get the aspect ratio by dividing the ```width``` for the ```height``` of the texture resolution. Finally by multiplying this ratio to the coordinates on ```y``` we will shrink this axis to match the original proportions.
 
 Uncomment line 21 of the following code to see this in action.
 
@@ -54,25 +54,25 @@ Uncomment line 21 of the following code to see this in action.
 
 ![](03.jpg)
 
-You may be thinking that this is unnesesary complicated... and you are probably right. Also this way of working with images leave a enought room to different hacks and creative tricks. Try to imagine that you are an upholster and by streaching and folding a fabric over a structure you can create better and new patterns and techniques.
+You may be thinking that this is unnecessarily complicated... and you are probably right. Also this way of working with images leaves enough room to different hacks and creative tricks. Try to imagine that you are an upholster and by stretching and folding a fabric over a structure you can create better and new patterns and techniques.
 
 ![Eadweard's Muybridge study of motion](muybridge.jpg)
 
-This level of craftsmanship links back to some of the first optical experiments ever made. For example on games *sprite animations* are very common, and is inevitably to see on it reminicence to phenakistoscope, zoetrope and praxinoscope.
+This level of craftsmanship links back to some of the first optical experiments ever made. For example on games *sprite animations* are very common, and is inevitably to see on it reminiscence to phenakistoscope, zoetrope and praxinoscope.
 
-This could seam simple but the posibilities of modifing textures coordinates is enormus. For example: .
+This could seem simple but the possibilities of modifying textures coordinates are enormous. For example:
 
 <div class="codeAndCanvas" data="texture-sprite.frag" data-textures="muybridge.jpg"></div>
 
 Now is your turn:
 
-* Can you make a kaleidoscope using what we have learn?
+* Can you make a kaleidoscope using what we have learned?
 
-* Way before Oculus or google cardboard, stereoscopic photography was a big thing. Could code a simple shader to re-use this beautiful images?
+* Way before Oculus or google cardboard, stereoscopic photography was a big thing. Could you code a simple shader to re-use these beautiful images?
 
 <a href=“../edit.php#10/ikeda-03.frag”><canvas id=“custom” class=“canvas” data-fragment-url=“ikeda-03.frag”  width=“520px” height=“200px”></canvas></a>
 
 
 * What other optical toys can you re-create using textures?
 
-In the next chapters we will learn how to do some image processing using shaders. You will note that finnaly the complexity of shader makes sense, because was in a big sense designed to do this type of process. We will start doing some image operations!
+In the next chapters we will learn how to do some image processing using shaders. You will note that finally the complexity of shader makes sense, because it was in a big sense designed to do this type of process. We will start doing some image operations!

15/texture-kaleidoscope.frag

@@ -28,7 +28,7 @@ void main () {
     float r = length(st);
     float a = atan(st.y, st.x);
 
-    // Repeat side acoriding to angle
+    // Repeat side according to angle
     float sides = 10.;
     float ma = mod(a, TWO_PI/sides);
     ma = abs(ma - PI/sides);

15/texture-resolution.frag

@@ -16,7 +16,7 @@ void main () {
     vec2 st = gl_FragCoord.xy/u_resolution.xy;
     vec4 color = vec4(0.0);
 
-    // Fix the proportions by finding the aspect ration
+    // Fix the proportions by finding the aspect ratio
     float aspect = u_tex0Resolution.x/u_tex0Resolution.y;
     // st.y *= aspect;  // and then applying to it
 

15/texture-sprite.frag

@@ -25,7 +25,7 @@ void main () {
     // Normalize value of the frame resolution
     vec2 nRes = u_tex0Resolution/fRes;
 
-    // Scale the coordenates to a single frame
+    // Scale the coordinates to a single frame
     st = st/nRes;
 
     // Calculate the offset in cols and rows