Applying a texture to a bitmap

Introduction

I thought this code might be useful to someone. I'm basically copy-pasting it from some post in VBForums (my own post). Here's what I do: I convert the texture to grayscale. The white-most pixels (highest r, g, or b value) will have the most transparency. The dark-most pixels will be the least transparent pixels when you are applying the texture.

My code may technically not be right, or not the most efficient way to do this. I just wanted to share the idea of how you can apply a texture. Hope this helps.

Details

Call ApplyTexture() to apply a texture to your bitmap. Here's the code:

   ' REMEMBER to add this to the class file that contains 
    ' this code: Imports System.Drawing.Imaging

    ' Modifies the ORIGINAL bitmap
    ' textureTransparency  has to be between 0 and 1, 
    ' with 0 being the least transparent, and 1 the most transparent 
    Public Shared Sub ApplyTexture(ByRef bmp As Bitmap, _
           ByVal texture As Bitmap, _
           ByVal textureTransparency As Single)

        If (bmp Is Nothing) OrElse (texture Is Nothing) _
           Then Throw New ArgumentNullException
        If textureTransparency < 0 OrElse textureTransparency > 1 Then
            Throw New ArgumentOutOfRangeException( _
              "textureTransparency must be between 0 and 1.")
        End If

        ' Convert the texture to grayscale before using it
        MakeImageGrayscale(texture)

        Dim x, y, alpha As Integer

        ' Adjust the alpha value of each pixel in the texture bitmap.
        ' The white-most pixels will have the the 
        ' most transparency (highest alpha), 
        ' and the dark-most pixels will have the least transparency.
        For x = 0 To texture.Width - 1
            For y = 0 To texture.Height - 1
                Dim c As Color = texture.GetPixel(x, y)
                ' c.R -> all of the RGB values are the same 
                ' since the image is in grayscale
                alpha = CInt(c.R * textureTransparency)
                c = Color.FromArgb(alpha, c)

                texture.SetPixel(x, y, c)
            Next
        Next

        Dim gr As Graphics = Graphics.FromImage(bmp)
        Dim myBrush As New TextureBrush(texture)

        ' Draw the texture over the original bitmap
        gr.FillRectangle(myBrush, bmp.GetBounds(GraphicsUnit.Pixel))
        myBrush.Dispose()
        gr.Dispose()
    End Sub

    ' Converts the image to grayscale
    Public Shared Sub MakeImageGrayscale(ByVal bmp As Bitmap)
        Dim cMatrix As New ColorMatrix(New Single()() _
            {New Single() {0.299, 0.299, 0.299, 0, 0}, _
            New Single() {0.587, 0.587, 0.587, 0, 0}, _
            New Single() {0.114, 0.114, 0.114, 0, 0}, _
            New Single() {0, 0, 0, 1, 0}, _
            New Single() {0, 0, 0, 0, 1}})

        Dim imageAttrib As New ImageAttributes
        imageAttrib.SetColorMatrix(cMatrix)


        Dim gr As Graphics = Graphics.FromImage(bmp)
        ' Apply the grayscale image attribute
        gr.DrawImage(bmp, New Rectangle(0, 0, bmp.Width, bmp.Height), _
          0, 0, bmp.Width, bmp.Height, GraphicsUnit.Pixel, imageAttrib)
        gr.Dispose()
    End Sub

I don't know how to program in C#, but I managed to convert that to C# and used pointers instead of SetPixel and GetPixel. I used one of Christian Graus's articles on CodeProject to figure out how to use pointers to read the RGB data from a bitmap, and changed that a bit around to be able to read ARGB values. I hope I did everything right :)

Here it is, faster than the VB version:

// REMEMBER to add this to the class file that contains your code
// using System.Drawing.Imaging;

// Modifies the ORIGINAL bitmap
// textureTransparency  has to be between 0 and 1, 
// with 0 being the least transparent, and 1 the most transparent 
public static void ApplyTexture (Image img, Image texture, 
    float textureTransparency)
{
    if ( (img ==null) || (texture==null) ) 
        throw new ArgumentNullException();
    if (textureTransparency < 0 || textureTransparency > 1) 
        throw new ArgumentOutOfRangeException(
              "Value must be between 0 and 1.");

    // Convert the texture to grayscale before using it
    MakeImageGrayscale (texture);


    Bitmap txtr = new Bitmap(texture);
    BitmapData bmData = txtr.LockBits(new Rectangle(0, 0, 
                 txtr.Width, txtr.Height), 
        ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb); 
    int stride = bmData.Stride; 
    System.IntPtr Scan0 = bmData.Scan0; 
    // Adjust the alpha value of each pixel in the texture bitmap.
    // The white-most pixels will have the the 
    // most transparency (highest alpha), 
    // and the dark-most pixels will have the least transparency.
    unsafe
    {
        byte * p = (byte *)(void *)Scan0;
        int nOffset = stride - txtr.Width*4;


        for (int y=0; y < txtr.Height; ++y)
        {
            for (int x=0; x < txtr.Width; ++x)
            {
                // p[3] is alpha  -  array is BGRA (blue, green , 
                // red, alpha)
                p[3] = (byte)(p[0] * textureTransparency);
                p += 4; // Move to the next pixel
            }
            p += nOffset;
        }
    }
    txtr.UnlockBits(bmData);

    Graphics gr = Graphics.FromImage(img);
    TextureBrush myBrush = new TextureBrush(txtr);
    gr.FillRectangle (myBrush,0,0,img.Width, img.Height);
    myBrush.Dispose();
    gr.Dispose();
    txtr.Dispose();
}



// Converts the image to grayscale
public static void MakeImageGrayscale (Image img)
{
    ColorMatrix cMatrix = new ColorMatrix ( 
       new float[][]  { 
         new float[] {0.299F, 0.299F, 0.299F, 0, 0},
         new float[] {0.587F, 0.587F, 0.587F, 0, 0},
         new float[] {0.114F, 0.114F, 0.114F, 0, 0},
         new float[] {0, 0, 0, 1, 0},
         new float[] {0,  0,  0,  1, 0}});

    ImageAttributes imageAttrib = new ImageAttributes();
    imageAttrib.SetColorMatrix(cMatrix);

    Graphics gr = Graphics.FromImage (img);
    // Apply the grayscale image attribute
    gr.DrawImage (img, new Rectangle(0, 0, img.Width, img.Height), 
                    0, 0, img.Width, img.Height, GraphicsUnit.Pixel, 
                    imageAttrib);
    gr.Dispose();
}

Thanks Greg Ingelmo for correcting me :)