mirror
/
JurassicParkTrespasser
mirror of https://github.com/OpenTrespasser/JurassicParkTrespasser.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
JurassicParkTrespasser/jp2_pc/Source/GUIApp/DialogBumpPack.cpp

1387 lines
29 KiB
C++
Raw Permalink Blame History

/**********************************************************************************************
*
* Copyright © DreamWorks Interactive, 1996
*
* Contents: Implementation of Bump Map Packing control dialog
*
**********************************************************************************************
*
* $Log:: /JP2_PC/Source/GUIApp/DialogBumpPack.cpp $
*
* 10 8/30/98 4:51p Asouth
* loop variable re-scoped
*
* 9 7/03/98 4:12p Rwyatt
* Made a little friendlier
*
* 8 7/02/98 7:11p Rwyatt
* New VM allocation stratergy for curved bump maps
*
* 7 4/21/98 2:56p Rwyatt
* Added a button for a non-pageable bump map page
*
* 6 2/24/98 6:36p Rwyatt
* Modified to use the new texture packer
*
* 5 2/11/98 4:35p Rwyatt
* Can pack triangles on transparent backgrounds.
*
* 4 1/29/98 7:25p Rwyatt
* Fixed memory leaks
* fixed some bug when there was no bump maps
* Works with 16 bit textures
*
* 3 1/19/98 7:30p Pkeet
* Added support for 16 bit bumpmaps by adding lower colour resolution and a smaller size for
* 'CBumpAnglePair.'
*
* 2 1/14/98 6:21p Rwyatt
* First full working version
*
* 1 12/22/97 12:27a Rwyatt
* Initial Implementation
*
*********************************************************************************************/
//
// Includes.
//
#include "StdAfx.h"
#include "DialogBumpPack.hpp"
#include "GUITools.hpp"
#include "Lib/View/Raster.hpp"
#include "Lib/View/RasterVid.hpp"
#include "Lib/View/Clut.hpp"
#include "Lib/Renderer/Primitives/FastBump.hpp"
#include "Lib/Sys/MemoryLog.hpp"
//*********************************************************************************************
//
// CDialogBumpPack implementation.
//
static int i4SelectIconID[MAP_ICONS] = {IDC_MAP0, IDC_MAP1, IDC_MAP2, IDC_MAP3,
IDC_MAP4, IDC_MAP5, IDC_MAP6, IDC_MAP7};
static bool bCheckDropPosition(rptr<CRaster> pras_pack, rptr<CRaster> pras_src, int32 i4_xpos, int32 i4_ypos);
//*********************************************************************************************
//
// Message map for CDialogBumpPack.
//
//*********************************************************************************************
BEGIN_MESSAGE_MAP(CDialogBumpPack, CDialog)
//{{AFX_MSG_MAP(CDialogBumpPack)
ON_WM_HSCROLL()
ON_WM_SHOWWINDOW()
ON_WM_PAINT()
ON_WM_MOUSEMOVE()
ON_LBN_SELCHANGE(IDC_LIST1, OnSelChange)
ON_BN_CLICKED(IDC_RADIO1, OnRadioChange)
ON_BN_CLICKED(IDC_RADIO2, OnRadioChange)
ON_BN_CLICKED(IDC_NEW_SURFACE2, OnNewPage)
ON_BN_CLICKED(IDC_NEW_SURFACE3, OnNewSmallPage)
ON_BN_CLICKED(IDC_MAP0, OnSel0)
ON_BN_CLICKED(IDC_MAP1, OnSel1)
ON_BN_CLICKED(IDC_MAP2, OnSel2)
ON_BN_CLICKED(IDC_MAP3, OnSel3)
ON_BN_CLICKED(IDC_MAP4, OnSel4)
ON_BN_CLICKED(IDC_MAP5, OnSel5)
ON_BN_CLICKED(IDC_MAP6, OnSel6)
ON_BN_CLICKED(IDC_MAP7, OnSel7)
ON_BN_CLICKED(IDC_SET, OnSet)
ON_BN_CLICKED(IDC_LEFT, OnLeft)
ON_BN_CLICKED(IDC_RIGHT, OnRight)
ON_BN_CLICKED(IDC_UP, OnUp)
ON_BN_CLICKED(IDC_DOWN, OnDown)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
//*********************************************************************************************
//
// CDialogBumpPack constructor.
//
//*********************************************************************************************
CDialogBumpPack::CDialogBumpPack(CWnd* pParent /*=NULL*/)
: CDialog(CDialogBumpPack::IDD, pParent)
{
//{{AFX_DATA_INIT(CDialogBumpPack)
i4RadioPage = 0;
strPackMip = _T("-");
strXSize = _T("");
strYSize = _T("");
strMipLevel = _T("");
strPacked = _T("");
strCurved = _T("");
strMinimum = _T("");
strMaximum = _T("");
//}}AFX_DATA_INIT
}
//*********************************************************************************************
CDialogBumpPack::~CDialogBumpPack()
{
delete pgdibmpPack;
delete pgdibmpSelected;
for (int i = 0; i<MAP_ICONS; i++)
{
delete apgdibmpMaps[i];
}
}
//*********************************************************************************************
//
// CDialogBumpPack member functions.
//
//*********************************************************************************************
//
void CDialogBumpPack::DoDataExchange(CDataExchange* pDX)
//
// MFC-generated shit for static controls.
//
//**************************************
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CDialogBumpPack)
DDX_Control(pDX,IDC_LIST1,lbBumpList);
DDX_Control(pDX,IDC_SCROLLBAR1,sbScrollMap);
DDX_Radio(pDX,IDC_RADIO1, i4RadioPage);
DDX_Text(pDX,IDC_TEXT_XSIZE2, strPackMip);
DDX_Text(pDX,IDC_TEXT_XSIZE, strXSize);
DDX_Text(pDX,IDC_TEXT_YSIZE, strYSize);
DDX_Text(pDX,IDC_TEXT_MIPLEVEL, strMipLevel);
DDX_Text(pDX,IDC_TEXT_PACKED, strPacked);
DDX_Text(pDX,IDC_TEXT_CURVED, strCurved);
DDX_Text(pDX,IDC_TEXT_MINIMUM, strMinimum);
DDX_Text(pDX,IDC_TEXT_MAXIMUM, strMaximum);
//}}AFX_DATA_MAP
}
//*********************************************************************************************
//
void CDialogBumpPack::OnHScroll
(
UINT nSBCode,
UINT nPos,
CScrollBar* pScrollBar
)
//
// Responds to the WM_HSCROLL message by moving one or more scrollbars and updating colour
// information accordingly.
//
//**************************************
{
char buf[64];
CDialog::OnHScroll(nSBCode, nPos, pScrollBar);
MoveScrollbar(nSBCode, nPos, pScrollBar);
int32 i4_pos = sbScrollMap.GetScrollPos();
int32 i4_diff = i4_pos - i4BaseScroll; // the number of maps that need to be drawn
int32 i4_off = i4_diff;
i4_diff = abs(i4_diff);
if (i4_diff > MAP_ICONS)
i4_diff = MAP_ICONS;
int32 i4_update;
if (i4_off >0)
{
i4_update = i4_pos + MAP_ICONS - i4_diff; // position to start updating for +ve
}
else
{
i4_update = i4BaseScroll - i4_diff; // position to start updating for -ve
}
while (i4_diff>0)
{
CreateIconPicture(i4_update & 7,i4_update);
i4_update++;
i4_diff--;
}
i4BaseScroll = i4_pos;
wsprintf(buf,"%d",i4BaseScroll);
strMinimum = buf;
wsprintf(buf,"%d",i4BaseScroll+MAP_ICONS-1);
strMaximum = buf;
if (i4Select<0)
{
Invalidate(false);
}
else
{
Invalidate();
// delete the selected DDB
}
delete pgdibmpSelected;
pgdibmpSelected = NULL;
i4Select = -1;
bBlit = false;
bShowRect = false;
ShowTextStats();
}
//*********************************************************************************************
//
void CDialogBumpPack::OnShowWindow
(
BOOL bShow,
UINT nStatus
)
//
// Responds to the WM_SHOWWINDOW message by initializing dialog controls.
//
//**************************************
{
char buf[64];
// Call the base class member function.
CDialog::OnShowWindow(bShow, nStatus);
CRenderTexturePackSurface** aptps = gtxmTexMan.aptpsGetPageList();
prasParent = rptr0;
prasBump = rptr0;
i4PageSelect = -1;
i4Select = -1;
i4BaseScroll = 0;
bShowRect = false;
bBlit = false;
pgdibmpSelected = NULL;
bDropState = false;
bDrop = false;
GetDlgItem(IDC_SET)->EnableWindow(false);
pblMaps = gtxmTexMan.pblGetBumpMaps();
if (pblMaps)
{
u4MapCount = (*pblMaps).size();
GetDlgItem(IDC_SCROLLBAR1)->EnableWindow(true);
sbScrollMap.SetScrollRange(0,u4MapCount-MAP_ICONS);
}
else
{
u4MapCount = 0;
GetDlgItem(IDC_SCROLLBAR1)->EnableWindow(false);
GetDlgItem(IDC_SET)->EnableWindow(false);
GetDlgItem(IDC_NEW_SURFACE2)->EnableWindow(false);
GetDlgItem(IDC_NEW_SURFACE3)->EnableWindow(false);
}
// Delete all strings in the list box because we are about to add them again...
int i = lbBumpList.GetCount();
int i_count = 0;
while (i)
{
lbBumpList.DeleteString(i-1);
i--;
}
bool b_found = false;
for (i=0 ; i<MAX_TEXTURE_PAGES ; i++)
{
// this element in the texture page list is used so add it to the list box
if (aptps[i])
{
if (aptps[i]->iGetPixelBits() == iBUMPMAP_RESOLUTION)
{
wsprintf(buf, "Texture Surface %d", i );
int indx = lbBumpList.AddString(buf);
// the item data of an entry is the index in the texture manager array
lbBumpList.SetItemData(indx, i);
b_found = true;
}
i_count++;
}
}
if (b_found)
{
lbBumpList.SetCurSel(0);
i4PageSelect = lbBumpList.GetItemData(0);
pgdibmpPack = new CGDIBitmap(aptps[ i4PageSelect ]->prasGetRaster(0));
prasParent = aptps[ i4PageSelect ]->prasGetRaster(0);
GetDlgItem(IDC_RADIO1)->EnableWindow(true);
GetDlgItem(IDC_RADIO2)->EnableWindow(true);
GetDlgItem(IDC_LIST1)->EnableWindow(true);
SetPackMipText( aptps[ i4PageSelect ]->eptGetType() );
//wsprintf(buf,"%d",aptps[ i4PageSelect ]->eptGetType( ) );
//strPackMip = buf;
}
else
{
pgdibmpPack = NULL;
GetDlgItem(IDC_RADIO1)->EnableWindow(false);
GetDlgItem(IDC_RADIO2)->EnableWindow(false);
GetDlgItem(IDC_LIST1)->EnableWindow(false);
}
//
// Get the localtion of all important icons
//
WINDOWPLACEMENT wndplc;
GetDlgItem(IDC_PACK_FRAME)->GetWindowPlacement(&wndplc);
rcFrame = wndplc.rcNormalPosition;
rcPack.left = rcFrame.left + (((rcFrame.right - rcFrame.left) - 256)/2);
rcPack.top = rcFrame.top + (((rcFrame.bottom - rcFrame.top) - 256)/2);
GetDlgItem(IDC_STATE)->GetWindowPlacement(&wndplc);
rcState = wndplc.rcNormalPosition;
rcState.left+=2;
rcState.top+=2;
rcState.right-=2;
rcState.bottom-=2;
for (i = 0; i<MAP_ICONS; i++)
{
GetDlgItem(i4SelectIconID[i])->GetWindowPlacement(&wndplc);
rcIconPosition[i] = wndplc.rcNormalPosition;
rcIconPosition[i].left +=2;
rcIconPosition[i].top +=2;
rcIconPosition[i].right -=2;
rcIconPosition[i].bottom -=2;
}
//
// make the initial set of picture icons
//
for (i = 0; i<MAP_ICONS; i++)
{
if (i+i4BaseScroll>=(int32)u4MapCount)
{
apgdibmpMaps[i] = NULL;
}
else
{
apgdibmpMaps[i] = NULL;
CreateIconPicture(i,i+i4BaseScroll);
}
}
wsprintf(buf,"%d",i4BaseScroll);
strMinimum = buf;
if (i4BaseScroll+MAP_ICONS<=(int32)u4MapCount)
wsprintf(buf,"%d",i4BaseScroll+MAP_ICONS-1);
else
wsprintf(buf,"%d",u4MapCount-1);
strMaximum = buf;
UpdateData(false);
}
//*********************************************************************************************
//
void CDialogBumpPack::OnPaint
(
)
//
// Responds to the WM_PAINT
//
//**************************************
{
char buf[128];
RECT rc_update;
int i;
if (!GetUpdateRect(&rc_update))
return;
CPaintDC dc(this);
CBrush blue(RGB(0,0,255));
CBrush green(RGB(0,255,0));
CPen red(PS_SOLID, 2, RGB(255,0,0));
//
// Paint the pack surface
//
if (pgdibmpPack)
{
pgdibmpPack->Draw(dc,rcPack.left,rcPack.top);
}
if (bShowRect)
{
dc.FrameRect(&rcShowRect, &green );
}
if ((bBlit) && (pgdibmpPack))
{
if (pgdibmpSelected->Draw(dc,i4XBlit,i4YBlit,false) == edsNotClipped )
{
if (bCheckDropPosition(prasParent, prasBump,i4XBlit-rcPack.left, i4YBlit-rcPack.top))
{
dc.FillSolidRect(&rcState, RGB(0,255,0) );
}
else
{
dc.FillSolidRect(&rcState, RGB(255,0,0) );
}
bDropState = true;
if (!bDrop)
{
GetDlgItem(IDC_SET)->EnableWindow(true);
bDrop = true;
}
}
else
{
dc.FillSolidRect(&rcState, RGB(255,0,0) );
if (bDrop)
{
GetDlgItem(IDC_SET)->EnableWindow(false);
bDrop = false;
}
bDropState = false;
}
wsprintf(buf,"(%d,%d)",i4XBlit-rcPack.left, i4YBlit-rcPack.top);
GetDlgItem(IDC_TEXT_POSITION)->SetWindowText(buf);
}
else
{
dc.FillSolidRect(&rcState, RGB(128,128,128) );
bDropState = false;
GetDlgItem(IDC_TEXT_POSITION)->SetWindowText("");
}
i = 0;
int32 i4_icon = i4BaseScroll & 7;
if ((rc_update.top<=rcIconPosition[0].bottom) && (rc_update.bottom>=rcIconPosition[0].top))
{
while (i<MAP_ICONS)
{
if (apgdibmpMaps[i4_icon])
{
int32 i4_icon_w = rcIconPosition[i].right - rcIconPosition[i].left;
int32 i4_icon_h = rcIconPosition[i].bottom - rcIconPosition[i].top;
// if our bmp is smaller than the icon, fill the bakcground with gray
if ((i4_icon_w > apgdibmpMaps[i4_icon]->i4Width) || (i4_icon_h > apgdibmpMaps[i4_icon]->i4Height))
{
dc.FillSolidRect(&rcIconPosition[i], RGB(128,128,128) );
}
int32 i4_xp = rcIconPosition[i].left + ((i4_icon_w - apgdibmpMaps[i4_icon]->i4Width)/2);
int32 i4_yp = rcIconPosition[i].top + ((i4_icon_h - apgdibmpMaps[i4_icon]->i4Height)/2);
apgdibmpMaps[i4_icon]->Draw(dc, i4_xp, i4_yp);
// if this map is packed, cross it out
if ( (*pblMaps)[i+i4BaseScroll].bPacked )
{
CPen* old = dc.SelectObject(&red);
dc.MoveTo(rcIconPosition[i].left,rcIconPosition[i].top);
dc.LineTo(rcIconPosition[i].right,rcIconPosition[i].bottom);
dc.MoveTo(rcIconPosition[i].right,rcIconPosition[i].top);
dc.LineTo(rcIconPosition[i].left,rcIconPosition[i].bottom);
dc.SelectObject(old);
}
}
else
{
dc.FillSolidRect(&rcIconPosition[i], RGB(0,0,0) );
}
i++;
i4_icon++;
i4_icon &= 7;
}
}
if (i4Select>=0)
{
RECT rc = rcIconPosition[i4Select];
rc.left -= 5;
rc.top -= 5;
rc.right += 4;
rc.bottom += 4;
dc.FrameRect(&rc, &blue);
}
CDialog::OnPaint();
}
//*********************************************************************************************
//
void CDialogBumpPack::OnSelChange
(
)
//
// Responds to the list box selection being chnaged
//
//**************************************
{
int32 i4_sel = lbBumpList.GetCurSel();
CRenderTexturePackSurface** aptps = gtxmTexMan.aptpsGetPageList();
bShowRect = false;
bBlit = false;
InvalidateRect(&rcState,false);
i4PageSelect = i4_sel;
delete pgdibmpPack;
pgdibmpPack = new CGDIBitmap(aptps[ lbBumpList.GetItemData(i4_sel) ]->prasGetRaster(i4RadioPage));
prasParent = aptps[ lbBumpList.GetItemData(i4_sel) ]->prasGetRaster(i4RadioPage);
SetPackMipText( aptps[ lbBumpList.GetItemData(i4_sel) ]->eptGetType() );
//wsprintf(buf,"%d",aptps[ lbBumpList.GetItemData(i4_sel) ]->eptGetType( ) );
//strPackMip = buf;
InvalidatePackArea();
UpdateData(false);
}
//*********************************************************************************************
//
void CDialogBumpPack::OnRadioChange
(
)
//
// Responds to the page radio buttons being clicked
//
//**************************************
{
// get the radio state
UpdateData(true);
int32 i4_sel = lbBumpList.GetCurSel();
CRenderTexturePackSurface** aptps = gtxmTexMan.aptpsGetPageList();
delete pgdibmpPack;
pgdibmpPack = new CGDIBitmap(aptps[ lbBumpList.GetItemData(i4_sel) ]->prasGetRaster(i4RadioPage));
prasParent = aptps[ lbBumpList.GetItemData(i4_sel) ]->prasGetRaster(i4RadioPage);
bShowRect = false;
bBlit = false;
InvalidateRect(&rcState,false);
InvalidatePackArea();
}
//*********************************************************************************************
//
void CDialogBumpPack::InvalidatePackArea
(
)
//
// Invlaidate the window in the area of the pakced surface
//
//**************************************
{
InvalidateRect(&rcFrame,false);
}
//*********************************************************************************************
//
void CDialogBumpPack::OnNewPage
(
)
//
// Creates a new bump map pack page
//
//**************************************
{
NewBumpPage(eptUSER_PACK);
}
//*********************************************************************************************
//
void CDialogBumpPack::OnNewSmallPage
(
)
//
// Creates a new bump map pack page that is not pageable
//
//**************************************
{
NewBumpPage(eptSMALLEST_USER_PACK);
}
//*********************************************************************************************
//
void CDialogBumpPack::NewBumpPage
(
ETexturePackTypes ept
)
//
// Creates a new bump map pack page that is not pageable
//
//**************************************
{
char buf[64];
int32 i4_page = gtxmTexMan.i4CreateNewBumpPage();
CRenderTexturePackSurface** aptps = gtxmTexMan.aptpsGetPageList();
aptps[ i4_page ]->SetType( ept );
wsprintf(buf, "Texture Surface %d", i4_page );
int indx = lbBumpList.AddString(buf);
if (i4PageSelect<0)
{
// we currently have no bump pages
GetDlgItem(IDC_RADIO1)->EnableWindow(true);
GetDlgItem(IDC_RADIO2)->EnableWindow(true);
GetDlgItem(IDC_LIST1)->EnableWindow(true);
SetPackMipText(aptps[ i4_page ]->eptGetType() );
//wsprintf(buf,"%d",aptps[ i4_page ]->eptGetType( ) );
//strPackMip = buf;
}
i4PageSelect = i4_page;
// the item data of an entry is the index in the texture manager array
lbBumpList.SetItemData(indx, i4_page);
lbBumpList.SetCurSel(indx);
OnSelChange();
}
//*********************************************************************************************
//
void CDialogBumpPack::OnSel0
(
)
//
// Seletcs a map icon
//
//**************************************
{
SelectMap(0);
}
//*********************************************************************************************
//
void CDialogBumpPack::OnSel1
(
)
//
// Seletcs a map icon
//
//**************************************
{
SelectMap(1);
}
//*********************************************************************************************
//
void CDialogBumpPack::OnSel2
(
)
//
// Seletcs a map icon
//
//**************************************
{
SelectMap(2);
}
//*********************************************************************************************
//
void CDialogBumpPack::OnSel3
(
)
//
// Seletcs a map icon
//
//**************************************
{
SelectMap(3);
}
//*********************************************************************************************
//
void CDialogBumpPack::OnSel4
(
)
//
// Seletcs a map icon
//
//**************************************
{
SelectMap(4);
}
//*********************************************************************************************
//
void CDialogBumpPack::OnSel5
(
)
//
// Seletcs a map icon
//
//**************************************
{
SelectMap(5);
}
//*********************************************************************************************
//
void CDialogBumpPack::OnSel6
(
)
//
// Seletcs a map icon
//
//**************************************
{
SelectMap(6);
}
//*********************************************************************************************
//
void CDialogBumpPack::OnSel7
(
)
//
// Seletcs a map icon
//
//**************************************
{
SelectMap(7);
}
//*********************************************************************************************
//
void CDialogBumpPack::OnLeft
(
)
//
// Move selected bump map around pack surface
//
//**************************************
{
if (bBlit)
{
i4XBlit -= 1;
InvalidatePackArea();
InvalidateRect(&rcState,false);
}
}
//*********************************************************************************************
//
void CDialogBumpPack::OnRight
(
)
//
// Move selected bump map around pack surface
//
//**************************************
{
if (bBlit)
{
i4XBlit += 1;
InvalidatePackArea();
InvalidateRect(&rcState,false);
}
}
//*********************************************************************************************
//
void CDialogBumpPack::OnUp
(
)
//
// Move selected bump map around pack surface
//
//**************************************
{
if (bBlit)
{
i4YBlit -= 1;
InvalidatePackArea();
InvalidateRect(&rcState,false);
}
}
//*********************************************************************************************
//
void CDialogBumpPack::OnDown
(
)
//
// Move selected bump map around pack surface
//
//**************************************
{
if (bBlit)
{
i4YBlit += 1;
InvalidatePackArea();
InvalidateRect(&rcState,false);
}
}
//*********************************************************************************************
//
void CDialogBumpPack::OnSet
(
)
//
// set the current pack position
//
//**************************************
{
if ((pgdibmpSelected == NULL) || (i4Select<0) || (!bBlit))
return;
CRenderTexturePackSurface** aptps = gtxmTexMan.aptpsGetPageList();
if ( (*pblMaps)[i4BaseScroll + i4Select].eptMipLevel == eptSMALLEST )
{
// If the texture is a smallest mip the page must also be of type eptSMALLEST
if ( ( aptps[ lbBumpList.GetItemData(lbBumpList.GetCurSel()) ]->eptGetType() != eptSMALLEST ) &&
( aptps[ lbBumpList.GetItemData(lbBumpList.GetCurSel()) ]->eptGetType() != eptSMALLEST_USER_PACK ))
{
MessageBox("The Smallest mip maps must be in non-pageable texture pages.", "Pack Error", MB_OK);
return;
}
}
rptr<CRaster> pras_pack = aptps[ lbBumpList.GetItemData(lbBumpList.GetCurSel())]->prasGetRaster(i4RadioPage);
SRect rc(i4XBlit-rcPack.left, i4YBlit-rcPack.top, (*pblMaps)[i4Select+i4BaseScroll].prasBumpMap->iWidth, (*pblMaps)[i4Select+i4BaseScroll].prasBumpMap->iHeight);
MEMLOG_SUB_COUNTER(emlBumpNoPack,1);
MEMLOG_SUB_COUNTER(emlBumpNoPackMem,
(*pblMaps)[i4Select+i4BaseScroll].prasBumpMap->iLineBytes()*(*pblMaps)[i4Select+i4BaseScroll].prasBumpMap->iHeight);
rptr<CRasterMem> prasmem = rptr_cast(CRasterMem, rptr_new CRasterMem
(
pras_pack,
rc,
aptps[ lbBumpList.GetItemData(lbBumpList.GetCurSel()) ]->ppckPackedRaster(i4RadioPage),
&(*pblMaps)[i4Select+i4BaseScroll].prasBumpMap->pxf)
);
(*pblMaps)[i4Select+i4BaseScroll].prasBumpMap->ChangeRaster( prasmem, true );
// mark this element as packed.
(*pblMaps)[i4Select+i4BaseScroll].bPacked = true;
bBlit = false;
delete pgdibmpSelected;
pgdibmpSelected = NULL;
UpdateData(false);
OnSelChange();
SelectMap(i4Select);
Invalidate();
}
//*********************************************************************************************
//
void CDialogBumpPack::OnMouseMove( UINT nFlags, CPoint pos)
//
// Mouse has moved
//
//**************************************
{
if (!rcFrame.PtInRect(pos))
return;
if (pgdibmpSelected == NULL)
return;
if (pgdibmpPack == NULL)
return;
if (nFlags & MK_LBUTTON)
{
bBlit = true;
i4XBlit = pos.x - (pgdibmpSelected->i4Width/2);
i4YBlit = pos.y - (pgdibmpSelected->i4Height/2);;
InvalidatePackArea();
InvalidateRect(&rcState,false);
}
}
//*********************************************************************************************
//
void CDialogBumpPack::ShowPacked
(
)
//
// shows a pack position
//
//**************************************
{
int32 i4_bump = i4BaseScroll + i4Select;
// if the current bump is not packed, we cannot select it
if ( !(*pblMaps)[i4_bump].bPacked )
return;
// if the stride is not 512 pixels then the map is not packed in a page, it is just in VM
if ( (*pblMaps)[i4_bump].prasBumpMap->iLinePixels != 512)
return;
rptr<CRasterMem> prasmem_bump = rptr_static_cast(CRasterMem, (*pblMaps)[i4_bump].prasBumpMap );
// get the parent packed raster of this bump map
rptr<CPackedRaster> ppck = prasmem_bump->ppckrParent;
CRenderTexturePackSurface** aptps = gtxmTexMan.aptpsGetPageList();
bool b_found = false;
uint32 u4_page;
int i_surface;
for (i_surface=0 ; i_surface<MAX_TEXTURE_PAGES ; i_surface++)
{
if (aptps[i_surface]->ppckPackedRaster(0) == ppck)
{
u4_page = 0;
b_found = true;
break;
}
if (aptps[i_surface]->ppckPackedRaster(1) == ppck)
{
u4_page = 1;
b_found = true;
break;
}
}
// i_surface is the element in the global pack list of our surface.
Assert(b_found);
// all packed surfaces must have a parent.
Assert(ppck);
void* p_parent = (void*) prasmem_bump->prasReferenced->pSurface;
void* p_tex = (void*) prasmem_bump->pSurface;
Assert(p_parent);
Assert(p_tex);
void* p_surface0 = aptps[ i_surface ]->prasGetRaster(0)->pSurface;
void* p_surface1 = aptps[ i_surface ]->prasGetRaster(1)->pSurface;
uint32 u4_bytes = aptps[ i_surface ]->prasGetRaster(0)->iPixelBits/8;
uint32 u4_texture = ((uint8*)p_tex) - ((uint8*)p_parent);
u4_texture /= u4_bytes;
int i_map_count = lbBumpList.GetCount();
int i_element;
while (i_map_count)
{
i_element = lbBumpList.GetItemData(i_map_count-1);
if (i_element == i_surface)
break;
i_map_count--;
}
lbBumpList.SetCurSel(i_map_count-1);
i4RadioPage = (int)u4_page;
OnSelChange();
rcShowRect.left = rcPack.left + (u4_texture & 255);
rcShowRect.top = rcPack.top + (u4_texture >> 9);
rcShowRect.right = rcShowRect.left + prasmem_bump->iWidth;
rcShowRect.bottom = rcShowRect.top + prasmem_bump->iHeight;
bShowRect = true;
InvalidatePackArea();
// delete the selected DDB
delete pgdibmpSelected;
pgdibmpSelected = NULL;
}
//*********************************************************************************************
//
void CDialogBumpPack::SelectMap
(
int32 i4_map
)
//
// Selects the specifed map icon
//
//**************************************
{
RECT rc;
if (i4_map + i4BaseScroll >= (int32)u4MapCount)
return;
if (bShowRect)
{
bShowRect = false;
InvalidatePackArea();
}
int32 i4_old = i4Select;
i4Select = i4_map;
ShowTextStats();
if (i4_old>=0)
{
// deselect the old map
rc = rcIconPosition[i4_old];
rc.left -=8;
rc.top -=8;
rc.right +=8;
rc.bottom +=8;
InvalidateRect(&rc,true);
}
rc = rcIconPosition[i4Select];
rc.left -=8;
rc.top -=8;
rc.right +=8;
rc.bottom +=8;
InvalidateRect(&rc,false);
bBlit = false;
prasBump = (*pblMaps)[i4Select+i4BaseScroll].prasBumpMap;
if ((*pblMaps)[i4Select+i4BaseScroll].bPacked)
{
ShowPacked();
}
else
{
// map is not packed so make a DDB for this icon
delete pgdibmpSelected;
pgdibmpSelected = new CGDIBitmap( prasBump );
pgdibmpSelected->SetClip(rcPack.left,rcPack.top,256,256);
i4XBlit = rcPack.left;
i4YBlit = rcPack.top;
InvalidatePackArea();
}
InvalidateRect(&rcState,false);
}
//*********************************************************************************************
//
void CDialogBumpPack::ShowTextStats
(
)
//
// Shows the stats for the current bump
//
//**************************************
{
char buf[128];
int32 i4 = i4BaseScroll + i4Select;
if (i4Select<0)
{
strXSize = _T("");
strYSize = _T("");
strMipLevel = _T("");
strPacked = _T("");
strCurved = _T("");
UpdateData(false);
}
else
{
wsprintf(buf,"%d", (*pblMaps)[i4].prasBumpMap->iWidth);
strXSize = buf;
wsprintf(buf,"%d", (*pblMaps)[i4].prasBumpMap->iHeight);
strYSize = buf;
switch ( (*pblMaps)[i4].eptMipLevel )
{
case 0:
strcpy(buf,"Top Level");
break;
case 1:
strcpy(buf,"Mip 1");
break;
case 2:
strcpy(buf,"Mip 2");
break;
case 3:
strcpy(buf,"Mip 3");
break;
case 4:
strcpy(buf,"Mip 4");
break;
case 5:
strcpy(buf,"Mip 5");
break;
case 6:
strcpy(buf,"Mip 6");
break;
case -1:
strcpy(buf,"Smallest (Non-Pageable)");
break;
case -2:
strcpy(buf,"Smallest User Pack (Non-Pageable)");
break;
case -3:
strcpy(buf,"Don't Care");
break;
case -4:
strcpy(buf,"User Pack");
break;
case -5:
strcpy(buf,"Curved Parent");
break;
default:
strcpy(buf,"Unknown");
break;
}
strMipLevel = buf;
if ((*pblMaps)[i4].bPacked)
{
if ((*pblMaps)[i4].prasBumpMap->iLinePixels == 512)
strPacked = "Yes";
else
strPacked = "Copied";
}
else
{
strPacked = "No";
}
if ((*pblMaps)[i4].bCurved)
{
strCurved = "Yes";
}
else
{
strCurved = "No";
}
UpdateData(false);
}
}
//*********************************************************************************************
//
void CDialogBumpPack::SetPackMipText
(
ETexturePackTypes ept
)
//**************************************
{
char buf[1024];
switch ( (uint32)ept )
{
case 0:
strcpy(buf,"Top Level");
break;
case 1:
strcpy(buf,"Mip 1");
break;
case 2:
strcpy(buf,"Mip 2");
break;
case 3:
strcpy(buf,"Mip 3");
break;
case 4:
strcpy(buf,"Mip 4");
break;
case 5:
strcpy(buf,"Mip 5");
break;
case 6:
strcpy(buf,"Mip 6");
break;
case -1:
strcpy(buf,"Smallest (Non-Pageable)");
break;
case -2:
strcpy(buf,"Smallest User (Non-Pageable)");
break;
case -3:
strcpy(buf,"Don't Care");
break;
case -4:
strcpy(buf,"User (Pageable)");
break;
case -5:
strcpy(buf,"Curved Parent");
break;
default:
strcpy(buf,"Unknown");
break;
}
strPackMip = buf;
}
//*********************************************************************************************
//
void CDialogBumpPack::CreateIconPicture
(
int32 i4_icon,
int32 i4_bump
)
//
// Creates a new DDB for the given icon and bump map
//
//**************************************
{
int32 i4_icon_w = rcIconPosition[i4_icon].right - rcIconPosition[i4_icon].left;
int32 i4_icon_h = rcIconPosition[i4_icon].bottom - rcIconPosition[i4_icon].top;
int32 i4_w,i4_h;
if ((*pblMaps)[i4_bump].prasBumpMap->iWidth>=i4_icon_w)
{
i4_w = i4_icon_w;
}
else
{
i4_w = (*pblMaps)[i4_bump].prasBumpMap->iWidth;
}
if ((*pblMaps)[i4_bump].prasBumpMap->iHeight>=i4_icon_h)
{
i4_h = i4_icon_h;
}
else
{
i4_h = (*pblMaps)[i4_bump].prasBumpMap->iHeight;
}
delete apgdibmpMaps[i4_icon];
apgdibmpMaps[i4_icon] = new CGDIBitmap((*pblMaps)[i4_bump].prasBumpMap, i4_w, i4_h);
}
//*********************************************************************************************
//
static bool bCheckDropPosition
(
rptr<CRaster> pras_pack,
rptr<CRaster> pras_src,
int32 i4_xpos,
int32 i4_ypos
)
//
// Creates a new DDB for the given icon and bump map
//
//**************************************
{
CBumpAnglePair bang_src;
CBumpAnglePair bang_pack;
int32 i4_w = pras_src->iWidth;
int32 i4_h = pras_src->iHeight;
int32 i4_xloc = i4_xpos;
int32 i4_yloc = i4_ypos;
for (int32 i4_y = 0; i4_y<i4_h ;i4_y++)
{
for (int32 i4_x = 0; i4_x<i4_w ;i4_x++)
{
bang_src.br = pras_src->pixGet(i4_x, i4_y);
// if this pixel is zero, ignore it
if (bang_src.u1GetColour() == 0)
continue;
bang_pack.br = pras_pack->pixGet(i4_x + i4_xloc, i4_y + i4_yloc);
if (bang_pack.u1GetColour() != 0)
return false;
}
}
return true;
}
Reference in New Issue View Git Blame Copy Permalink