#### 5.8.2 Updating Pixel Buffers

Pixel Buffers can be updated in two different ways; a simple, convenient way and a more difficult (but in some cases faster) method. Both methods make use of PixelBox objects (See Pixel boxes) to represent image data in memory.

#### blitFromMemory

The easy method to get an image into a PixelBuffer is by using HardwarePixelBuffer::blitFromMemory. This takes a PixelBox object and does all necessary pixel format conversion and scaling for you. For example, to create a manual texture and load an image into it, all you have to do is

    // Manually loads an image and puts the contents in a manually created texture
    Image img;
    img.load("elephant.png", "General");
    // Create RGB texture with 5 mipmaps
    TexturePtr tex = TextureManager::getSingleton().createManual(
        "elephant",
        "General",
        TEX_TYPE_2D,
        img.getWidth(), img.getHeight(),
        5, PF_X8R8G8B8);
    // Copy face 0 mipmap 0 of the image to face 0 mipmap 0 of the texture.
    tex->getBuffer(0,0)->blitFromMemory(img.getPixelBox(0,0));

#### Direct memory locking

A more advanced method to transfer image data from and to a PixelBuffer is to use locking. By locking a PixelBuffer you can directly access its contents in whatever the internal format of the buffer inside the GPU is.

    /// Lock the buffer so we can write to it
    buffer->lock(HardwareBuffer::HBL_DISCARD);
    const PixelBox &pb = buffer->getCurrentLock();

    /// Update the contents of pb here
    /// Image data starts at pb.data and has format pb.format
    /// Here we assume data.format is PF_X8R8G8B8 so we can address pixels as uint32.
    uint32 *data = static_cast<uint32*>(pb.data);
    size_t height = pb.getHeight();
    size_t width = pb.getWidth();
    size_t pitch = pb.rowPitch; // Skip between rows of image
    for(size_t y=0; y<height; ++y)
    {
        for(size_t x=0; x<width; ++x)
        {
            // 0xRRGGBB -> fill the buffer with yellow pixels
            data[pitch*y + x] = 0x00FFFF00;
        }
    }

    /// Unlock the buffer again (frees it for use by the GPU)
    buffer->unlock();