Как наложить текстуру на картинку?

bool SmoothFilter (Graphics::TBitmap *BmpIn, Graphics::TBitmap *BmpOut, int s_offset)
{
        // позиция пикселя
        int x, y;
        // высота
        int h_In = BmpIn->Height;
        // ширина
        int w_In = BmpIn->Width;
        // рабочая линия изображения
        BYTE *line_ptr;
        // трехмерный массив с информацией о пикселях
        BYTE ***in = NULL;
 
        try
        {
            // устанавливаем формат изображения
            BmpIn->PixelFormat = pf24bit;
            // если исходный битмап отличается от входящего
            // то подгоняем его под входящий битмап
            if (BmpOut != BmpIn)
            {
                BmpOut->PixelFormat = pf24bit;
                BmpOut->Width = BmpIn->Width;
                BmpOut->Height = BmpIn->Height;
            }
 
            // выделение памяти
            in = new BYTE **[3];
            for (int i=0; i<3; i++)
            {
                in[i] = new BYTE *[w_In];
                for (int j=0; j<w_In; j++)
                {
                    in[i][j] = new BYTE[h_In];
                }
            }
 
            // копирование изображения из BmpIn в массив in
            for (y=0; y<h_In; y++)
            {
                line_ptr = (BYTE *)BmpIn->ScanLine[y];
                for (x=0; x<w_In; x++)
                {
                    in[0][x][y] = line_ptr[x*3];   // красный канал
                    in[1][x][y] = line_ptr[x*3+1]; // зелёный канал
                    in[2][x][y] = line_ptr[x*3+2]; // синий канал
                }
            }
            // узнаем сколько клеток захватили для размытия
            int d = (s_offset+s_offset+1) * (s_offset+s_offset+1);
 
            for (y=s_offset; y<h_In-s_offset; y++)
            {
                line_ptr = (BYTE *)BmpOut->ScanLine[y-s_offset];
                for (x=s_offset; x<w_In-s_offset; x++)
                {
                    float sum1=0, sum2=0, sum3=0;
                    // пробегаем циклами по всем захваченым клеткам
                    for (int j=-s_offset; j<=s_offset; j++)
                    {
                        // суммируем значения пикселя
                        for (int i=-s_offset; i<=s_offset; i++)
                        {
                            sum1 += in[0][x+i][y+j];
                            sum2 += in[1][x+i][y+j];
                            sum3 += in[2][x+i][y+j];
                        }
                    }
                    // выводим, при этом делим на количество захваченных клеток
                    // дабы получить средний результат
                    line_ptr[(x-s_offset)*3] = (BYTE)(sum1/d);
                    line_ptr[(x-s_offset)*3+1] = (BYTE)(sum2/d);
                    line_ptr[(x-s_offset)*3+2] = (BYTE)(sum3/d);
                }
            }
 
            // освобождение памяти
            for (int i=0; i<3; i++)
            {
                for (int j=0; j<w_In; j++)
                {
                    delete[] in[i][j];
                }
                delete[] in[i];
            }
            delete[] in;
        }
        catch (...)
        {
            return false;
        }
        return true;
}

struct t_rgb_triple
{
    BYTE b;
    BYTE g;
    BYTE r;
} ;
 
// ---------------------------------------------------------------------------
void __fastcall TForm1::img1Click( TObject * Sender )
{
    float blocks_size( 80 );
    TBitmap * bmp( img1->Picture->Bitmap );
    t_rgb_triple ** blocks_line = new t_rgb_triple *[ blocks_size ];
 
    bmp->PixelFormat = pf24bit;
 
    for ( int i( 0 ), i_limit( Ceil( bmp->Height / blocks_size ) ); i < i_limit; ++i )
    {
        for (
            int y( i * blocks_size ), i_line( 0 ), y_limit( ( i + 1 ) * blocks_size ), height( bmp->Height );
            y < y_limit && y < height;
            ++i_line, ++y )
        {
            blocks_line[ i_line ] = reinterpret_cast < t_rgb_triple * > ( bmp->ScanLine[ y ] );
        }
        for (
            long k( 0 ), k_limit( Ceil( bmp->Width / blocks_size ) ), r( 0 ), g( 0 ), b( 0 ), pixels_amount( 0 );
            k < k_limit;
            ++k, r = 0, g = 0, b = 0, pixels_amount = 0 )
        {
            for (
                int x( k * blocks_size ), x_limit( ( k + 1 ) * blocks_size ), width( bmp->Width );
                x < x_limit && x < width;
                ++x )
            {
                for (
                    size_t i_line( 0 ), i_line_limit( blocks_size );
                    i_line < i_line_limit;
                    ++i_line, ++pixels_amount )
                {
                    r += blocks_line[ i_line ][ x ].r;
                    g += blocks_line[ i_line ][ x ].g;
                    b += blocks_line[ i_line ][ x ].b;
                }
            }
            bmp->Canvas->Brush->Color = RGB( r / pixels_amount, g / pixels_amount, b / pixels_amount );
            bmp->Canvas->FillRect( Rect(
                    k * blocks_size,
                    i * blocks_size,
                    k * blocks_size + blocks_size,
                    i * blocks_size + blocks_size ) );
        }
    }
 
    delete[ ]blocks_line;
}