Где найти код Transformation->Distort?

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <cstdint>
#include <memory>
#include <cmath>
 
#include "pixel_buffer.hpp"
 
enum {
    g_width     = 640,
    g_height    = 480
};
 
pixel_buffer_dib32  g_texture( 16, 16 );
pixel_buffer_dib32  g_buffer( g_width, g_height );
 
struct coord {
    double x, y;
    coord( double x, double y ) : x(x), y(y) {}
};
 
/// [url]http://stackoverflow.com/a/12919399[/url]
coord tform( int xI, int yI, coord * src, coord * dst ) {
    double ADDING = 0.001; // to avoid dividing by zero
 
    double xA = src[0].x;
    double yA = src[0].y;
 
    double xC = src[1].x;
    double yC = src[1].y;
 
    double xAu = dst[0].x;
    double yAu = dst[0].y;
 
    double xBu = dst[1].x;
    double yBu = dst[1].y;
 
    double xCu = dst[2].x;
    double yCu = dst[2].y;
 
    double xDu = dst[3].x;
    double yDu = dst[3].y;
 
    // Calcultations
    // if points are the same, have to add a ADDING to avoid dividing by zero
    if (xBu==xCu) xCu+=ADDING;
    if (xAu==xDu) xDu+=ADDING;
    if (xAu==xBu) xBu+=ADDING;
    if (xDu==xCu) xCu+=ADDING;
    double kBC = (yBu-yCu)/(xBu-xCu);
    double kAD = (yAu-yDu)/(xAu-xDu);
    double kAB = (yAu-yBu)/(xAu-xBu);
    double kDC = (yDu-yCu)/(xDu-xCu);
 
    if (kBC==kAD) kAD+=ADDING;
    double xE = (kBC*xBu - kAD*xAu + yAu - yBu) / (kBC-kAD);
    double yE = kBC*(xE - xBu) + yBu;
 
    if (kAB==kDC) kDC+=ADDING;
    double xF = (kAB*xBu - kDC*xCu + yCu - yBu) / (kAB-kDC);
    double yF = kAB*(xF - xBu) + yBu;
 
    if (xE==xF) xF+=ADDING;
    double kEF = (yE-yF) / (xE-xF);
 
    if (kEF==kAB) kAB+=ADDING;
    double xG = (kEF*xDu - kAB*xAu + yAu - yDu) / (kEF-kAB);
    double yG = kEF*(xG - xDu) + yDu;
 
    if (kEF==kBC) kBC+=ADDING;
    double xH = (kEF*xDu - kBC*xBu + yBu - yDu) / (kEF-kBC);
    double yH = kEF*(xH - xDu) + yDu;
 
    double rG = (yC-yI)/(yC-yA);
    double rH = (xI-xA)/(xC-xA);
 
    double xJ = (xG-xDu)*rG + xDu;
    double yJ = (yG-yDu)*rG + yDu;
 
    double xK = (xH-xDu)*rH + xDu;
    double yK = (yH-yDu)*rH + yDu;
 
    if (xF==xJ) xJ+=ADDING;
    if (xE==xK) xK+=ADDING;
    double kJF = (yF-yJ) / (xF-xJ); //23
    double kKE = (yE-yK) / (xE-xK); //12
 
    if (kJF==kKE) kKE+=ADDING;
    double xIu = (kJF*xF - kKE*xE + yE - yF) / (kJF-kKE);
    double yIu = kJF * (xIu - xJ) + yJ;
 
    return coord( xIu, yIu );
}
 
void on_paint() {
 
    /// bounds
    coord src[2] = { { 0, 0 }, { g_buffer.get_width(), g_buffer.get_height() } };
 
    /// destination quad
    coord dst[4] = {
        {                        -100, -100 },
        { g_buffer.get_width() - -500, -500 },
        { g_buffer.get_width() - -200, g_buffer.get_height() - -200 },
        {                        -100, g_buffer.get_height() - -100 } };
 
    /// transform...
    for ( int y = 0; y < g_buffer.get_height(); ++y )
    for ( int x = 0; x < g_buffer.get_width(); ++x ) {
        coord xy = tform( x, y, src, dst );
 
        /// rescale from window to texture coordinates...
        coord uv(
            std::trunc( xy.x / g_buffer.get_width()  * g_texture.get_width() ),
            std::trunc( xy.y / g_buffer.get_height() * g_texture.get_height() ) );
 
        /// get texel...
        uint32_t c = g_texture.get_pixel( uv.x, uv.y );
 
        /// set pixel...
        g_buffer.set_pixel( x, y, c );
    }
}
 
LRESULT CALLBACK g_wnd_proc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam ) {
    switch ( uMsg ) {
        case WM_KEYDOWN: {
            switch ( wParam ) {
                case VK_ESCAPE:
                    PostQuitMessage( 0 );
                    break;
            }
        } break;
 
        case WM_PAINT:
            PAINTSTRUCT ps;
            ::BeginPaint( hWnd, &ps );
            on_paint();
            g_buffer.blit( ps.hdc );
            ::EndPaint( hWnd, &ps );
            break;
 
        case WM_CLOSE:
        case WM_DESTROY:
            ::PostQuitMessage( 0 );
            break;
 
        default:
            return ::DefWindowProc( hWnd, uMsg, wParam, lParam );
    }
    return 0;
}
 
int main()
{
    g_buffer.clear( 255 );
 
    // generate checker texture with red border
    for ( int y = 0; y < g_texture.get_height(); ++y )
    for ( int x = 0; x < g_texture.get_width(); ++x ) {
        uint32_t c;
        if ( x == 0 || y == 0 || x == g_texture.get_width() - 1 || y == g_texture.get_height() - 1 ) {
            c = 0xff0000;
        } else {
            c = (x + y) & 1 ? 127 : 192;
            c |= c << 8;
            c |= c << 16;
        }
        g_texture.set_pixel( x, y, c );
    }
 
    WNDCLASS wc = {};
    wc.lpfnWndProc      = g_wnd_proc;
    wc.hInstance        = ::GetModuleHandle( NULL );
    wc.lpszClassName    = "test_cls";
    wc.hCursor          = ::LoadCursor( NULL, IDC_ARROW );
    wc.hbrBackground    = (HBRUSH)(COLOR_BTNFACE + 1);
    ::RegisterClass( &wc );
 
    HWND hWnd = ::CreateWindow(
        wc.lpszClassName, NULL, WS_POPUP /*| WS_VISIBLE*/,
        ::GetSystemMetrics( SM_CXSCREEN ) / 2 - g_width  / 2,
        ::GetSystemMetrics( SM_CYSCREEN ) / 2 - g_height / 2,
        g_width, g_height, NULL, NULL, wc.hInstance, NULL );
 
    ::ShowWindow( hWnd, SW_SHOW );
    ::UpdateWindow( hWnd );
 
    MSG msg;
    while ( ::GetMessage( &msg, NULL, 0, 0 ) ) {
        ::TranslateMessage( &msg );
        ::DispatchMessage( &msg );
    }
 
    ::DestroyWindow( hWnd );
    ::UnregisterClass( wc.lpszClassName, wc.hInstance );
    return 0;
}

#ifndef __PIXEL_BUFFER_HPP__
#define __PIXEL_BUFFER_HPP__
 
class pixel_buffer_dib32 final {
public:
    pixel_buffer_dib32( int width, int height ) :
        m_width( width ),
        m_height( height ),
        m_stride( (width * 4 + 3) / 4 * 4 ),
        m_ptr( new (std::nothrow) uint8_t [m_stride * m_height] )
    {
        ZeroMemory( &m_bi, sizeof( BITMAPINFO ) );
        m_bi.bmiHeader.biSize           = sizeof( BITMAPINFOHEADER );
        m_bi.bmiHeader.biWidth          = m_width;
        m_bi.bmiHeader.biHeight         = -m_height;
        m_bi.bmiHeader.biPlanes         = 1;
        m_bi.bmiHeader.biBitCount       = 32;
        m_bi.bmiHeader.biCompression    = BI_RGB;
    }
 
    virtual ~pixel_buffer_dib32() {
        delete [] m_ptr;
    }
 
    void clear( uint8_t value = 0 ) const { memset( m_ptr, value, m_height * m_stride ); }
 
    explicit operator bool () const { return m_ptr != nullptr; }
 
    int get_width() const { return m_width; }
    int get_height() const { return m_height; }
    int get_stride() const { return m_stride; }
 
    uint8_t * get_ptr() const { return m_ptr; }
    uint8_t * get_row_ptr( int y ) const { return m_ptr + y * m_stride; }
    uint8_t * get_pix_ptr( int x, int y ) const { return get_row_ptr( y ) + x * 4; }
 
    void blit( HDC hdc ) {
        SetDIBitsToDevice( hdc, 0, 0, m_width, m_height, 0, 0, 0, m_height, m_ptr, &m_bi, DIB_RGB_COLORS );
    }
 
    uint32_t get_pixel( int x, int y ) {
        if ( x < 0 || x >= m_width || y < 0 || y >= m_height ) return 0xffffff;
        return *reinterpret_cast<uint32_t *>( get_pix_ptr( x, y ) );
    }
 
    void set_pixel( int x, int y, uint32_t color ) {
        if ( x < 0 || x >= m_width || y < 0 || y >= m_height ) return;
        *reinterpret_cast<uint32_t *>( get_pix_ptr( x, y ) ) = color;
    }
 
private:
    int         m_width;
    int         m_height;
    int         m_stride;
    uint8_t *   m_ptr;
    BITMAPINFO  m_bi;
};
 
#endif // __PIXEL_BUFFER_HPP__