id
/
quake3
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
quake3/q3radiant/SurfaceDlg.cpp

984 lines
25 KiB
C++
Executable File
Raw Permalink Blame History

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
This file is part of Quake III Arena source code.
Quake III Arena source code 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 2 of the License,
or (at your option) any later version.
Quake III Arena source code 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 Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
// SurfaceDlg.cpp : implementation file
//
#include "stdafx.h"
#include "Radiant.h"
#include "SurfaceDlg.h"
#include "PrefsDlg.h"
#include "mainfrm.h"
#include "TextureLayout.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// surface properties plugin
// global flag for surface properties plugin is g_qeglobals.bSurfacePropertiesPlugin
_QERPlugSurfaceTable g_SurfaceTable;
/////////////////////////////////////////////////////////////////////////////
// CSurfaceDlg dialog
CSurfaceDlg g_dlgSurface;
CSurfaceDlg::CSurfaceDlg(CWnd* pParent /*=NULL*/)
: CDialog(CSurfaceDlg::IDD, pParent)
{
//{{AFX_DATA_INIT(CSurfaceDlg)
m_nHeight = 1;
m_nWidth = 1;
//}}AFX_DATA_INIT
}
void CSurfaceDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CSurfaceDlg)
DDX_Control(pDX, IDC_SPIN_WIDTH, m_wndWidth);
DDX_Control(pDX, IDC_SPIN_HEIGHT, m_wndHeight);
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_HEIGHT, m_nHeight);
DDV_MinMaxInt(pDX, m_nHeight, 1, 32);
DDX_Text(pDX, IDC_EDIT_WIDTH, m_nWidth);
DDV_MinMaxInt(pDX, m_nWidth, 1, 32);
//}}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_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_AXIAL, OnBtnAxial)
ON_BN_CLICKED(IDC_BTN_BRUSHFIT, OnBtnBrushfit)
ON_BN_CLICKED(IDC_BTN_FACEFIT, OnBtnFacefit)
//}}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
};
/*
==============
SetTexMods
Set the fields to the current texdef
if one face selected -> will read this face texdef, else current texdef
if only patches selected, will read the patch texdef
===============
*/
bool g_bNewFace = false;
bool g_bNewApplyHandling = false;
bool g_bGatewayhack = false;
void CSurfaceDlg::SetTexMods()
{
char sz[128];
texdef_t *pt;
brushprimit_texdef_t *bpt;
// local copy if a width=2 height=2 qtetxture_t is needed
brushprimit_texdef_t local_bp;
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());
g_patch_texdef.SetName(Patch_GetTextureName());
}
else
{
//strcpy(g_patch_texdef.name, pt->name);
g_patch_texdef.SetName(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 && g_ptrSelectedFaces.GetSize() > 0)
{
face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(0));
pt = &selFace->texdef;
if (g_qeglobals.m_bBrushPrimitMode)
{
// compute a texture matrix related to the default matrix width=2 height=2
ConvertTexMatWithQTexture( &selFace->brushprimit_texdef, selFace->d_texture, &local_bp, NULL );
bpt = &local_bp;
}
}
else
{
pt = &g_qeglobals.d_texturewin.texdef;
if (g_qeglobals.m_bBrushPrimitMode)
{
bpt = &g_qeglobals.d_texturewin.brushprimit_texdef;
}
}
// brush primitive mode : compute fake shift scale rot representation
if (g_qeglobals.m_bBrushPrimitMode)
TexMatToFakeTexCoords( bpt->coords, m_shift, &m_rotate, m_scale );
}
SendMessage (WM_SETREDRAW, 0, 0);
::SetWindowText(GetDlgItem(IDC_TEXTURE)->GetSafeHwnd(), pt->name);
if (m_bPatchMode)
sprintf(sz, "%4.6f", pt->shift[0]);
else
if (g_qeglobals.m_bBrushPrimitMode)
sprintf(sz, "%d", (int)m_shift[0]);
else
sprintf(sz, "%d", (int)pt->shift[0]);
::SetWindowText(GetDlgItem(IDC_HSHIFT)->GetSafeHwnd(), sz);
if (m_bPatchMode)
sprintf(sz, "%4.6f", pt->shift[1]);
else
if (g_qeglobals.m_bBrushPrimitMode)
sprintf(sz, "%d", (int)m_shift[1]);
else
sprintf(sz, "%d", (int)pt->shift[1]);
::SetWindowText(GetDlgItem(IDC_VSHIFT)->GetSafeHwnd(), sz);
sprintf(sz, m_bPatchMode ? "%4.6f" : "%4.6f", g_qeglobals.m_bBrushPrimitMode ? m_scale[0] : pt->scale[0]);
::SetWindowText(GetDlgItem(IDC_HSCALE)->GetSafeHwnd(), sz);
sprintf(sz, m_bPatchMode ? "%4.6f" : "%4.6f", g_qeglobals.m_bBrushPrimitMode ? m_scale[1] : pt->scale[1]);
::SetWindowText(GetDlgItem(IDC_VSCALE)->GetSafeHwnd(), sz);
//++timo compute BProtate as int ..
sprintf(sz, "%d", g_qeglobals.m_bBrushPrimitMode ? (int)m_rotate : (int)pt->rotate);
::SetWindowText(GetDlgItem(IDC_ROTATE)->GetSafeHwnd(), sz);
sprintf(sz, "%d", (int)pt->value);
::SetWindowText(GetDlgItem(IDC_VALUE)->GetSafeHwnd(), sz);
for (i=0 ; i<32 ; i++)
::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);
pt->flags = 0;
for (i=0 ; i<32 ; i++)
{
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
in brush primitive mode, grab the fake shift scale rot and compute a new texture matrix
===============
*/
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 && g_ptrSelectedFaces.GetSize() > 0)
{
face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(0));
pt = &selFace->texdef;
}
else
{
pt = &g_qeglobals.d_texturewin.texdef;
}
}
::GetWindowText (GetDlgItem(IDC_TEXTURE)->GetSafeHwnd(), sz, 127);
//strncpy (pt->name, sz, sizeof(pt->name)-1);
pt->SetName(sz);
if (pt->name[0] <= ' ')
{
//strcpy (pt->name, "none");
pt->SetName("none");
::SetWindowText(GetDlgItem(IDC_TEXTURE)->GetSafeHwnd(), pt->name);
}
::GetWindowText (GetDlgItem(IDC_HSHIFT)->GetSafeHwnd(), sz, 127);
( g_qeglobals.m_bBrushPrimitMode ? m_shift[0] : pt->shift[0] ) = atof(sz);
::GetWindowText (GetDlgItem(IDC_VSHIFT)->GetSafeHwnd(), sz, 127);
( g_qeglobals.m_bBrushPrimitMode ? m_shift[1] : pt->shift[1] ) = atof(sz);
::GetWindowText(GetDlgItem(IDC_HSCALE)->GetSafeHwnd(), sz, 127);
( g_qeglobals.m_bBrushPrimitMode ? m_scale[0] : pt->scale[0] ) = atof(sz);
::GetWindowText(GetDlgItem(IDC_VSCALE)->GetSafeHwnd(), sz, 127);
( g_qeglobals.m_bBrushPrimitMode ? m_scale[1] : pt->scale[1] ) = atof(sz);
::GetWindowText(GetDlgItem(IDC_ROTATE)->GetSafeHwnd(), sz, 127);
( g_qeglobals.m_bBrushPrimitMode ? m_rotate : pt->rotate ) = atof(sz);
::GetWindowText(GetDlgItem(IDC_VALUE)->GetSafeHwnd(), sz, 127);
pt->value = atof(sz);
pt->flags = 0;
for (i=0 ; i<32 ; i++)
{
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;
}
g_changed_surface = true;
// a local copy of the texture matrix, given for a qtexture_t with width=2 height=2
brushprimit_texdef_t local_bp;
brushprimit_texdef_t *bpt;
if (g_qeglobals.m_bBrushPrimitMode)
{
face_t *selFace = NULL;
if (g_bNewFace && g_ptrSelectedFaces.GetSize() > 0)
{
selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(0));
bpt = &selFace->brushprimit_texdef;
}
else
{
bpt = &g_qeglobals.d_texturewin.brushprimit_texdef;
}
// compute texture matrix
// the matrix returned must be understood as a qtexture_t with width=2 height=2
FakeTexCoordsToTexMat( m_shift, m_rotate, m_scale, local_bp.coords );
// copy the texture matrix in the global struct
// fit the qtexture if we have a face selected, otherwise g_qeglobals.d_texturewin.brushprimit_texdef uses the basic qtexture_t with width=2 height=2
ConvertTexMatWithQTexture( &local_bp, NULL, bpt, ( ( g_bNewFace && selFace ) ? selFace->d_texture : NULL ) );
}
Select_SetTexture(pt,&local_bp);
//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
{
// in brush primitive mode, will read up-to-date m_shift m_rotate m_scale
GetTexMods ();
if (g_bNewFace && g_ptrSelectedFaces.GetSize() > 0)
{
face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(0));
pt = &selFace->texdef;
}
else
{
pt = &g_qeglobals.d_texturewin.texdef;
}
if (nID == IDC_SPIN_ROTATE)
{
if (g_qeglobals.m_bBrushPrimitMode)
{
if (bUp)
m_rotate += 45;
else
m_rotate -= 45;
}
else
{
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 (g_qeglobals.m_bBrushPrimitMode)
{
if (bUp)
m_scale[0] += 0.1;
else
m_scale[0] -= 0.1;
}
else
{
if (bUp)
pt->scale[0] += 0.1;
else
pt->scale[0] -= 0.1;
}
}
else if (nID == IDC_SPIN_VSCALE)
{
if (g_qeglobals.m_bBrushPrimitMode)
{
if (bUp)
m_scale[1] += 0.1;
else
m_scale[1] -= 0.1;
}
else
{
if (bUp)
pt->scale[1] += 0.1;
else
pt->scale[1] -= 0.1;
}
}
else if (nID == IDC_SPIN_HSHIFT)
{
if (g_qeglobals.m_bBrushPrimitMode)
{
if (bUp)
m_shift[0] += 8;
else
m_shift[0] -= 8;
}
else
{
if (bUp)
pt->shift[0] += 8;
else
pt->shift[0] -= 8;
}
}
else if (nID == IDC_SPIN_VSHIFT)
{
if (g_qeglobals.m_bBrushPrimitMode)
{
if (bUp)
m_shift[1] += 8;
else
m_shift[1] -= 8;
}
else
{
if (bUp)
pt->shift[1] += 8;
else
pt->shift[1] -= 8;
}
}
}
// a local copy of the texture matrix, given for a qtexture_t with width=2 height=2
brushprimit_texdef_t local_bp;
brushprimit_texdef_t *bpt;
if (g_qeglobals.m_bBrushPrimitMode)
{
face_t *selFace = NULL;
if (g_bNewFace && g_ptrSelectedFaces.GetSize() > 0)
{
selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(0));
bpt = &selFace->brushprimit_texdef;
}
else
{
bpt = &g_qeglobals.d_texturewin.brushprimit_texdef;
}
// compute texture matrix
// the matrix returned must be understood as a qtexture_t with width=2 height=2
FakeTexCoordsToTexMat( m_shift, m_rotate, m_scale, local_bp.coords );
// copy the texture matrix in the global struct
// fit the qtexture if we have a face selected, otherwise g_qeglobals.d_texturewin.brushprimit_texdef uses the basic qtexture_t with width=2 height=2
ConvertTexMatWithQTexture( &local_bp, NULL, bpt, ( ( g_bNewFace && selFace ) ? selFace->d_texture : NULL ) );
}
// brush primit : will update the widgets after reading back texture matrix and computing fake shift scale rot
SetTexMods();
g_changed_surface = true;
Select_SetTexture(pt,&local_bp);
}
void CSurfaceDlg::UpdateSpinners(int nScrollCode, int nPos, CScrollBar* pBar)
{
texdef_t *pt;
GetTexMods ();
if (g_bNewFace && g_ptrSelectedFaces.GetSize() > 0)
{
face_t *selFace = reinterpret_cast<face_t*>(g_ptrSelectedFaces.GetAt(0));
pt = &selFace->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;
//++timo if !g_qeglobals.m_bBrushPrimitMode send a NULL brushprimit_texdef
if (!g_qeglobals.m_bBrushPrimitMode)
{
Sys_Printf("Warning : non brush primitive mode call to CSurfaceDlg::GetTexMods broken\n");
Sys_Printf(" ( Select_SetTexture not called )\n");
}
// Select_SetTexture(pt);
}
void UpdateSurfaceDialog()
{
if (g_qeglobals.bSurfacePropertiesPlugin)
{
g_SurfaceTable.m_pfnUpdateSurfaceDialog();
}
else
{
if (g_surfwin)
g_dlgSurface.SetTexMods();
}
g_pParentWnd->UpdateTextureBar();
}
bool ByeByeSurfaceDialog();
void DoSurface (void)
{
// surface properties plugin ?
if (g_qeglobals.bSurfacePropertiesPlugin)
{
g_SurfaceTable.m_pfnDoSurface();
return;
}
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;
// use rotation increment from preferences
g_patch_texdef.rotate = g_PrefsDlg.m_nRotation;
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()
{
// surface properties plugin ?
if (g_qeglobals.bSurfacePropertiesPlugin)
{
return g_SurfaceTable.m_pfnByeByeSurfaceDialog();
}
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 ();
#ifdef QUAKE3
GetDlgItem(IDC_CHECK32)->SetWindowText("Curve");
GetDlgItem(IDC_CHECK64)->SetWindowText("Inverted");
#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, 32);
m_wndHeight.SetRange(1, 32);
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");
}
}
if (strstr(g_PrefsDlg.m_strWhatGame, "Quake3") != NULL) {
for (int i=0 ; i < 64 ; i++) {
::EnableWindow(GetDlgItem(g_checkboxes[i])->GetSafeHwnd(), FALSE);
}
}
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)
{
//++timo if !g_qeglobals.m_bBrushPrimitMode send a NULL brushprimit_texdef
if (!g_qeglobals.m_bBrushPrimitMode)
{
Sys_Printf("Warning : non brush primitive mode call to CSurfaceDlg::GetTexMods broken\n");
Sys_Printf(" ( Select_SetTexture not called )\n");
}
// 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, &g_qeglobals.d_texturewin.brushprimit_texdef, true);
g_changed_surface = true;
SetTexMods();
Sys_UpdateWindows(W_ALL);
}
void CSurfaceDlg::OnBtnBrushfit()
{
// TODO: Add your control notification handler code here
}
void CSurfaceDlg::OnBtnFacefit()
{
UpdateData(TRUE);
if (g_ptrSelectedFaces.GetSize() == 0)
{
brush_t *b;
for (b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
{
for (face_t* pFace = b->brush_faces; pFace; pFace = pFace->next)
{
g_ptrSelectedFaces.Add(pFace);
g_ptrSelectedFaceBrushes.Add(b);
}
}
}
Select_FitTexture(m_nHeight, m_nWidth);
SetTexMods();
g_changed_surface = true;
Sys_UpdateWindows(W_ALL);
}
Reference in New Issue View Git Blame Copy Permalink