/*==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==*/
#include "hsTypes.h"
#include "plLayerTex.h"
#include "plLayerTexBitmapPB.h"
#include "../plDetailCurveCtrl.h"
#if 1
class BMTexPBAccessor;
extern BMTexPBAccessor bmtex_accessor;
class BMCropper : public CropCallback
{
IParamBlock2 *fPBlock;
public:
BMCropper(IParamBlock2* pblock) : fPBlock(pblock) {}
float GetInitU() { return fPBlock->GetFloat(kBmpClipU); }
float GetInitV() { return fPBlock->GetFloat(kBmpClipV); }
float GetInitW() { return fPBlock->GetFloat(kBmpClipW); }
float GetInitH() { return fPBlock->GetFloat(kBmpClipH); }
BOOL GetInitMode() { return fPBlock->GetInt(kBmpCropPlace); }
void SetValues(float u, float v, float w, float h, BOOL md);
void OnClose();
};
class BitmapDlgProc : public ParamMap2UserDlgProc
{
friend class BMTexPBAccessor;
PBBitmap *fLastBMap;
bool fSettingDetailValues;
public:
/// Called to update the controls of the dialog
/// Note: we're bad that we use a static here, but
virtual void Update( TimeValue t, Interval &valid, IParamMap2 *map )
{
ICustButton *bmSelectBtn;
IParamBlock2 *pblock;
int width, height;
ParamMap2UserDlgProc::Update( t, valid, map );
if( fSettingDetailValues )
{
// We're getting an update just because we changed detail values, so we
// know we don't have to do anything ourselves
return;
}
pblock = map->GetParamBlock();
// Update texture map button
bmSelectBtn = GetICustButton( GetDlgItem( map->GetHWnd(), IDC_LAYER_NAME ) );
PBBitmap *pbbm = pblock->GetBitmap( kBmpBitmap, t );
if( pbbm )
{
if( pbbm != fLastBMap )
{
bmSelectBtn->SetText( (TCHAR *)pbbm->bi.Filename() );
// Init values for clamping spinners to powers of 2
width = IFloorPow2( pbbm->bi.Width() );
map->SetRange( kBmpExportWidth, 4.f, (float)width );
height = IFloorPow2( pbbm->bi.Height() );
map->SetRange( kBmpExportHeight, 4.f, (float)height );
IClampTexSizeSpinner( t, map, true );
ISetDetailCurveNumLevels( map, t );
}
}
else if( pbbm != fLastBMap )
bmSelectBtn->SetText( _T( "None" ) );
fLastBMap = pbbm;
ReleaseICustButton( bmSelectBtn );
// Update detail curve control
HWND dlg = map->GetHWnd();
plDetailCurveCtrl *ctrl = GET_DETAIL_CURVE_CTRL( dlg, IDC_DETAIL_CURVE_CTRL );
if( ctrl == NULL )
{
// The control hasn't been created, so create it already!
HWND basis;
RECT r;
// Create the detail map control
basis = GetDlgItem( dlg, IDC_DETAIL_SAMPLE );
GetClientRect( basis, &r );
MapWindowPoints( basis, dlg, (POINT *)&r, 2 );
ctrl = TRACKED_NEW plDetailCurveCtrl( dlg, IDC_DETAIL_CURVE_CTRL, &r );
}
EnableWindow( GetDlgItem( dlg, IDC_DETAIL_CURVE_CTRL ), (BOOL)pblock->GetInt( kBmpUseDetail, t ) );
if( ctrl != NULL )
{
ctrl->SetStartPoint( (float)pblock->GetInt( kBmpDetailStartSize, t ) / 100.f,
(float)pblock->GetInt( kBmpDetailStartOpac, t ) / 100.f );
ctrl->SetEndPoint( (float)pblock->GetInt( kBmpDetailStopSize, t ) / 100.f,
(float)pblock->GetInt( kBmpDetailStopOpac, t ) / 100.f );
}
}
virtual BOOL DlgProc(TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
static ICustButton* bmSelectBtn;
switch (msg)
{
case WM_INITDIALOG:
fLastBMap = NULL;
fSettingDetailValues = false;
break;
/// Note: the following *could* be done in the accessor, except that you end up in an
/// infinite loop updating the values. Not good.
case CC_SPINNER_CHANGE:
if( LOWORD( wParam ) == IDC_EXPORTWIDTH_SPINNER )
IClampTexSizeSpinner( t, map, true );
else if( LOWORD( wParam ) == IDC_EXPORTHEIGHT_SPINNER )
IClampTexSizeSpinner( t, map, false );
break;
// Message from the detail curve that a point got dragged
case PL_DC_POINT_DRAGGED:
{
plDetailCurveCtrl *ctrl = (plDetailCurveCtrl *)lParam;
IParamBlock2 *pblock = map->GetParamBlock();
float x, y;
fSettingDetailValues = true;
if( wParam == PL_DC_START_POINT )
{
ctrl->GetStartPoint( x, y );
pblock->SetValue( kBmpDetailStartSize, t, (int)( x * 100.f ) );
pblock->SetValue( kBmpDetailStartOpac, t, (int)( y * 100.f ) );
}
else
{
ctrl->GetEndPoint( x, y );
pblock->SetValue( kBmpDetailStopSize, t, (int)( x * 100.f ) );
pblock->SetValue( kBmpDetailStopOpac, t, (int)( y * 100.f ) );
}
map->UpdateUI( t );
fSettingDetailValues = false;
}
return 0;
case WM_COMMAND:
if( HIWORD( wParam ) == EN_CHANGE && LOWORD( wParam ) == IDC_EXPORTWIDTH )
IClampTexSizeSpinner( t, map, true );
else if( HIWORD( wParam ) == EN_CHANGE && LOWORD( wParam ) == IDC_EXPORTHEIGHT )
IClampTexSizeSpinner( t, map, false );
else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_BM_CROP_IMAGE)
{
IParamBlock2 *pblock = map->GetParamBlock();
PBBitmap *pbbm = pblock->GetBitmap(kBmpBitmap, t);
if (pbbm)
{
if (!pbbm->bm)
pbbm->bm = TheManager->Load(&pbbm->bi);
BMCropper *cropper = TRACKED_NEW BMCropper(pblock);
pbbm->bm->Display("Specify Cropping/Placement", BMM_CN, FALSE, TRUE, cropper);
}
// bm->DeleteThis();
return TRUE;
}
else if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_LAYER_RELOAD)
{
// TEMP
IParamBlock2 *pblock = map->GetParamBlock();
PBBitmap *pbbm = pblock->GetBitmap(kBmpBitmap, t);
if (pbbm)
{
plLayerTex *layer = (plLayerTex*)map->GetParamBlock()->GetOwner();
layer->RefreshBitmaps();
layer->fMtlParams->MtlChanged();
layer->IChanged();
}
return TRUE;
}
else if (LOWORD(wParam) == IDC_LAYER_NAME)
{
plPlasmaMAXLayer *layer = (plPlasmaMAXLayer *)map->GetParamBlock()->GetOwner();
if (layer == nil)
return FALSE;
BOOL selectedNewBitmap = layer->HandleBitmapSelection();
if(selectedNewBitmap)
{
IParamBlock2 *pblock = map->GetParamBlock();
//plLayerTex *layer = (plLayerTex*)map->GetParamBlock()->GetOwner();
//layer->SetBitmap(&bi);
//layer->IChanged();
//BitmapInfo *bi = &layer->GetPBBitmap()->bi;
bmSelectBtn = GetICustButton(GetDlgItem(hWnd,IDC_LAYER_NAME));
PBBitmap *pbbm = layer->GetPBBitmap();
bmSelectBtn->SetText(pbbm != nil ? (TCHAR*)pbbm->bi.Filename() : "");
ReleaseICustButton(bmSelectBtn);
if (pbbm != nil)
{
// Init values for clamping spinners to powers of 2
int width = IFloorPow2( pbbm->bi.Width() );
map->SetRange( kBmpExportWidth, 4.f, (float)width );
int height = IFloorPow2( pbbm->bi.Height() );
map->SetRange( kBmpExportHeight, 4.f, (float)height );
if( width > 512 )
{
height = (int)( 512.f * (float)( (float)height / (float)width ) );
width = 512;
}
else if( height > 512 )
{
width = (int)( 512.f * (float)( (float)width / (float)height ) );
height = 512;
}
pblock->SetValue( kBmpExportWidth, t, width );
pblock->SetValue( kBmpExportLastWidth, t, width );
pblock->SetValue( kBmpExportHeight, t, height );
pblock->SetValue( kBmpExportLastHeight, t, height );
IClampTexSizeSpinner( t, map, true );
}
return TRUE;
}
else
{
return FALSE;
}
}
break;
}
return FALSE;
}
virtual void DeleteThis() {};
void ISetDetailCurveNumLevels( IParamMap2 *map, TimeValue t )
{
/// Set the level count on the detail control
plDetailCurveCtrl *ctrl = GET_DETAIL_CURVE_CTRL( map->GetHWnd(), IDC_DETAIL_CURVE_CTRL );
if( ctrl != NULL )
{
IParamBlock2 *pblock = map->GetParamBlock();
int w = pblock->GetInt( kBmpExportWidth, t );
int h = pblock->GetInt( kBmpExportHeight, t );
int numLevels = 0;
while( w > 1 && h > 1 )
{
w >>= 1;
h >>= 1;
numLevels++;
}
ctrl->SetNumLevels( numLevels );
}
}
/// Clamp texture sizes to a power of 2
void IClampTexSizeSpinner( TimeValue t, IParamMap2 *map, bool clampWidth )
{
IParamBlock2 *pblock = map->GetParamBlock();
ParamID clampNew, clampOld;
ParamID otherNew, otherOld;
if( clampWidth )
{
clampNew = kBmpExportWidth; clampOld = kBmpExportLastWidth;
otherNew = kBmpExportHeight; otherOld = kBmpExportLastHeight;
}
else
{
clampNew = kBmpExportHeight; clampOld = kBmpExportLastHeight;
otherNew = kBmpExportWidth; otherOld = kBmpExportLastWidth;
}
int lastVal = pblock->GetInt( clampOld, t );
int tempVal, newVal = pblock->GetInt( clampNew, t );
if( newVal < lastVal )
{
lastVal = newVal;
for( tempVal = 1; tempVal <= newVal; tempVal <<= 1 );
newVal = tempVal >> 1;
}
else
{
lastVal = newVal;
for( tempVal = 1; tempVal < newVal; tempVal <<= 1 );
newVal = tempVal;
}
pblock->SetValue( clampNew, t, newVal );
pblock->SetValue( clampOld, t, newVal );
// And clamp aspect ratio
PBBitmap *pbbm = pblock->GetBitmap( kBmpBitmap, t );
if( pbbm != NULL )
{
int realWidth = pbbm->bi.Width();
int realHeight = pbbm->bi.Height();
float aspect;
if( clampWidth )
aspect = (float)realHeight / (float)realWidth;
else
aspect = (float)realWidth / (float)realHeight;
int value = newVal;
value *= aspect;
if( value < 4 )
{
// Can't be below 4!
value = 4;
pblock->SetValue( otherNew, t, value );
pblock->SetValue( otherOld, t, value );
value = value / aspect;
pblock->SetValue( clampNew, t, value );
pblock->SetValue( clampOld, t, value );
}
else
{
pblock->SetValue( otherNew, t, value );
pblock->SetValue( otherOld, t, value );
}
}
ISetDetailCurveNumLevels( map, t );
}
int IFloorPow2( int value )
{
int v;
for( v = 1; v <= value; v <<= 1 );
return v >> 1;
}
};
static BitmapDlgProc gBitmapDlgProc;
static ParamBlockDesc2 gBitmapParamBlk
(
plLayerTex::kBlkBitmap, _T("bitmap"), 0, GetLayerTexDesc(),//NULL,
P_AUTO_CONSTRUCT + P_AUTO_UI, plLayerTex::kRefBitmap,
IDD_LAYER_TEX, IDS_LAYER_TEX, 0, 0, &gBitmapDlgProc,
// Bitmap
kBmpUseBitmap, _T("useBitmap"), TYPE_BOOL, 0, 0,
p_default, TRUE,
p_ui, TYPE_SINGLECHEKBOX, IDC_USE_BITMAP,
end,
kBmpBitmap, _T("bitmap"), TYPE_BITMAP, P_SHORT_LABELS, 0,
p_accessor, &bmtex_accessor,
end,
// Crop/Place
kBmpApply, _T("apply"), TYPE_BOOL, 0, 0,
p_default, FALSE,
p_ui, TYPE_SINGLECHEKBOX, IDC_BM_CLIP,
end,
kBmpCropPlace, _T("cropPlace"), TYPE_INT, 0, 0,
p_default, 0,
p_range, 0, 1,
p_ui, TYPE_RADIO, 2, IDC_BM_CROP,IDC_BM_PLACE,
end,
kBmpClipU, _T("clipU"), TYPE_FLOAT, P_ANIMATABLE, IDS_BITMAP_CLIPU,
p_default, 0.0,
p_range, 0.0, 1.0,
p_ui, TYPE_SPINNER, EDITTYPE_FLOAT, IDC_CLIP_X, IDC_CLIP_XSPIN, 0.001f,
p_accessor, &bmtex_accessor,
end,
kBmpClipV, _T("clipV"), TYPE_FLOAT, P_ANIMATABLE, IDS_BITMAP_CLIPV,
p_default, 0.0,
p_range, 0.0, 1.0,
p_ui, TYPE_SPINNER, EDITTYPE_FLOAT, IDC_CLIP_Y, IDC_CLIP_YSPIN, 0.001f,
p_accessor, &bmtex_accessor,
end,
kBmpClipW, _T("clipW"), TYPE_FLOAT, P_ANIMATABLE, IDS_BITMAP_CLIPW,
p_default, 1.0,
p_range, 0.0, 1.0,
p_ui, TYPE_SPINNER, EDITTYPE_FLOAT, IDC_CLIP_W, IDC_CLIP_WSPIN, 0.001f,
p_accessor, &bmtex_accessor,
end,
kBmpClipH, _T("clipH"), TYPE_FLOAT, P_ANIMATABLE, IDS_BITMAP_CLIPH,
p_default, 1.0,
p_range, 0.0, 1.0,
p_ui, TYPE_SPINNER, EDITTYPE_FLOAT, IDC_CLIP_H, IDC_CLIP_HSPIN, 0.001f,
p_accessor, &bmtex_accessor,
end,
// Texture Color/Alpha
kBmpDiscardColor, _T("discardColor"), TYPE_BOOL, 0, 0,
p_ui, TYPE_SINGLECHEKBOX, IDC_BLEND_NO_COLOR,
end,
kBmpInvertColor, _T("invertColor"), TYPE_BOOL, 0, 0,
p_ui, TYPE_SINGLECHEKBOX, IDC_BLEND_INV_COLOR,
end,
kBmpDiscardAlpha, _T("discardAlpha"), TYPE_BOOL, 0, 0,
p_ui, TYPE_SINGLECHEKBOX, IDC_DISCARD_ALPHA,
end,
kBmpInvertAlpha, _T("invertAlpha"), TYPE_BOOL, 0, 0,
p_ui, TYPE_SINGLECHEKBOX, IDC_BLEND_INV_ALPHA,
end,
// Texture Quality
kBmpNonCompressed, _T("nonCompressed"),TYPE_BOOL, 0, 0,
p_ui, TYPE_SINGLECHEKBOX, IDC_FORCE_NONCOMPRESSED,
end,
kBmpScaling, _T("scaling"), TYPE_INT, 0, 0,
p_ui, TYPE_RADIO, 3, IDC_SCALE_ALL, IDC_SCALE_HALF, IDC_SCALE_NONE,
end,
// Max Only
kBmpMonoOutput, _T("monoOutput"), TYPE_INT, 0, 0,
p_ui, TYPE_RADIO, 2, IDC_HSMAX_LAYER_RGBOUT, IDC_HSMAX_LAYER_ALPHAOUT,
end,
kBmpRGBOutput, _T("rgbOutput"), TYPE_INT, 0, 0,
p_ui, TYPE_RADIO, 2, IDC_HSMAX_LAYER_RGBOUT2, IDC_HSMAX_LAYER_ALPHAOUT2,
end,
// Mipmap
kBmpNoFilter, _T("noFilter"), TYPE_BOOL, 0, 0,
p_ui, TYPE_SINGLECHEKBOX, IDC_NO_FILTERING,
end,
kBmpMipBlur, _T("mipBlur"), TYPE_FLOAT, 0, 0,
p_ui, TYPE_SPINNER, EDITTYPE_FLOAT, IDC_MIPBLUR_EDIT, IDC_MIPBLUR_SPIN, 0.4,
p_range, 0.01f, 100.0f,
p_default, 1.0,
end,
kBmpMipBias, _T("mipBias"), TYPE_BOOL, 0, 0,
p_ui, TYPE_SINGLECHEKBOX, IDC_USE_MIPBIAS,
p_enable_ctrls, 1, kBmpMipBiasAmt,
end,
kBmpMipBiasAmt, _T("mipBiasAmt"), TYPE_FLOAT, 0, 0,
p_ui, TYPE_SPINNER, EDITTYPE_FLOAT, IDC_MIPBIAS_EDIT, IDC_MIPBIAS_SPIN, 0.7,
p_range, -100.0, 100.0,
p_default, 1.0,
end,
// Detail
kBmpUseDetail, _T("useDetail"), TYPE_BOOL, 0, 0,
p_ui, TYPE_SINGLECHEKBOX, IDC_USE_DETAIL,
p_default, FALSE,
p_enable_ctrls, 4, kBmpDetailStartSize, kBmpDetailStopSize, kBmpDetailStartOpac, kBmpDetailStopOpac,
p_accessor, &bmtex_accessor,
end,
kBmpDetailStartSize,_T("dropOffStart"), TYPE_INT, 0, 0,
p_ui, TYPE_SPINNER, EDITTYPE_INT, IDC_DETAIL_START_SIZE_EDIT, IDC_DETAIL_START_SIZE_SPIN, 0.4,
p_range, 0, 100,
p_default, 0,
p_accessor, &bmtex_accessor,
end,
kBmpDetailStopSize, _T("dropOffStop"), TYPE_INT, 0, 0,
p_ui, TYPE_SPINNER, EDITTYPE_INT, IDC_DETAIL_STOP_SIZE_EDIT, IDC_DETAIL_STOP_SIZE_SPIN, 0.4,
p_range, 0, 100,
p_default, 100,
p_accessor, &bmtex_accessor,
end,
kBmpDetailStartOpac, _T("detailMax"), TYPE_INT, 0, 0,
p_ui, TYPE_SPINNER, EDITTYPE_INT, IDC_DETAIL_START_OPAC_EDIT, IDC_DETAIL_START_OPAC_SPIN, 0.4,
p_range, 0, 100,
p_default, 100,
p_accessor, &bmtex_accessor,
end,
kBmpDetailStopOpac, _T("detailMin"), TYPE_INT, 0, 0,
p_ui, TYPE_SPINNER, EDITTYPE_INT, IDC_DETAIL_STOP_OPAC_EDIT, IDC_DETAIL_STOP_OPAC_SPIN, 0.4,
p_range, 0, 100,
p_default, 0,
p_accessor, &bmtex_accessor,
end,
kBmpExportWidth, _T("exportWidth"), TYPE_INT, 0, 0,
p_ui, TYPE_SPINNER, EDITTYPE_INT, IDC_EXPORTWIDTH, IDC_EXPORTWIDTH_SPINNER, SPIN_AUTOSCALE,
p_range, 4, 2048,
p_default, 512,
end,
kBmpExportHeight, _T("exportHeight"), TYPE_INT, 0, 0,
p_ui, TYPE_SPINNER, EDITTYPE_INT, IDC_EXPORTHEIGHT, IDC_EXPORTHEIGHT_SPINNER, SPIN_AUTOSCALE,
p_range, 4, 2048,
p_default, 512,
end,
kBmpExportLastWidth, _T("lastExportWidth"), TYPE_INT, 0, 0,
end,
kBmpExportLastHeight, _T("lastExportHeight"), TYPE_INT, 0, 0,
end,
// Keep a sysmem copy at runtime (for image examination/manipulation).
kBmpNoDiscard, _T("noDiscard"), TYPE_BOOL, 0, 0,
p_ui, TYPE_SINGLECHEKBOX, IDC_NO_DISCARD,
p_default, FALSE,
end,
end
);
ParamBlockDesc2 *GetBitmapBlk() { return &gBitmapParamBlk; }
class BMTexPBAccessor : public PBAccessor
{
public:
void Set(PB2Value& val, ReferenceMaker* owner, ParamID id, int tabIndex, TimeValue t)
{
plLayerTex* layer = (plLayerTex*)owner;
if(layer == NULL) return;
IParamBlock2 *pb = layer->GetParamBlockByID(plLayerTex::kBlkBitmap);
switch (id)
{
case kBmpBitmap:
if (pb->GetMap())
pb->GetMap()->Invalidate(kBmpBitmap);
// Update the bitmap saved by the layer
//layer->SetBitmap(&val.bm->bi, tabIndex);
break;
/*
case kBmpFilename:
bmt->SetMapName(val.s);
break;
case kBmpFiltering:
bmt->filterType = val.i;
if (bmt->thebm)
bmt->thebm->SetFilter(bmFilterType(val.i));
break;
*/
case kBmpClipU:
{
float u = val.f;
float w = pb->GetFloat(kBmpClipW, t);
if (u + w > 1.0f)
{
pb->SetValue(kBmpClipW, t, 1.0f-u);
if (pb->GetMap())
pb->GetMap()->Invalidate(kBmpClipW);
}
break;
}
case kBmpClipW:
{
float w = val.f;
float u = pb->GetFloat(kBmpClipU, t);
if (u + w > 1.0f)
{
pb->SetValue(kBmpClipU, t, 1.0f-w);
if (pb->GetMap())
pb->GetMap()->Invalidate(kBmpClipU);
}
break;
}
case kBmpClipV:
{
float v = val.f;
float h = pb->GetFloat(kBmpClipH, t);
if (v + h > 1.0f)
{
pb->SetValue(kBmpClipH, t, 1.0f-v);
if (pb->GetMap())
pb->GetMap()->Invalidate(kBmpClipH);
}
break;
}
case kBmpClipH:
{
float h = val.f;
float v = pb->GetFloat(kBmpClipV, t);
if (v + h > 1.0f)
{
pb->SetValue(kBmpClipV, t, 1.0f-h);
if (pb->GetMap())
pb->GetMap()->Invalidate(kBmpClipV);
}
break;
}
case kBmpDetailStartSize:
case kBmpDetailStopSize:
case kBmpDetailStartOpac:
case kBmpDetailStopOpac:
if( pb != NULL )
{
if( IIsProcSettingDetailValues( pb ) )
break; // Ignore, since we're the ones setting 'em
HWND dlg = pb->GetMap()->GetHWnd();
plDetailCurveCtrl *ctrl = GET_DETAIL_CURVE_CTRL( dlg, IDC_DETAIL_CURVE_CTRL );
if( ctrl != NULL )
{
if( id == kBmpDetailStartSize || id == kBmpDetailStartOpac )
ctrl->SetStartPoint( (float)pb->GetInt( kBmpDetailStartSize, t ) / 100.f,
(float)pb->GetInt( kBmpDetailStartOpac, t ) / 100.f );
else
ctrl->SetEndPoint( (float)pb->GetInt( kBmpDetailStopSize, t ) / 100.f,
(float)pb->GetInt( kBmpDetailStopOpac, t ) / 100.f );
}
// Make sure start is less than end
if( id == kBmpDetailStartSize )
{
int end = pb->GetInt( kBmpDetailStopSize, t );
if( val.i > end )
pb->SetValue( kBmpDetailStopSize, t, val.i );
}
else if( id == kBmpDetailStopSize )
{
int start = pb->GetInt( kBmpDetailStartSize, t );
if( val.i < start )
pb->SetValue( kBmpDetailStartSize, t, val.i );
}
}
break;
case kBmpUseDetail:
if( pb != NULL )
{
HWND dlg = pb->GetMap()->GetHWnd();
EnableWindow( GetDlgItem( dlg, IDC_DETAIL_CURVE_CTRL ), (BOOL)val.i );
}
break;
}
}
void Get(PB2Value& v, ReferenceMaker* owner, ParamID id, int tabIndex, TimeValue t, Interval &valid)
{
}
// Gotta love hacks....
bool IIsProcSettingDetailValues( IParamBlock2 *pb );
};
static BMTexPBAccessor bmtex_accessor;
//=========================================================================================
// BMCropper
//=========================================================================================
void BMCropper::SetValues(float u, float v, float w, float h, BOOL md)
{
TimeValue t = GetCOREInterface()->GetTime();
if (u != fPBlock->GetFloat(kBmpClipU, t))
{
fPBlock->SetValue(kBmpClipU, t, u);
fPBlock->GetMap()->Invalidate(kBmpClipU);
}
if (v != fPBlock->GetFloat(kBmpClipV, t))
{
fPBlock->SetValue(kBmpClipV, t, v);
fPBlock->GetMap()->Invalidate(kBmpClipV);
}
if (w != fPBlock->GetFloat(kBmpClipW, t))
{
fPBlock->SetValue(kBmpClipW, t, w);
fPBlock->GetMap()->Invalidate(kBmpClipW);
}
if (h != fPBlock->GetFloat(kBmpClipH, t))
{
fPBlock->SetValue(kBmpClipH, t, h);
fPBlock->GetMap()->Invalidate(kBmpClipH);
}
if (md != fPBlock->GetInt(kBmpCropPlace))
{
fPBlock->SetValue(kBmpCropPlace, t, md);
fPBlock->GetMap()->Invalidate(kBmpCropPlace);
}
}
void BMCropper::OnClose()
{
delete this;
}
// Gotta love hacks....
bool BMTexPBAccessor::IIsProcSettingDetailValues( IParamBlock2 *pb )
{
BitmapDlgProc *proc = (BitmapDlgProc *)pb->GetMap()->GetUserDlgProc();
if( proc != NULL )
return proc->fSettingDetailValues;
return false;
}
#endif