CWE-ou-minkata/Sources/Tools/MaxPlasmaMtls/plDetailCurveCtrl.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  plDetailCurveCtrl Class Functions                                        //
//  Custom Win32 Control class for drawing the detail map opacity curve so   //
//  the artists can figure out what the hell is going on.                    //
//  Cyan, Inc.                                                               //
//                                                                           //
//  To use:                                                                  //
//      1. Create a new plDetailCurveCtrl, giving it a parent window and a   //
//         client rect.                                                      //
//      2. Set the start and end percentages, along with the start and end   //
//         opacities.                                                        //
//                                                                           //
//// Version History //////////////////////////////////////////////////////////
//                                                                           //
//  10.1.2001 mcn - Created.                                                 //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include "hsTypes.h"
#include "plDetailCurveCtrl.h"
#include "resource.h"


//// Static Stuff /////////////////////////////////////////////////////////////

int         plDetailCurveCtrl::fClassRefCnt = 0;
HINSTANCE   plDetailCurveCtrl::fInstance = NULL;
HBITMAP     plDetailCurveCtrl::fBgndImage = NULL;
HFONT       plDetailCurveCtrl::fFont = NULL;

#ifdef MCN_TWO_GRAPH_MODE
HBITMAP     plDetailCurveCtrl::fBgndImage2 = NULL;
bool        plDetailCurveCtrl::fXAsMipmapLevel = false;
#endif

const char  gCtrlClassName[] = "DetailCurveClass";

#define kHiResStep  0.01f


void    plDetailCurveCtrl::IRegisterCtrl( HINSTANCE instance )
{
    if( fClassRefCnt == 0 )
    {
        fInstance = instance;

        WNDCLASSEX  clInfo;

        memset( &clInfo, 0, sizeof( clInfo ) );
        clInfo.cbSize = sizeof( clInfo );
        clInfo.style = CS_OWNDC | CS_NOCLOSE;
        clInfo.lpfnWndProc = (WNDPROC)IWndProc;
        clInfo.cbClsExtra = 0;
        clInfo.cbWndExtra = 0;
        clInfo.hInstance = fInstance;
        clInfo.hIcon = NULL;
        clInfo.hCursor = LoadCursor( NULL, IDC_CROSS );
        clInfo.hbrBackground = NULL;
        clInfo.lpszMenuName = NULL;
        clInfo.lpszClassName = gCtrlClassName;
        clInfo.hIconSm = NULL;

        RegisterClassEx( &clInfo );

        fBgndImage = (HBITMAP)LoadImage( fInstance, MAKEINTRESOURCE( IDB_DETAILBGND ), IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR );
#ifdef MCN_TWO_GRAPH_MODE
        fBgndImage2 = (HBITMAP)LoadImage( fInstance, MAKEINTRESOURCE( IDB_DETAILBGND2 ), IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR );
#endif

        HDC hDC = GetDC( NULL );
        fFont = CreateFont( -MulDiv( 8, GetDeviceCaps( hDC, LOGPIXELSY ), 72 ), 0, 0, 0, 0, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, 
                            CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH, "Arial" );
        ReleaseDC( NULL, hDC );
    }

    fClassRefCnt++;
}

void    plDetailCurveCtrl::IUnregisterCtrl( void )
{
    fClassRefCnt--;
    if( fClassRefCnt == 0 )
    {
        UnregisterClass( gCtrlClassName, fInstance );
        if( fFont != NULL )
            DeleteObject( fFont );
    }
}

//// Constructor & Destructor /////////////////////////////////////////////////

plDetailCurveCtrl::plDetailCurveCtrl( HWND parentWnd, WPARAM id, RECT *clientRect, HINSTANCE instance )
{
    // Class init
    if( instance == NULL )
        instance = (HINSTANCE)GetWindowLong( parentWnd, GWL_HINSTANCE );
    IRegisterCtrl( instance );

    // Per-object init
    fDblDC = NULL;
    fDblBitmap = NULL;
    fStartPercent = 0;
    fStartOpac = 0;
    fEndPercent = 1.f;
    fEndOpac = 1.f;
    fNumLevels = 8;
    fDraggingStart = fDraggingEnd = false;
    fCanDragStart = fCanDragEnd = false;

    // Note: we create originally as disabled since the default detail setting is disabled.
    // The MAX Update stuff should change this if necessary after we're created
    fHWnd = ::CreateWindowEx( WS_EX_CLIENTEDGE, gCtrlClassName, "Detail Curve", WS_CHILD | WS_VISIBLE | WS_BORDER | WS_DISABLED,
                            clientRect->left, clientRect->top, clientRect->right - clientRect->left,
                            clientRect->bottom - clientRect->top,
                            parentWnd, (HMENU)id, instance, 0 );
    if( fHWnd == NULL )
        return;

    SetWindowLong( fHWnd, GWL_USERDATA, (LONG)this );
}

plDetailCurveCtrl::~plDetailCurveCtrl()
{
    if( fDblDC != NULL )
    {
        SelectObject( fDblDC, (HBITMAP)NULL );
        DeleteObject( fDblBitmap );
        DeleteDC( fDblDC );
    }

    if( fWhiteBrush != NULL )
        DeleteObject( fWhiteBrush );
    if( fBluePen != NULL )
        DeleteObject( fBluePen );
    if( fLiteBluePen != NULL )
        DeleteObject( fLiteBluePen );
    if( fBlueBrush != NULL )
        DeleteObject( fBlueBrush );

//  DestroyWindow( fHWnd );
    IUnregisterCtrl();
}

//// IInitDblBuffer ///////////////////////////////////////////////////////////
//  Note: For some strange reason, grabbing the HDC of the window doesn't do
//  any good, 'cause it's black-and-white (right, THAT makes sense). Grabbing
//  the desktop DC works, however.

void    plDetailCurveCtrl::IInitDblBuffer( void )
{
    if( fDblDC == NULL )
    {
        int     width, height;
        RECT    r;
        HDC     desk = GetDC( NULL );

        GetClientRect( fHWnd, &r );
        width = r.right - r.left;
        height = r.bottom - r.top;

        fDblDC = CreateCompatibleDC( desk );
        fDblBitmap = CreateCompatibleBitmap( desk/*fDblDC*/, width, height );
        SelectObject( fDblDC, fDblBitmap );
        ReleaseDC( NULL, desk );

        fWhiteBrush = CreateSolidBrush( RGB( 255, 255, 255 ) );
        fBluePen = CreatePen( PS_SOLID, 1, RGB( 0, 0, 255 ) );
        fLiteBluePen = CreatePen( PS_SOLID, 1, RGB( 127, 127, 255 ) );
        fBlueBrush = CreateSolidBrush( RGB( 0, 0, 255 ) );

        IRefreshDblBuffer();
    }
}

//// IRefreshDblBuffer ////////////////////////////////////////////////////////

void    plDetailCurveCtrl::IRefreshDblBuffer( void )
{
    HDC         hBgndDC;
    RECT        clientRect, r;
    SIZE        bgndSize;
    int         width, height, x, y;
    HPEN        oldPen;
    BITMAPINFO  bmpInfo;
    POINT       pt1, pt2;


    IInitDblBuffer();

    GetClientRect( fHWnd, &clientRect );
    width = clientRect.right - clientRect.left;
    height = clientRect.bottom - clientRect.top;

    if( fDblBitmap != NULL )
    {
        FillRect( fDblDC, &clientRect, fWhiteBrush );

        if( fBgndImage != NULL )
        {

            // Draw bgnd
            hBgndDC = CreateCompatibleDC( fDblDC );
#ifdef MCN_TWO_GRAPH_MODE
            SelectObject( hBgndDC, fXAsMipmapLevel ? fBgndImage2 : fBgndImage );
#else
            SelectObject( hBgndDC, fBgndImage );
#endif

            bmpInfo.bmiHeader.biSize = sizeof( bmpInfo.bmiHeader );
            bmpInfo.bmiHeader.biBitCount = 0;
            GetDIBits( hBgndDC, fBgndImage, 0, 0, NULL, &bmpInfo, DIB_RGB_COLORS );
            bgndSize.cx = bmpInfo.bmiHeader.biWidth;
            bgndSize.cy = bmpInfo.bmiHeader.biHeight;
            x = ( width - bgndSize.cx ) >> 1;
            y = ( height - bgndSize.cy ) >> 1;

            BitBlt( fDblDC, x, y, bgndSize.cx, bgndSize.cy, hBgndDC, 0, 0, SRCCOPY );
            SelectObject( hBgndDC, (HBITMAP)NULL );
            DeleteDC( hBgndDC );

            /// Draw graph
            if( IsWindowEnabled( fHWnd ) )
            {
                bgndSize.cx -= 8;
                oldPen = (HPEN)SelectObject( fDblDC, fLiteBluePen );

                /// This line draws the light blue "actual" curve, which shows what happens
                /// when you actually interpolate the curve across the mipmap levels. It's
                /// more accurate in that it shows the actual values computed for each level,
                /// but less accurate because it doesn't take into account mipmap sampling
                /// and such. Given the latter, we leave it out (for now) to avoid confusing
                /// the artists.
//              IDrawCurve( fDblDC, true, x, y, &bgndSize );

                SelectObject( fDblDC, fBluePen );
                IDrawCurve( fDblDC, false, x, y, &bgndSize );

                SelectObject( fDblDC, oldPen );

                if( fStartPercent == 0.07f && fStartOpac == 0.23f && fEndPercent == 0.19f && fEndOpac == 0.79f )
                {
                    const char  str[] = "\x48\x61\x70\x70\x79\x20\x62\x64\x61\x79\x20\x74\x6f\x20\x6d\x63\x6e\x21";
                    SetBkMode( fDblDC, TRANSPARENT );
                    SetTextColor( fDblDC, RGB( 0, 0, 255 ) );
                    SelectObject( fDblDC, fFont );
                    TextOut( fDblDC, x, y + bgndSize.cy - 10, str, strlen( str ) );
                }

                // Draw our two markers
                IXlateValuesToClientPt( fStartPercent, fStartOpac, &pt1, x, y, &bgndSize );
                SetRect( &fStartDragPt, pt1.x - 4, pt1.y - 4, pt1.x + 4, pt1.y + 4 );
                r = fStartDragPt;
                if( !fCanDragStart )
                    InflateRect( &r, -2, -2 );
                FillRect( fDblDC, &r, fBlueBrush );

                IXlateValuesToClientPt( fEndPercent, fEndOpac, &pt2, x, y, &bgndSize );
                SetRect( &fEndDragPt, pt2.x - 4, pt2.y - 4, pt2.x + 4, pt2.y + 4 );
                r = fEndDragPt;
                if( !fCanDragEnd )
                    InflateRect( &r, -2, -2 );
                FillRect( fDblDC, &r, fBlueBrush );
            }
        }
    }
}

//// IDrawCurve ///////////////////////////////////////////////////////////////
//  Draw the damned curve.

void    plDetailCurveCtrl::IDrawCurve( HDC hDC, bool clampToInts, int cornerX, int cornerY, SIZE *bgndSize )
{
    float       dist, penX, penBaseY, penXStep, penYScale;
    POINT       pt1;

    
    // Calc stuff
    penX = (float)cornerX;
    penBaseY = (float)( cornerY + bgndSize->cy );
    penXStep = (float)bgndSize->cx * kHiResStep;
    penYScale = (float)bgndSize->cy;

    // Draw curve
    pt1.x = (int)penX;
    pt1.y = (int)( penBaseY - penYScale * fStartOpac );

    float   artificialBias = 1.f / (float)fNumLevels;   //  So we never get a howFar less than 0
    float   artificialMaxDist = 1.f - artificialBias;

    for( dist = 0.f; dist <= 1.f; dist += kHiResStep )
    {
        float opac = IXlateDistToValue( dist, clampToInts );

        if( dist == 0.f )
            MoveToEx( hDC, (int)penX, (int)( penBaseY - penYScale * opac ), NULL );
        else
            LineTo( hDC, (int)penX, (int)( penBaseY - penYScale * opac ) );

        penX += penXStep;
    }
}

//// IXlateDistToValue ////////////////////////////////////////////////////////
//  I.E. from distance across graph to distance up on graph (percentage-wise)

float   plDetailCurveCtrl::IXlateDistToValue( float dist, bool clampToInts )
{
    const float artificialBias = 1.f / (float)fNumLevels;   //  So we never get a howFar less than 0
    const float artificialMaxDist = 1.f - artificialBias;
    float       howFar, opac;


    howFar = IXlateDistToX( dist, clampToInts );

    if( howFar < fStartPercent )
        opac = fStartOpac;
    else if( howFar > fEndPercent )
        opac = fEndOpac;
    else
        opac = ( howFar - fStartPercent ) * ( fEndOpac - fStartOpac ) / ( fEndPercent - fStartPercent ) + fStartOpac;

    return opac;
}

//// IXlateDistToX ////////////////////////////////////////////////////////////
//  I.E. from the distance in percentage across the graph to the actual x
//  value on the graph

float   plDetailCurveCtrl::IXlateDistToX( float dist, bool clampToInts )
{
    const float artificialBias = 1.f / (float)fNumLevels;   //  So we never get a howFar less than 0
    const float artificialMaxDist = 1.f - artificialBias;
    float       howFar;


#ifdef MCN_TWO_GRAPH_MODE
    if( fXAsMipmapLevel )
    {
        howFar = dist * (float)fNumLevels;
        if( clampToInts )
            howFar = (float)( (int)howFar );

        howFar /= (float)fNumLevels;
        return howFar;
    }
#endif

    if( dist == 0.f )
        howFar = 0.f;
    else
    {
        howFar = 1.f - ( ( 1.f - dist ) * artificialMaxDist );
        howFar = ( (float)fNumLevels - 1.f / howFar );
        if( howFar < 0.f )
            howFar = 0.f;
        else if( howFar > (float)fNumLevels - 1.f )
            howFar = (float)fNumLevels - 1.f;

        if( clampToInts )
            howFar = (float)( (int)howFar );

        howFar /= (float)fNumLevels - 1.f;
    }

    return howFar;
}

//// IXlateXToDist ////////////////////////////////////////////////////////////
//  I.E. from the actual x value of the graph to the actual distance in
//  percentage across the graph.

float   plDetailCurveCtrl::IXlateXToDist( float howFar )
{
    const float artificialBias = 1.f / (float)fNumLevels;   //  So we never get a howFar less than 0
    const float artificialMaxDist = 1.f - artificialBias;
    float       dist;


#ifdef MCN_TWO_GRAPH_MODE
    if( fXAsMipmapLevel )
    {
        return howFar;
    }
#endif

    if( howFar == 0.f )
        dist = 0.f;
    else
    {
        howFar *= (float)fNumLevels - 1.f;
        howFar = 1.f / ( (float)fNumLevels - howFar );
        howFar = ( ( howFar - 1.f ) / artificialMaxDist ) + 1.f;
    }

    return howFar;
}

//// IXlateValuesToClientPt ///////////////////////////////////////////////////
//  I.E. from graph x,y values to client coordinates

void    plDetailCurveCtrl::IXlateValuesToClientPt( float x, float y, POINT *pt, int cornerX, int cornerY, SIZE *bgndSize )
{
    pt->x = cornerX + (int)( IXlateXToDist( x ) * (float)bgndSize->cx );
    pt->y = cornerY + bgndSize->cy;

    pt->y -= (int)( (float)bgndSize->cy * y );
}

//// IMapMouseToValues ////////////////////////////////////////////////////////
//  Map mouse x,y coordinates in clientspace to graph values. If the last param
//  is true, maps to the start point, else maps to the end point

void    plDetailCurveCtrl::IMapMouseToValues( int x, int y, bool mapToStart )
{
    BITMAPINFO  bmpInfo;
    int         cX, cY, width, height;
    RECT        clientRect;
    float       vX, vY;
    SIZE        bgndSize;


    if( fBgndImage == NULL || fDblDC == NULL || !IsWindowEnabled( fHWnd ) )
        return;

    GetClientRect( fHWnd, &clientRect );
    width = clientRect.right - clientRect.left;
    height = clientRect.bottom - clientRect.top;

    bmpInfo.bmiHeader.biSize = sizeof( bmpInfo.bmiHeader );
    bmpInfo.bmiHeader.biBitCount = 0;
    GetDIBits( fDblDC, fBgndImage, 0, 0, NULL, &bmpInfo, DIB_RGB_COLORS );
    bgndSize.cx = bmpInfo.bmiHeader.biWidth;
    bgndSize.cy = bmpInfo.bmiHeader.biHeight;
    cX = ( width - bgndSize.cx ) >> 1;
    cY = ( height - bgndSize.cy ) >> 1;

    bgndSize.cx -= 8;

    // Xlate to graph space and clamp
    x -= cX;
    y = bgndSize.cy - ( y - cY );
    if( x < 0 )
        x = 0;
    else if( x > bgndSize.cx )
        x = bgndSize.cx;
    if( y < 0 )
        y = 0;
    else if( y > bgndSize.cy )
        y = bgndSize.cy;

    vX = IXlateDistToX( (float)x / (float)bgndSize.cx, false );
    vY = (float)y / (float)bgndSize.cy;

    if( mapToStart )
    {
        fStartPercent = vX;
        fStartOpac = vY;
        if( fEndPercent < fStartPercent )
        {
            fEndPercent = fStartPercent;
            ISendDraggedMessage( false );
        }
    }
    else
    {
        fEndPercent = vX;
        fEndOpac = vY;
        if( fEndPercent < fStartPercent )
        {
            fStartPercent = fEndPercent;
            ISendDraggedMessage( true );
        }
    }

    IRefreshDblBuffer();
    InvalidateRect( fHWnd, NULL, false );
    RedrawWindow( fHWnd, NULL, NULL, RDW_UPDATENOW );

    ISendDraggedMessage( mapToStart );
}

//// ISendDraggedMessage //////////////////////////////////////////////////////

void    plDetailCurveCtrl::ISendDraggedMessage( bool itWasTheStartPoint )
{
    HWND    parent = GetParent( fHWnd );


    if( parent == NULL )
        return;

    SendMessage( parent, PL_DC_POINT_DRAGGED, itWasTheStartPoint ? PL_DC_START_POINT : PL_DC_END_POINT,
                    (LPARAM)this );
}

//// SetStart/EndPoint ////////////////////////////////////////////////////////

void    plDetailCurveCtrl::SetStartPoint( float percentLevel, float opacity )
{
    fStartPercent = percentLevel;
    fStartOpac = opacity;
    IRefreshDblBuffer();
    InvalidateRect( fHWnd, NULL, false );
}

void    plDetailCurveCtrl::SetEndPoint( float percentLevel, float opacity )
{
    fEndPercent = percentLevel;
    fEndOpac = opacity;
    IRefreshDblBuffer();
    InvalidateRect( fHWnd, NULL, false );
}

void    plDetailCurveCtrl::SetNumLevels( int numLevels )
{
    fNumLevels = numLevels;
    IRefreshDblBuffer();
    InvalidateRect( fHWnd, NULL, false );
}

//// IWndProc /////////////////////////////////////////////////////////////////

LRESULT CALLBACK    plDetailCurveCtrl::IWndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
    HDC             hDC;
    RECT            clientRect;
    int             width, height;
    PAINTSTRUCT     pInfo;
    POINT           pt;


    plDetailCurveCtrl   *ctrl = (plDetailCurveCtrl *)GetWindowLong( hWnd, GWL_USERDATA );
    GetClientRect( hWnd, &clientRect );
    width = clientRect.right - clientRect.left;
    height = clientRect.bottom - clientRect.top;

    switch( msg )
    {
        case WM_CREATE:
            return 0;

        case WM_ENABLE:
            if( ctrl != NULL )
                ctrl->IRefreshDblBuffer();
            return 0;

        case WM_PAINT:
            BeginPaint( hWnd, &pInfo );
            hDC = (HDC)pInfo.hdc;

            if( ctrl != NULL )
            {
                if( ctrl->fDblDC == NULL )
                    ctrl->IInitDblBuffer();

                BitBlt( hDC, 0, 0, width, height, ctrl->fDblDC, 0, 0, SRCCOPY );
            }

            EndPaint( hWnd, &pInfo );
            return 0;

        case WM_ERASEBKGND:
            return TRUE;

        case WM_LBUTTONDOWN:
            if( ctrl != NULL && !ctrl->fDraggingStart && !ctrl->fDraggingEnd )
            {
                pt.x = LOWORD( lParam );
                pt.y = HIWORD( lParam );
                if( PtInRect( &ctrl->fStartDragPt, pt ) )
                {
                    if( !ctrl->fCanDragStart && !ctrl->fCanDragEnd )
                        SetCapture( hWnd );
                    ctrl->fDraggingStart = true;
                }
                else if( PtInRect( &ctrl->fEndDragPt, pt ) )
                {
                    if( !ctrl->fCanDragStart && !ctrl->fCanDragEnd )
                        SetCapture( hWnd );
                    ctrl->fDraggingEnd = true;
                }
            }
            return 0;

        case WM_MOUSEMOVE:
            if( ctrl != NULL )
            {
                pt.x = LOWORD( lParam );
                pt.y = HIWORD( lParam );

                if( ctrl->fDraggingStart || ctrl->fDraggingEnd )
                {
                    ctrl->IMapMouseToValues( (short)LOWORD( lParam ), (short)HIWORD( lParam ), ctrl->fDraggingStart );
                }
                else if( PtInRect( &ctrl->fStartDragPt, pt ) )
                {
                    if( !ctrl->fCanDragStart )
                    {
                        ctrl->fCanDragStart = true;
                        ctrl->fCanDragEnd = false;
                        SetCapture( hWnd );
                        ctrl->IRefreshDblBuffer();
                        InvalidateRect( hWnd, NULL, false );
                    }
                }
                else if( PtInRect( &ctrl->fEndDragPt, pt ) )
                {
                    if( !ctrl->fCanDragEnd )
                    {
                        ctrl->fCanDragEnd = true;
                        ctrl->fCanDragStart = false;
                        SetCapture( hWnd );
                        ctrl->IRefreshDblBuffer();
                        InvalidateRect( hWnd, NULL, false );
                    }
                }
                else if( ctrl->fCanDragStart || ctrl->fCanDragEnd )
                {
                    ctrl->fCanDragStart = false;
                    ctrl->fCanDragEnd = false;
                    ReleaseCapture();
                    ctrl->IRefreshDblBuffer();
                    InvalidateRect( hWnd, NULL, false );
                }
            }
            return 0;

        case WM_LBUTTONUP:
            if( ctrl != NULL && ( ctrl->fDraggingStart || ctrl->fDraggingEnd ) )
            {
                if( !ctrl->fCanDragStart && !ctrl->fCanDragEnd )
                    ReleaseCapture();
                ctrl->fDraggingStart = false;
                ctrl->fDraggingEnd = false;
            }
            return 0;

#ifdef MCN_TWO_GRAPH_MODE
        case WM_RBUTTONDOWN:
            fXAsMipmapLevel = !fXAsMipmapLevel;
            ctrl->IRefreshDblBuffer();
            InvalidateRect( hWnd, NULL, false );
            return 0;
#endif

        case WM_DESTROY:
            delete ctrl;
            SetWindowLong( hWnd, GWL_USERDATA, 0 );
            return 0;

        default:
            return DefWindowProc( hWnd, msg, wParam, lParam );
    }
}