CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/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 );
	}
}