1006 lines
24 KiB
C++
1006 lines
24 KiB
C++
// SurfaceDlg.cpp : implementation file
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "Radiant.h"
|
|
#include "SurfaceDlg.h"
|
|
#include "PrefsDlg.h"
|
|
#include "mainfrm.h"
|
|
#include "TextureLayout.h"
|
|
#ifdef SOF
|
|
#include "materials.h"
|
|
#endif
|
|
#include "oddbits.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CSurfaceDlg dialog
|
|
|
|
CSurfaceDlg g_dlgSurface;
|
|
|
|
|
|
CSurfaceDlg::CSurfaceDlg(CWnd* pParent /*=NULL*/)
|
|
: CDialog(CSurfaceDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CSurfaceDlg)
|
|
m_nWidth = 1;
|
|
m_nHeight = 1;
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
|
|
void CSurfaceDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CSurfaceDlg)
|
|
DDX_Control(pDX, IDC_SPIN_HEIGHT, m_wndHeight);
|
|
DDX_Control(pDX, IDC_SPIN_WIDTH, m_wndWidth);
|
|
DDX_Control(pDX, IDC_SPIN_VSHIFT, m_wndVShift);
|
|
DDX_Control(pDX, IDC_SPIN_VSCALE, m_wndVScale);
|
|
DDX_Control(pDX, IDC_SPIN_ROTATE, m_wndRotate);
|
|
DDX_Control(pDX, IDC_SPIN_HSHIFT, m_wndHShift);
|
|
DDX_Control(pDX, IDC_SPIN_HSCALE, m_wndHScale);
|
|
DDX_Text(pDX, IDC_EDIT_WIDTH, m_nWidth);
|
|
DDV_MinMaxInt(pDX, m_nWidth, 1, 5000);
|
|
DDX_Text(pDX, IDC_EDIT_HEIGHT, m_nHeight);
|
|
DDV_MinMaxInt(pDX, m_nHeight, 1, 5000);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CSurfaceDlg, CDialog)
|
|
//{{AFX_MSG_MAP(CSurfaceDlg)
|
|
ON_WM_HSCROLL()
|
|
ON_WM_KEYDOWN()
|
|
ON_WM_VSCROLL()
|
|
ON_BN_CLICKED(IDAPPLY, OnApply)
|
|
ON_WM_CLOSE()
|
|
ON_WM_DESTROY()
|
|
ON_BN_CLICKED(ID_BTN_CANCEL, OnBtnCancel)
|
|
ON_BN_CLICKED(IDC_BTN_COLOR, OnBtnColor)
|
|
ON_WM_CTLCOLOR()
|
|
ON_WM_CREATE()
|
|
ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN_HSHIFT, OnDeltaPosSpin)
|
|
ON_BN_CLICKED(IDC_BTN_PATCHDETAILS, OnBtnPatchdetails)
|
|
ON_BN_CLICKED(IDC_BTN_PATCHNATURAL, OnBtnPatchnatural)
|
|
ON_BN_CLICKED(IDC_BTN_PATCHRESET, OnBtnPatchreset)
|
|
ON_BN_CLICKED(IDC_BTN_PATCHFIT, OnBtnPatchfit)
|
|
ON_BN_CLICKED(IDC_BTN_AXIAL, OnBtnAxial)
|
|
ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN_HSCALE, OnDeltaPosSpin)
|
|
ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN_ROTATE, OnDeltaPosSpin)
|
|
ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN_VSCALE, OnDeltaPosSpin)
|
|
ON_NOTIFY(UDN_DELTAPOS, IDC_SPIN_VSHIFT, OnDeltaPosSpin)
|
|
ON_BN_CLICKED(IDC_BTN_FACEFIT, OnBtnFacefit)
|
|
ON_BN_CLICKED(IDC_BTN_FACERESET, OnBtnFaceReset)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CSurfaceDlg message handlers
|
|
|
|
|
|
/*
|
|
===================================================
|
|
|
|
SURFACE INSPECTOR
|
|
|
|
===================================================
|
|
*/
|
|
|
|
texdef_t g_old_texdef;
|
|
texdef_t g_patch_texdef;
|
|
HWND g_surfwin = NULL;
|
|
qboolean g_changed_surface;
|
|
|
|
int g_checkboxes[64] = {
|
|
IDC_CHECK1, IDC_CHECK2, IDC_CHECK3, IDC_CHECK4,
|
|
IDC_CHECK5, IDC_CHECK6, IDC_CHECK7, IDC_CHECK8,
|
|
IDC_CHECK9, IDC_CHECK10, IDC_CHECK11, IDC_CHECK12,
|
|
IDC_CHECK13, IDC_CHECK14, IDC_CHECK15, IDC_CHECK16,
|
|
IDC_CHECK17, IDC_CHECK18, IDC_CHECK19, IDC_CHECK20,
|
|
IDC_CHECK21, IDC_CHECK22, IDC_CHECK23, IDC_CHECK24,
|
|
IDC_CHECK25, IDC_CHECK26, IDC_CHECK27, IDC_CHECK28,
|
|
IDC_CHECK29, IDC_CHECK30, IDC_CHECK31, IDC_CHECK32,
|
|
|
|
IDC_CHECK33, IDC_CHECK34, IDC_CHECK35, IDC_CHECK36,
|
|
IDC_CHECK37, IDC_CHECK38, IDC_CHECK39, IDC_CHECK40,
|
|
IDC_CHECK41, IDC_CHECK42, IDC_CHECK43, IDC_CHECK44,
|
|
IDC_CHECK45, IDC_CHECK46, IDC_CHECK47, IDC_CHECK48,
|
|
IDC_CHECK49, IDC_CHECK50, IDC_CHECK51, IDC_CHECK52,
|
|
IDC_CHECK53, IDC_CHECK54, IDC_CHECK55, IDC_CHECK56,
|
|
IDC_CHECK57, IDC_CHECK58, IDC_CHECK59, IDC_CHECK60,
|
|
IDC_CHECK61, IDC_CHECK62, IDC_CHECK63, IDC_CHECK64
|
|
};
|
|
|
|
#ifdef SOF
|
|
char *psLightmipStrings[]= // don't add to these 4 unless you update all flag AND bits etc. Basically, leave it. -slc
|
|
{
|
|
"default",
|
|
"low (eg 1/3....1/1)", // this spacing actually matches under final output font
|
|
"lower (eg 1/6....1/1)",
|
|
"single pixel",
|
|
NULL
|
|
};
|
|
#endif
|
|
|
|
/*
|
|
==============
|
|
SetTexMods
|
|
|
|
Set the fields to the current texdef
|
|
===============
|
|
*/
|
|
|
|
bool g_bNewFace = false;
|
|
bool g_bNewApplyHandling = false;
|
|
bool g_bGatewayhack = false;
|
|
|
|
void CSurfaceDlg::SetTexMods()
|
|
{
|
|
char sz[128];
|
|
texdef_t *pt;
|
|
int i;
|
|
|
|
if (!g_surfwin)
|
|
return;
|
|
|
|
m_bPatchMode = false;
|
|
|
|
if (OnlyPatchesSelected())
|
|
{
|
|
pt = &g_qeglobals.d_texturewin.texdef;
|
|
if (QE_SingleBrush())
|
|
{
|
|
strcpy(g_patch_texdef.name, Patch_GetTextureName());
|
|
}
|
|
else
|
|
{
|
|
strcpy(g_patch_texdef.name, pt->name);
|
|
}
|
|
g_patch_texdef.contents = pt->contents;
|
|
g_patch_texdef.flags = pt->flags;
|
|
g_patch_texdef.value = pt->value;
|
|
pt = &g_patch_texdef;
|
|
m_bPatchMode = true;
|
|
}
|
|
else
|
|
{
|
|
if (g_bNewFace && selected_face)
|
|
pt = &selected_face->texdef;
|
|
else
|
|
pt = &g_qeglobals.d_texturewin.texdef;
|
|
|
|
#ifdef SOF
|
|
// lightmip combo box...
|
|
//
|
|
i = (pt->flags >> 22) &3;
|
|
HWND comboBox = GetDlgItem(IDC_TEXTURE_LIGHTMIP)->GetSafeHwnd();
|
|
::SendMessage(comboBox, CB_RESETCONTENT, 0,0);
|
|
for (int j=0; psLightmipStrings[j]; j++)
|
|
{
|
|
::SendMessage(comboBox, CB_ADDSTRING, 0, (LPARAM)psLightmipStrings[j]);
|
|
if (i == j)
|
|
{
|
|
::SendMessage(comboBox, CB_SELECTSTRING, (WPARAM)(-1), (LPARAM)psLightmipStrings[j]);
|
|
}
|
|
}
|
|
|
|
// materials combo box...
|
|
//
|
|
i = (pt->flags & 0x0FF000000) >> 24;
|
|
comboBox = GetDlgItem(IDC_TEXTURE_MATERIAL)->GetSafeHwnd();
|
|
::SendMessage(comboBox, CB_RESETCONTENT, 0,0);
|
|
for (materialtype_t *mat = materialtypes ; mat->name ; mat++)
|
|
{
|
|
::SendMessage(comboBox, CB_ADDSTRING, 0, (LPARAM)mat->name);
|
|
if (i == mat->value)
|
|
{
|
|
::SendMessage(comboBox, CB_SELECTSTRING, (WPARAM)(-1), (LPARAM)mat->name);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
SendMessage (WM_SETREDRAW, 0, 0);
|
|
|
|
::SetWindowText(GetDlgItem(IDC_TEXTURE)->GetSafeHwnd(), pt->name);
|
|
if (m_bPatchMode)
|
|
sprintf(sz, "%4.3f", pt->shift[0]);
|
|
else
|
|
sprintf(sz, "%d", (int)pt->shift[0]);
|
|
::SetWindowText(GetDlgItem(IDC_HSHIFT)->GetSafeHwnd(), sz);
|
|
|
|
if (m_bPatchMode)
|
|
sprintf(sz, "%4.3f", pt->shift[1]);
|
|
else
|
|
sprintf(sz, "%d", (int)pt->shift[1]);
|
|
::SetWindowText(GetDlgItem(IDC_VSHIFT)->GetSafeHwnd(), sz);
|
|
|
|
sprintf(sz, m_bPatchMode ? "%4.6f" : "%4.6f", pt->scale[0]);
|
|
::SetWindowText(GetDlgItem(IDC_HSCALE)->GetSafeHwnd(), sz);
|
|
|
|
sprintf(sz, m_bPatchMode ? "%4.6f" : "%4.6f", pt->scale[1]);
|
|
::SetWindowText(GetDlgItem(IDC_VSCALE)->GetSafeHwnd(), sz);
|
|
|
|
sprintf(sz, "%d", (int)pt->rotate);
|
|
::SetWindowText(GetDlgItem(IDC_ROTATE)->GetSafeHwnd(), sz);
|
|
|
|
sprintf(sz, "%d", (int)pt->value);
|
|
::SetWindowText(GetDlgItem(IDC_VALUE)->GetSafeHwnd(), sz);
|
|
|
|
#ifdef SOF
|
|
sprintf(sz, "%f", pt->lighting[0]);
|
|
::SetWindowText(GetDlgItem(IDC_LIGHT_RED)->GetSafeHwnd(), sz);
|
|
|
|
sprintf(sz, "%f", pt->lighting[1]);
|
|
::SetWindowText(GetDlgItem(IDC_LIGHT_GREEN)->GetSafeHwnd(), sz);
|
|
|
|
sprintf(sz, "%f", pt->lighting[2]);
|
|
::SetWindowText(GetDlgItem(IDC_LIGHT_BLUE)->GetSafeHwnd(), sz);
|
|
|
|
sprintf(sz, "%f", pt->lighting[3]);
|
|
::SetWindowText(GetDlgItem(IDC_LIGHT_ALPHA)->GetSafeHwnd(), sz);
|
|
#endif
|
|
|
|
#ifdef SOF
|
|
for (i=0 ; i<22 ; i++) // top 8 bits are now material, next 2 are lightmip
|
|
#else
|
|
for (i=0 ; i<32 ; i++)
|
|
#endif
|
|
::SendMessage(GetDlgItem(g_checkboxes[i])->GetSafeHwnd(), BM_SETCHECK, !!(pt->flags&(1<<i)), 0 );
|
|
for (i=0 ; i<32 ; i++)
|
|
::SendMessage(GetDlgItem(g_checkboxes[32+i])->GetSafeHwnd(), BM_SETCHECK, !!(pt->contents&(1<<i)), 0 );
|
|
|
|
SendMessage (WM_SETREDRAW, 1, 0);
|
|
InvalidateRect (NULL, true);
|
|
}
|
|
|
|
|
|
void CSurfaceDlg::GrabPatchMods()
|
|
{
|
|
char sz[128];
|
|
int i;
|
|
bool b;
|
|
texdef_t *pt = & g_patch_texdef;
|
|
|
|
::GetWindowText (GetDlgItem(IDC_HSHIFT)->GetSafeHwnd(), sz, 127);
|
|
pt->shift[0] = atof(sz);
|
|
|
|
::GetWindowText (GetDlgItem(IDC_VSHIFT)->GetSafeHwnd(), sz, 127);
|
|
pt->shift[1] = atof(sz);
|
|
|
|
::GetWindowText(GetDlgItem(IDC_HSCALE)->GetSafeHwnd(), sz, 127);
|
|
pt->scale[0] = atof(sz);
|
|
|
|
::GetWindowText(GetDlgItem(IDC_VSCALE)->GetSafeHwnd(), sz, 127);
|
|
pt->scale[1] = atof(sz);
|
|
|
|
::GetWindowText(GetDlgItem(IDC_ROTATE)->GetSafeHwnd(), sz, 127);
|
|
pt->rotate = atof(sz);
|
|
|
|
::GetWindowText(GetDlgItem(IDC_VALUE)->GetSafeHwnd(), sz, 127);
|
|
pt->value = atof(sz);
|
|
|
|
#ifdef SOF // not 100% sure it'll ever get here in SOF mode - no patches?
|
|
::GetWindowText(GetDlgItem(IDC_LIGHT_RED)->GetSafeHwnd(), sz, 127);
|
|
pt->lighting[0] = atof(sz);
|
|
|
|
::GetWindowText(GetDlgItem(IDC_LIGHT_GREEN)->GetSafeHwnd(), sz, 127);
|
|
pt->lighting[1] = atof(sz);
|
|
|
|
::GetWindowText(GetDlgItem(IDC_LIGHT_BLUE)->GetSafeHwnd(), sz, 127);
|
|
pt->lighting[2] = atof(sz);
|
|
|
|
::GetWindowText(GetDlgItem(IDC_LIGHT_ALPHA)->GetSafeHwnd(), sz, 127);
|
|
pt->lighting[3] = atof(sz);
|
|
#endif
|
|
|
|
|
|
pt->flags = 0;
|
|
#ifdef SOF
|
|
for (i=0 ; i<22 ; i++) // top 8 bits are now material, next 2 are lightmip
|
|
#else
|
|
for (i=0 ; i<32 ; i++)
|
|
#endif
|
|
{
|
|
b = ::SendMessage(GetDlgItem(g_checkboxes[i])->GetSafeHwnd(), BM_GETCHECK, 0, 0);
|
|
if (b != 1 && b != 0)
|
|
continue;
|
|
pt->flags |= b<<i;
|
|
}
|
|
|
|
pt->contents = 0;
|
|
for (i=0 ; i<32 ; i++)
|
|
{
|
|
b = ::SendMessage(GetDlgItem(g_checkboxes[32+i])->GetSafeHwnd(), BM_GETCHECK, 0, 0);
|
|
if (b != 1 && b != 0)
|
|
continue;
|
|
pt->contents |= b<<i;
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
==============
|
|
GetTexMods
|
|
|
|
Reads the fields to get the current texdef
|
|
===============
|
|
*/
|
|
void CSurfaceDlg::GetTexMods()
|
|
{
|
|
char sz[128];
|
|
texdef_t *pt;
|
|
int b;
|
|
int i;
|
|
|
|
m_bPatchMode = false;
|
|
|
|
if (OnlyPatchesSelected())
|
|
{
|
|
pt = &g_qeglobals.d_texturewin.texdef;
|
|
m_bPatchMode = true;
|
|
}
|
|
else
|
|
{
|
|
if (g_bNewFace && selected_face)
|
|
pt = &selected_face->texdef;
|
|
else
|
|
pt = &g_qeglobals.d_texturewin.texdef;
|
|
}
|
|
|
|
::GetWindowText (GetDlgItem(IDC_TEXTURE)->GetSafeHwnd(), sz, 127);
|
|
sz[127]=0;
|
|
CString str(sz);
|
|
str.TrimLeft();
|
|
str.TrimRight();
|
|
strcpy(sz,(LPCSTR)str);
|
|
|
|
strncpy (pt->name, sz, sizeof(pt->name)-1);
|
|
|
|
if (pt->name[0] <= ' ')
|
|
{
|
|
strcpy (pt->name, "none");
|
|
::SetWindowText(GetDlgItem(IDC_TEXTURE)->GetSafeHwnd(), pt->name);
|
|
}
|
|
|
|
::GetWindowText (GetDlgItem(IDC_HSHIFT)->GetSafeHwnd(), sz, 127);
|
|
pt->shift[0] = atof(sz);
|
|
|
|
::GetWindowText (GetDlgItem(IDC_VSHIFT)->GetSafeHwnd(), sz, 127);
|
|
pt->shift[1] = atof(sz);
|
|
|
|
::GetWindowText(GetDlgItem(IDC_HSCALE)->GetSafeHwnd(), sz, 127);
|
|
pt->scale[0] = atof(sz);
|
|
|
|
::GetWindowText(GetDlgItem(IDC_VSCALE)->GetSafeHwnd(), sz, 127);
|
|
pt->scale[1] = atof(sz);
|
|
|
|
::GetWindowText(GetDlgItem(IDC_ROTATE)->GetSafeHwnd(), sz, 127);
|
|
pt->rotate = atof(sz);
|
|
|
|
::GetWindowText(GetDlgItem(IDC_VALUE)->GetSafeHwnd(), sz, 127);
|
|
pt->value = atof(sz);
|
|
|
|
|
|
#ifdef SOF
|
|
::GetWindowText(GetDlgItem(IDC_LIGHT_RED)->GetSafeHwnd(), sz, 127);
|
|
pt->lighting[0] = atof(sz);
|
|
|
|
::GetWindowText(GetDlgItem(IDC_LIGHT_GREEN)->GetSafeHwnd(), sz, 127);
|
|
pt->lighting[1] = atof(sz);
|
|
|
|
::GetWindowText(GetDlgItem(IDC_LIGHT_BLUE)->GetSafeHwnd(), sz, 127);
|
|
pt->lighting[2] = atof(sz);
|
|
|
|
::GetWindowText(GetDlgItem(IDC_LIGHT_ALPHA)->GetSafeHwnd(), sz, 127);
|
|
pt->lighting[3] = atof(sz);
|
|
#endif
|
|
|
|
|
|
pt->flags = 0;
|
|
#ifdef SOF
|
|
for (i=0 ; i<22 ; i++) // top 8 bits are now material, next 2 are lightmip
|
|
#else
|
|
for (i=0 ; i<32 ; i++)
|
|
#endif
|
|
{
|
|
b = ::SendMessage(GetDlgItem(g_checkboxes[i])->GetSafeHwnd(), BM_GETCHECK, 0, 0);
|
|
if (b != 1 && b != 0)
|
|
continue;
|
|
pt->flags |= b<<i;
|
|
}
|
|
|
|
pt->contents = 0;
|
|
for (i=0 ; i<32 ; i++)
|
|
{
|
|
b = ::SendMessage(GetDlgItem(g_checkboxes[32+i])->GetSafeHwnd(), BM_GETCHECK, 0, 0);
|
|
if (b != 1 && b != 0)
|
|
continue;
|
|
pt->contents |= b<<i;
|
|
}
|
|
|
|
#ifdef SOF
|
|
// read bits from LIGHTMIP combo box...
|
|
HWND comboBox = GetDlgItem(IDC_TEXTURE_LIGHTMIP)->GetSafeHwnd();
|
|
::GetWindowText(comboBox, sz, 127);
|
|
for (int j=0; psLightmipStrings[j]; j++)
|
|
{
|
|
if (!strcmp(psLightmipStrings[j], sz))
|
|
{
|
|
// assumes SURF_LIGHTMIP is in bits 22,23 (top 8 bits (minus 2))
|
|
pt->flags = (pt->flags & ~(0x03<<22)) | (j << 22);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// read bits from MATERIALS combo box...
|
|
comboBox = GetDlgItem(IDC_TEXTURE_MATERIAL)->GetSafeHwnd();
|
|
::GetWindowText(comboBox, sz, 127);
|
|
for (materialtype_t *mat=materialtypes ; mat->name ; mat++)
|
|
{
|
|
if (!strcmp(mat->name, sz))
|
|
{
|
|
// assumes SURF_MATERIAL is in top 8 bits
|
|
pt->flags = (pt->flags & 0x0FFFFFF) | (mat->value << 24);
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
g_changed_surface = true;
|
|
|
|
Select_SetTexture(pt);
|
|
//if (m_bPatchMode)
|
|
//{
|
|
// Patch_SetTextureInfo(pt);
|
|
//}
|
|
|
|
}
|
|
|
|
/*
|
|
=================
|
|
UpdateSpinners
|
|
=================
|
|
*/
|
|
|
|
void CSurfaceDlg::UpdateSpinners(bool bUp, int nID)
|
|
{
|
|
texdef_t *pt;
|
|
texdef_t td;
|
|
|
|
if (m_bPatchMode)
|
|
{
|
|
td.rotate = 0.0;
|
|
td.scale[0] = td.scale[1] = 0.0;
|
|
td.shift[0] = td.shift[1] = 0.0;
|
|
GrabPatchMods();
|
|
|
|
pt = &g_patch_texdef;
|
|
td.contents = pt->contents;
|
|
td.flags = pt->flags;
|
|
td.value = pt->value;
|
|
|
|
if (nID == IDC_SPIN_ROTATE)
|
|
{
|
|
if (bUp)
|
|
td.rotate = pt->rotate;
|
|
else
|
|
td.rotate = -pt->rotate;
|
|
}
|
|
else if (nID == IDC_SPIN_HSCALE)
|
|
{
|
|
if (bUp)
|
|
td.scale[0] = 1-pt->scale[0];
|
|
else
|
|
td.scale[0] = 1+pt->scale[0];
|
|
}
|
|
else if (nID == IDC_SPIN_VSCALE)
|
|
{
|
|
if (bUp)
|
|
td.scale[1] = 1-pt->scale[1];
|
|
else
|
|
td.scale[1] = 1+pt->scale[1];
|
|
}
|
|
|
|
else if (nID == IDC_SPIN_HSHIFT)
|
|
{
|
|
if (bUp)
|
|
td.shift[0] = pt->shift[0];
|
|
else
|
|
td.shift[0] = -pt->shift[0];
|
|
}
|
|
else if (nID == IDC_SPIN_VSHIFT)
|
|
{
|
|
if (bUp)
|
|
td.shift[1] = pt->shift[1];
|
|
else
|
|
td.shift[1] = -pt->shift[1];
|
|
}
|
|
pt = &g_qeglobals.d_texturewin.texdef;
|
|
Patch_SetTextureInfo(&td);
|
|
}
|
|
else
|
|
{
|
|
GetTexMods ();
|
|
if (g_bNewFace && selected_face)
|
|
pt = &selected_face->texdef;
|
|
else
|
|
pt = &g_qeglobals.d_texturewin.texdef;
|
|
|
|
if (nID == IDC_SPIN_ROTATE)
|
|
{
|
|
if (bUp)
|
|
pt->rotate += 45;
|
|
else
|
|
pt->rotate -= 45;
|
|
|
|
if (pt->rotate < 0)
|
|
pt->rotate += 360;
|
|
|
|
if (pt->rotate >= 360)
|
|
pt->rotate -= 360;
|
|
}
|
|
else if (nID == IDC_SPIN_HSCALE)
|
|
{
|
|
if (bUp)
|
|
pt->scale[0] += 0.1;
|
|
else
|
|
pt->scale[0] -= 0.1;
|
|
}
|
|
else if (nID == IDC_SPIN_VSCALE)
|
|
{
|
|
if (bUp)
|
|
pt->scale[1] += 0.1;
|
|
else
|
|
pt->scale[1] -= 0.1;
|
|
}
|
|
|
|
else if (nID == IDC_SPIN_HSHIFT)
|
|
{
|
|
if (bUp)
|
|
pt->shift[0] += 8;
|
|
else
|
|
pt->shift[0] -= 8;
|
|
}
|
|
else if (nID == IDC_SPIN_VSHIFT)
|
|
{
|
|
if (bUp)
|
|
pt->shift[1] += 8;
|
|
else
|
|
pt->shift[1] -= 8;
|
|
}
|
|
}
|
|
|
|
SetTexMods();
|
|
g_changed_surface = true;
|
|
Select_SetTexture(pt);
|
|
}
|
|
|
|
void CSurfaceDlg::UpdateSpinners(int nScrollCode, int nPos, CScrollBar* pBar)
|
|
{
|
|
texdef_t *pt;
|
|
|
|
GetTexMods ();
|
|
if (g_bNewFace && selected_face)
|
|
pt = &selected_face->texdef;
|
|
else
|
|
pt = &g_qeglobals.d_texturewin.texdef;
|
|
|
|
if ((nScrollCode != SB_LINEUP) && (nScrollCode != SB_LINEDOWN))
|
|
return;
|
|
|
|
if (pBar->GetSafeHwnd() == ::GetDlgItem(GetSafeHwnd(), IDC_ROTATEA))
|
|
{
|
|
if (nScrollCode == SB_LINEUP)
|
|
pt->rotate += 45;
|
|
else
|
|
pt->rotate -= 45;
|
|
|
|
if (pt->rotate < 0)
|
|
pt->rotate += 360;
|
|
|
|
if (pt->rotate >= 360)
|
|
pt->rotate -= 360;
|
|
}
|
|
|
|
else if (pBar->GetSafeHwnd() == ::GetDlgItem(GetSafeHwnd(), IDC_HSCALEA))
|
|
{
|
|
if (nScrollCode == SB_LINEDOWN)
|
|
pt->scale[0] -= 0.1;
|
|
else
|
|
pt->scale[0] += 0.1;
|
|
}
|
|
|
|
else if (pBar->GetSafeHwnd() == ::GetDlgItem(GetSafeHwnd(), IDC_VSCALEA))
|
|
{
|
|
if (nScrollCode == SB_LINEUP)
|
|
pt->scale[1] += 0.1;
|
|
else
|
|
pt->scale[1] -= 0.1;
|
|
}
|
|
|
|
else if (pBar->GetSafeHwnd() == ::GetDlgItem(GetSafeHwnd(), IDC_HSHIFTA))
|
|
{
|
|
if (nScrollCode == SB_LINEDOWN)
|
|
pt->shift[0] -= 8;
|
|
else
|
|
pt->shift[0] += 8;
|
|
}
|
|
|
|
else if (pBar->GetSafeHwnd() == ::GetDlgItem(GetSafeHwnd(), IDC_VSHIFTA))
|
|
{
|
|
if (nScrollCode == SB_LINEUP)
|
|
pt->shift[1] += 8;
|
|
else
|
|
pt->shift[1] -= 8;
|
|
}
|
|
|
|
SetTexMods();
|
|
g_changed_surface = true;
|
|
Select_SetTexture(pt);
|
|
}
|
|
|
|
void UpdateSurfaceDialog()
|
|
{
|
|
if (g_surfwin)
|
|
g_dlgSurface.SetTexMods();
|
|
g_pParentWnd->UpdateTextureBar();
|
|
}
|
|
|
|
|
|
|
|
|
|
bool ByeByeSurfaceDialog();
|
|
|
|
|
|
|
|
void DoSurface (void)
|
|
{
|
|
g_bNewFace = g_PrefsDlg.m_bFace;
|
|
g_bNewApplyHandling = g_PrefsDlg.m_bNewApplyHandling;
|
|
g_bGatewayhack = g_PrefsDlg.m_bGatewayHack;
|
|
// save current state for cancel
|
|
g_old_texdef = g_qeglobals.d_texturewin.texdef;
|
|
g_changed_surface = false;
|
|
|
|
if (g_surfwin == NULL && g_dlgSurface.GetSafeHwnd() == NULL)
|
|
{
|
|
g_patch_texdef.scale[0] = 0.05;
|
|
g_patch_texdef.scale[1] = 0.05;
|
|
g_patch_texdef.shift[0] = 0.05;
|
|
g_patch_texdef.shift[1] = 0.05;
|
|
g_patch_texdef.rotate = 45;
|
|
|
|
g_dlgSurface.Create(IDD_SURFACE);
|
|
CRect rct;
|
|
LONG lSize = sizeof(rct);
|
|
if (LoadRegistryInfo("Radiant::SurfaceWindow", &rct, &lSize))
|
|
g_dlgSurface.SetWindowPos(NULL, rct.left, rct.top, 0,0, SWP_NOSIZE | SWP_SHOWWINDOW);
|
|
|
|
Sys_UpdateWindows(W_ALL);
|
|
}
|
|
else
|
|
{
|
|
g_surfwin = g_dlgSurface.GetSafeHwnd();
|
|
g_dlgSurface.SetTexMods ();
|
|
g_dlgSurface.ShowWindow(SW_SHOW);
|
|
}
|
|
}
|
|
|
|
bool ByeByeSurfaceDialog()
|
|
{
|
|
if (g_surfwin)
|
|
{
|
|
if (g_bGatewayhack)
|
|
PostMessage(g_surfwin, WM_COMMAND, IDAPPLY, 0);
|
|
else
|
|
PostMessage(g_surfwin, WM_COMMAND, IDCANCEL, 0);
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
|
|
BOOL CSurfaceDlg::OnInitDialog()
|
|
{
|
|
CDialog::OnInitDialog();
|
|
|
|
g_surfwin = GetSafeHwnd();
|
|
SetTexMods ();
|
|
|
|
// enable whichever one of these you think looks best...
|
|
//
|
|
//#define LOSE_MENU_ITEM(item) GetDlgItem(item)->EnableWindow(false); // grey the item
|
|
#define LOSE_MENU_ITEM(item) GetDlgItem(item)->DestroyWindow(); // remove it
|
|
|
|
|
|
#ifdef QUAKE3
|
|
GetDlgItem(IDC_CHECK32)->SetWindowText("Curve");
|
|
GetDlgItem(IDC_CHECK63)->SetWindowText("Inverted");
|
|
RECT Rect,Rect2;
|
|
GetWindowRect(&Rect);
|
|
GetDlgItem(IDC_STATIC_PATCHTEXTURING)->GetWindowRect(&Rect2);
|
|
SetWindowPos(&wndTopMost, Rect.left, Rect.top, 2*(Rect2.left-Rect.left) + (Rect2.right-Rect2.left), (Rect.bottom-Rect.top), SWP_NOCOPYBITS|SWP_NOMOVE);
|
|
#endif
|
|
|
|
m_wndHScale.SetRange(0, 1000);
|
|
m_wndVScale.SetRange(0, 1000);
|
|
m_wndHShift.SetRange(0, 1000);
|
|
m_wndVShift.SetRange(0, 1000);
|
|
m_wndRotate.SetRange(0, 1000);
|
|
m_wndWidth.SetRange(1, 5000);
|
|
m_wndHeight.SetRange(1, 5000);
|
|
|
|
LPVOID lpv = g_pParentWnd->GetPlugInMgr().GetSurfaceFlags();
|
|
if (lpv != NULL)
|
|
{
|
|
int i = 0;
|
|
char* p = reinterpret_cast<char*>(lpv);
|
|
char* pBuff = new char[strlen(p)+1];
|
|
strcpy(pBuff, p);
|
|
char* pToken = strtok(pBuff, ";\0");
|
|
while (pToken != NULL)
|
|
{
|
|
GetDlgItem(g_checkboxes[i++])->SetWindowText(pToken);
|
|
pToken = strtok(NULL, ";\0");
|
|
}
|
|
}
|
|
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
void CSurfaceDlg::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
|
|
{
|
|
CDialog::OnHScroll(nSBCode, nPos, pScrollBar);
|
|
UpdateSpinners(nSBCode, nPos, pScrollBar);
|
|
Sys_UpdateWindows(W_CAMERA);
|
|
}
|
|
|
|
void CSurfaceDlg::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
|
|
{
|
|
|
|
CDialog::OnKeyDown(nChar, nRepCnt, nFlags);
|
|
}
|
|
|
|
void CSurfaceDlg::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
|
|
{
|
|
CDialog::OnVScroll(nSBCode, nPos, pScrollBar);
|
|
UpdateSpinners(nSBCode, nPos, pScrollBar);
|
|
Sys_UpdateWindows(W_CAMERA);
|
|
}
|
|
|
|
void CSurfaceDlg::OnApply()
|
|
{
|
|
GetTexMods ();
|
|
Sys_UpdateWindows(W_CAMERA);
|
|
if (g_bNewApplyHandling)
|
|
OnOK();
|
|
}
|
|
|
|
void CSurfaceDlg::OnOK()
|
|
{
|
|
GetTexMods();
|
|
g_surfwin = NULL;
|
|
CDialog::OnOK();
|
|
Sys_UpdateWindows(W_ALL);
|
|
}
|
|
|
|
void CSurfaceDlg::OnClose()
|
|
{
|
|
g_surfwin = NULL;
|
|
CDialog::OnClose();
|
|
}
|
|
|
|
void CSurfaceDlg::OnCancel()
|
|
{
|
|
if (g_bGatewayhack)
|
|
OnOK();
|
|
else
|
|
OnBtnCancel();
|
|
}
|
|
|
|
void CSurfaceDlg::OnDestroy()
|
|
{
|
|
if (GetSafeHwnd())
|
|
{
|
|
CRect rct;
|
|
GetWindowRect(rct);
|
|
SaveRegistryInfo("Radiant::SurfaceWindow", &rct, sizeof(rct));
|
|
}
|
|
CDialog::OnDestroy();
|
|
g_surfwin = NULL;
|
|
Sys_UpdateWindows(W_ALL);
|
|
}
|
|
|
|
void CSurfaceDlg::OnBtnCancel()
|
|
{
|
|
g_qeglobals.d_texturewin.texdef = g_old_texdef;
|
|
if (g_changed_surface)
|
|
Select_SetTexture(&g_qeglobals.d_texturewin.texdef);
|
|
g_surfwin = NULL;
|
|
DestroyWindow();
|
|
}
|
|
|
|
void CSurfaceDlg::OnBtnColor()
|
|
{
|
|
}
|
|
|
|
HBRUSH CSurfaceDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
|
|
{
|
|
HBRUSH hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor);
|
|
return hbr;
|
|
}
|
|
|
|
int CSurfaceDlg::OnCreate(LPCREATESTRUCT lpCreateStruct)
|
|
{
|
|
if (CDialog::OnCreate(lpCreateStruct) == -1)
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
BOOL CSurfaceDlg::PreCreateWindow(CREATESTRUCT& cs)
|
|
{
|
|
// TODO: Add your specialized code here and/or call the base class
|
|
|
|
return CDialog::PreCreateWindow(cs);
|
|
}
|
|
|
|
|
|
void CSurfaceDlg::OnDeltaPosSpin(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
NM_UPDOWN* pNMUpDown = (NM_UPDOWN*)pNMHDR;
|
|
UpdateSpinners((pNMUpDown->iDelta > 0), pNMUpDown->hdr.idFrom);
|
|
*pResult = 0;
|
|
}
|
|
|
|
|
|
|
|
void CSurfaceDlg::OnBtnPatchdetails()
|
|
{
|
|
Patch_NaturalizeSelected(true);
|
|
Sys_UpdateWindows(W_ALL);
|
|
}
|
|
|
|
void CSurfaceDlg::OnBtnPatchnatural()
|
|
{
|
|
Patch_NaturalizeSelected();
|
|
Sys_UpdateWindows(W_ALL);
|
|
}
|
|
|
|
void CSurfaceDlg::OnBtnPatchreset()
|
|
{
|
|
CTextureLayout dlg;
|
|
if (dlg.DoModal() == IDOK)
|
|
{
|
|
Patch_ResetTexturing(dlg.m_fX, dlg.m_fY);
|
|
}
|
|
Sys_UpdateWindows(W_ALL);
|
|
}
|
|
|
|
void CSurfaceDlg::OnBtnPatchfit()
|
|
{
|
|
Patch_FitTexturing();
|
|
Sys_UpdateWindows(W_ALL);
|
|
}
|
|
|
|
void CSurfaceDlg::OnBtnAxial()
|
|
{
|
|
Select_SetTexture (&g_qeglobals.d_texturewin.texdef, true);
|
|
g_changed_surface = true;
|
|
SetTexMods();
|
|
Sys_UpdateWindows(W_ALL);
|
|
}
|
|
|
|
void FaceFit_Actual(int iWidth, int iHeight)
|
|
{
|
|
/* if (1)//selected_face == NULL)
|
|
{
|
|
brush_t *b;
|
|
for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
|
|
{
|
|
selected_face_brush = b;
|
|
for (face_t* pFace = b->brush_faces; pFace; pFace = pFace->next)
|
|
{
|
|
selected_face = pFace;
|
|
Select_FitTexture(m_nHeight, m_nWidth);
|
|
SetTexMods();
|
|
}
|
|
}
|
|
// selected_face = NULL;
|
|
}
|
|
// else
|
|
*/
|
|
Select_FitTexture(iHeight, iWidth);
|
|
}
|
|
|
|
|
|
// this is fucking crap. I can't use the ID version because their's doesn't work properly either, it seems to, but it
|
|
// has some bad side effects, so for now...
|
|
//
|
|
void CSurfaceDlg::OnBtnFacefit()
|
|
{
|
|
UpdateData(TRUE);
|
|
|
|
if (!selected_face)
|
|
{
|
|
ErrorBox("This only works when a face is selected, not a whole brush");
|
|
return;
|
|
}
|
|
|
|
FaceFit_Actual(m_nWidth, m_nHeight);
|
|
SetTexMods();
|
|
|
|
g_changed_surface = true;
|
|
Sys_UpdateWindows(W_ALL);
|
|
}
|
|
|
|
// so we can call the functionality of the FIT button from a hotkey without the dialog being up...
|
|
//
|
|
void FaceFit(void)
|
|
{
|
|
FaceFit_Actual(g_dlgSurface.m_nWidth, g_dlgSurface.m_nHeight);
|
|
g_dlgSurface.SetTexMods();
|
|
Sys_UpdateWindows(W_ALL);
|
|
}
|
|
|
|
|
|
void CSurfaceDlg::OnBtnFaceReset()
|
|
{
|
|
UpdateData(TRUE);
|
|
|
|
if (!selected_face)
|
|
{
|
|
ErrorBox("This only works when a face is selected, not a whole brush");
|
|
return;
|
|
}
|
|
|
|
/* if (selected_face == NULL)
|
|
{
|
|
brush_t *b;
|
|
for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
|
|
{
|
|
selected_face_brush = b;
|
|
for (face_t* pFace = b->brush_faces; pFace; pFace = pFace->next)
|
|
{
|
|
selected_face = pFace;
|
|
|
|
pFace->texdef.shift[0] =
|
|
pFace->texdef.shift[1] = 0.0f;
|
|
pFace->texdef.rotate = 0.0f;
|
|
pFace->texdef.scale[0] =
|
|
pFace->texdef.scale[1] = (g_PrefsDlg.m_bHiColorTextures) ? 0.5 : 1;
|
|
|
|
SetTexMods();
|
|
}
|
|
}
|
|
// selected_face = NULL;
|
|
}
|
|
// else
|
|
*/
|
|
if (selected_face)
|
|
{
|
|
face_t* pFace = selected_face;
|
|
|
|
pFace->texdef.shift[0] =
|
|
pFace->texdef.shift[1] = 0.0f;
|
|
pFace->texdef.rotate = 0.0f;
|
|
pFace->texdef.scale[0] =
|
|
pFace->texdef.scale[1] = (g_PrefsDlg.m_bHiColorTextures) ? fTEXTURE_SCALE : 1;
|
|
|
|
SetTexMods();
|
|
}
|
|
|
|
g_changed_surface = true;
|
|
OnApply();
|
|
}
|
|
|