Here we're adding new functionality to the texture class. We have functions to lock/unlock the texture because in order to access a texture's pixels we have to lock it and once
we're done messing with the pixels we have to unlock it.

We have a function to get the raw pixels and a function to get the pitch. The pitch is basically the width of the texture in memory. On some older and mobile hardware, there are
limitations of what size texture you can have. If you create a texture with a width of 100 pixels, it may get padded to 128 pixels wide (the next power of two). Using the pitch,
we know how the image is in memory.

In terms of data members we have a pointer to the pixels after we lock the texture and the pitch.

To allow ourselves the ability to edit the texture, we have to load our textures differently. When we created textures from surfaces before, they had the default
SDL_TextureAccess of SDL_TEXTUREACCESS_STATIC, which means we can't change it after it is created. In order to
be able to edit the texture's pixels we have to create the texture with SDL_TEXTUREACCESS_STREAMING.

First we have the load the image as a surface like before. We then have to convert the surface to the same pixel format as the window using SDL_ConvertSurfaceFormat because we can't mix texture rendering and surface rendering calls. We then create a blank texture with SDL_CreateTexture.

After the texture is created we have to manually copy the pixels from the surface to the texture. To grab the pixels from the texture we use
SDL_LockTexture. The first argument is the texture we'll be grabbing pixels from. The second argument is the
region we want to grab pixels from and since we're getting the pixels from the whole texture we set this argument to NULL. The third argument is the pointer that will be set to the
address of the pixels and the last argument will be set the the texture's pitch.

After we have the texture's pixels, we copy the pixels from the surface to the texture using memcpy. The first argument is the destination, the second argument is the source, and
the third argument is the number of bytes we'll be copying. Fortunately, the pitch SDL gives us is the number of bytes per row of pixels so all we have to do is multiply by the
height of the surface to copy in all the pixels from the image.

After we're done copying the pixels from the surface to the texture, we unlock the texture to update it with the new pixels using
SDL_UnlockTexture. After the texture is unlocked the pixel pointer is invalid so we set it to NULL.

With the pixels from the surface copied into the texture, we then get rid of the old surfaces and return true if the texture loaded successfully.

After the texture is locked, we're going to go through the pixels and make all the background pixels transparent. What we're doing is essentially manually color keying the image.

First we allocate a pixel format using SDL_GetWindowPixelFormat and SDL_AllocFormat. We then need to grab the pixels. Our pixel accessor returns a void
pointer and we want 32bit pixels so we type cast it to a 32bit unsigned integer.

Next we want to get the number of pixels. We get the pitch which is the width in bytes. We need the width in pixels and since there are 4 bytes per pixel all we need to do is divide
by 4 to get the pitch in pixels. Then we multiply the pitch width by the height to get the total number of pixels.

What we're going to do is find all the pixels that the color key color and then replace them with transparent pixels. First we map color key color and the transparent color using the window's pixel format.
Then we go through all the pixels and check if any of the pixels match the color key. If it does, we give the value of a transparent pixel.

After we're done going through the pixels we unlock the texture to update it with the new pixels. Lastly we can't forget to call SDL_FreeFormat to deallocate
the pixel format we created.