ubergames/md3view
0
0
Fork 0
mirror of https://github.com/UberGames/MD3View.git synced 2024-11-25 05:31:46 +00:00
Code Issues Projects Releases Packages Wiki Activity
md3view/win32_msg.cpp
Tim Oliver 3efaa62d80 Hello World!
2011-12-05 20:41:28 +08:00

1649 lines
No EOL
40 KiB
C++
Executable file
Raw Blame History

/*
Copyright (C) 2010 Matthew Baranowski, Sander van Rossen & Raven software.
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/>.
*/
#ifdef WIN32
#include "system.h"
#include "ndictionary.h"
#include "md3gl.h"
#include "md3view.h"
#include "Resource.h"
#include "AFXRES.H"
#include "text.h"
#include "oddbits.h"
#include "animation.h"
#include "bmp.h"
#include "clipboard.h"
extern HINSTANCE WinhInstance;
extern NodeSequenceInfo tagMenuList;
HDC hDC_;
bool sys_rbuttondown = false;
bool sys_lbuttondown = false;
bool sys_mbuttondown = false;
OPENFILENAME *FileOpenDialog(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl, int type);
OPENFILENAME *FileSaveDialog(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl, int type);
/*
selects a 16 bit color file format, could be higher though it wouldn't work with a voodoo
*/
void SetPixelFormat( HDC hdc)
{
PIXELFORMATDESCRIPTOR pfd, *ppfd;
int pixelformat;
ppfd = &pfd;
memset(ppfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
ppfd->nVersion = 1;
ppfd->dwFlags = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
ppfd->dwLayerMask = PFD_MAIN_PLANE;
ppfd->iPixelType = PFD_TYPE_RGBA;
ppfd->cColorBits = 16;
ppfd->cDepthBits = 16;
ppfd->cAccumBits = 0;
ppfd->cStencilBits = 0;
pixelformat = ChoosePixelFormat( hdc, ppfd);
if ( pixelformat == 0) {
Error("ChoosePixelFormat failed");
}
if (ppfd->dwFlags & PFD_NEED_PALETTE) {
Error ("ChoosePixelFormat needs palette" );
}
if (SetPixelFormat( hdc, pixelformat, ppfd) == FALSE) {
Error("SetPixelFormat failed");
}
}
/*
** ChoosePFD
**
** Helper function that replaces ChoosePixelFormat.
*/
#define MAX_PFDS 256
static int GLW_ChoosePFD( HDC hDC, PIXELFORMATDESCRIPTOR *pPFD )
{
PIXELFORMATDESCRIPTOR pfds[MAX_PFDS+1];
int maxPFD = 0;
int i;
int bestMatch = 0;
OutputDebugString( va("...GLW_ChoosePFD( %d, %d, %d )\n", ( int ) pPFD->cColorBits, ( int ) pPFD->cDepthBits, ( int ) pPFD->cStencilBits) );
// count number of PFDs
//
maxPFD = DescribePixelFormat( hDC, 1, sizeof( PIXELFORMATDESCRIPTOR ), &pfds[0] );
if ( maxPFD > MAX_PFDS )
{
OutputDebugString( va( "...numPFDs > MAX_PFDS (%d > %d)\n", maxPFD, MAX_PFDS) );
maxPFD = MAX_PFDS;
}
OutputDebugString( va("...%d PFDs found\n", maxPFD - 1) );
FILE *handle = fopen("MD3View_GL_report.txt","wt");
fprintf(handle,"Total PFDs: %d\n\n",maxPFD);
// grab information
for ( i = 1; i <= maxPFD; i++ )
{
DescribePixelFormat( hDC, i, sizeof( PIXELFORMATDESCRIPTOR ), &pfds[i] );
fprintf(handle,"PFD %d/%d\n",i,maxPFD);
fprintf(handle,"=========\n");
#define FLAGDUMP(flag) if ( (pfds[i].dwFlags & flag ) != 0 ) fprintf(handle,"(flag: %s)\n",#flag);
FLAGDUMP( PFD_DOUBLEBUFFER );
FLAGDUMP( PFD_STEREO );
FLAGDUMP( PFD_DRAW_TO_WINDOW );
FLAGDUMP( PFD_DRAW_TO_BITMAP );
FLAGDUMP( PFD_SUPPORT_GDI );
FLAGDUMP( PFD_SUPPORT_OPENGL );
FLAGDUMP( PFD_GENERIC_FORMAT );
FLAGDUMP( PFD_NEED_PALETTE );
FLAGDUMP( PFD_NEED_SYSTEM_PALETTE );
FLAGDUMP( PFD_SWAP_EXCHANGE );
FLAGDUMP( PFD_SWAP_COPY );
FLAGDUMP( PFD_SWAP_LAYER_BUFFERS );
FLAGDUMP( PFD_GENERIC_ACCELERATED );
FLAGDUMP( PFD_SUPPORT_DIRECTDRAW );
if ( pfds[i].iPixelType == PFD_TYPE_RGBA )
{
// fprintf(handle,"RGBA mode\n");
}
else
{
fprintf(handle,"NOT RGBA mode!!!!!!!!!!!!\n");
}
fprintf(handle, "Colour bits: %d\n",pfds[i].cColorBits);
fprintf(handle, "Depth bits: %d\n",pfds[i].cDepthBits);
fprintf(handle,"\n");
}
// look for a best match
for ( i = 1; i <= maxPFD; i++ )
{
fprintf(handle,"(bestMatch: %d)\n",bestMatch );
//
// make sure this has hardware acceleration
//
if ( ( pfds[i].dwFlags & PFD_GENERIC_FORMAT ) != 0 )
{
// if ( !r_allowSoftwareGL->integer )
{
// if ( r_verbose->integer )
{
fprintf(handle,//OutputDebugString(
va ("...PFD %d rejected, software acceleration\n", i ));
}
continue;
}
}
// verify pixel type
if ( pfds[i].iPixelType != PFD_TYPE_RGBA )
{
// if ( r_verbose->integer )
{
fprintf(handle,//OutputDebugString(
va("...PFD %d rejected, not RGBA\n", i) );
}
continue;
}
// verify proper flags
if ( ( ( pfds[i].dwFlags & pPFD->dwFlags ) & pPFD->dwFlags ) != pPFD->dwFlags )
{
// if ( r_verbose->integer )
{
fprintf(handle,//OutputDebugString(
va("...PFD %d rejected, improper flags (0x%x instead of 0x%x)\n", i, pfds[i].dwFlags, pPFD->dwFlags) );
}
continue;
}
// verify enough bits
if ( pfds[i].cDepthBits < 15 )
{
fprintf(handle,va("...PFD %d rejected, depth bits only %d (<15)\n", i, pfds[i].cDepthBits) );
continue;
}
/* if ( ( pfds[i].cStencilBits < 4 ) && ( pPFD->cStencilBits > 0 ) )
{
continue;
}
*/
//
// selection criteria (in order of priority):
//
// PFD_STEREO
// colorBits
// depthBits
// stencilBits
//
if ( bestMatch )
{
/*
// check stereo
if ( ( pfds[i].dwFlags & PFD_STEREO ) && ( !( pfds[bestMatch].dwFlags & PFD_STEREO ) ) && ( pPFD->dwFlags & PFD_STEREO ) )
{
bestMatch = i;
continue;
}
if ( !( pfds[i].dwFlags & PFD_STEREO ) && ( pfds[bestMatch].dwFlags & PFD_STEREO ) && ( pPFD->dwFlags & PFD_STEREO ) )
{
bestMatch = i;
continue;
}
*/
// check color
if ( pfds[bestMatch].cColorBits != pPFD->cColorBits )
{
// prefer perfect match
if ( pfds[i].cColorBits == pPFD->cColorBits )
{
bestMatch = i;
continue;
}
// otherwise if this PFD has more bits than our best, use it
else if ( pfds[i].cColorBits > pfds[bestMatch].cColorBits )
{
bestMatch = i;
continue;
}
}
// check depth
if ( pfds[bestMatch].cDepthBits != pPFD->cDepthBits )
{
// prefer perfect match
if ( pfds[i].cDepthBits == pPFD->cDepthBits )
{
bestMatch = i;
continue;
}
// otherwise if this PFD has more bits than our best, use it
else if ( pfds[i].cDepthBits > pfds[bestMatch].cDepthBits )
{
bestMatch = i;
continue;
}
}
/*
// check stencil
if ( pfds[bestMatch].cStencilBits != pPFD->cStencilBits )
{
// prefer perfect match
if ( pfds[i].cStencilBits == pPFD->cStencilBits )
{
bestMatch = i;
continue;
}
// otherwise if this PFD has more bits than our best, use it
else if ( ( pfds[i].cStencilBits > pfds[bestMatch].cStencilBits ) &&
( pPFD->cStencilBits > 0 ) )
{
bestMatch = i;
continue;
}
}
*/
}
else
{
bestMatch = i;
}
}
fprintf(handle,"Bestmode: %d\n",bestMatch);
if ( !bestMatch )
{
fprintf(handle,"No decent mode found!\n");
fclose(handle);
return 0;
}
if ( ( pfds[bestMatch].dwFlags & PFD_GENERIC_FORMAT ) != 0 )
{
// if ( !r_allowSoftwareGL->integer )
// {
// ri.Printf( PRINT_ALL, "...no hardware acceleration found\n" );
// return 0;
// }
// else
{
fprintf(handle,//OutputDebugString(
"...using software emulation\n" );
}
}
else if ( pfds[bestMatch].dwFlags & PFD_GENERIC_ACCELERATED )
{
fprintf(handle,//OutputDebugString(
"...MCD acceleration found\n" );
}
else
{
fprintf(handle,//OutputDebugString(
"...hardware acceleration found\n" );
}
*pPFD = pfds[bestMatch];
fclose(handle);
return bestMatch;
}
/*
creates an OpenGL rendering context and makes it current
*/
void InitOpenGL( HWND hwnd )
{
HDC hdc = GetDC( hwnd );
mdview.hdc = hdc;
static PIXELFORMATDESCRIPTOR pfd =
{
sizeof(PIXELFORMATDESCRIPTOR), // WORD nSize;
1, // WORD nVersion;
PFD_DRAW_TO_WINDOW | // DWORD dwFlags;
PFD_DOUBLEBUFFER | //
PFD_SUPPORT_OPENGL, //
PFD_TYPE_RGBA, // BYTE iPixelType;
24, // BYTE cColorBits;
// not used to select mode...
//
0, // BYTE cRedBits;
0, // BYTE cRedShift;
0, // BYTE cGreenBits;
0, // BYTE cGreenShift;
0, // BYTE cBlueBits;
0, // BYTE cBlueShift;
0, // BYTE cAlphaBits;
0, // BYTE cAlphaShift;
0, // BYTE cAccumBits;
0, // BYTE cAccumRedBits;
0, // BYTE cAccumGreenBits;
0, // BYTE cAccumBlueBits;
0, // BYTE cAccumAlphaBits;
32,//24, // BYTE cDepthBits;
// not used to select mode...
0, // BYTE cStencilBits;
0, // BYTE cAuxBuffers;
PFD_MAIN_PLANE, // BYTE iLayerType;
// not used to select mode...
0, // BYTE bReserved;
0, // DWORD dwLayerMask;
0, // DWORD dwVisibleMask;
0 // DWORD dwDamageMask;
};
/*
// choose a pixel format that best matches the one we want...
//
int iPixelFormat = ChoosePixelFormat(hdc,&pfd);
//
// set the pixel format for this device context...
//
*/
int iPixelFormat = GLW_ChoosePFD( hdc, &pfd );
VERIFY(SetPixelFormat(hdc, iPixelFormat, &pfd));
// SetPixelFormat( hdc );
HGLRC glrc = wglCreateContext( hdc );
mdview.glrc = glrc;
if ( glrc == NULL) {
Error("Failed on wglCreateContext( HDC hdc )");
}
if (!wglMakeCurrent( hdc, glrc)) {
Error("Failed on wglMakeCurrent(..)" );
}
}
bool gbMinimised = false;
/*
called every pass of the event loop
*/
void SysOnIdle()
{
// OutputDebugString("Idle\n");
if (!gbMinimised)
{
animation_loop();
}
else
{
Sleep(0);
}
}
/*
renders the model with simple viewing parameters
*/
void SysOnPaint( HWND hwnd, bool bFlip /* = true */ )
{
if (!gbMinimised)
{
PAINTSTRUCT ps;
BeginPaint(hwnd, &ps);
wglMakeCurrent( mdview.hdc, mdview.glrc );
render_mdview();
if (bFlip)
{
HDC hDC = GetDC(hwnd);
SwapBuffers( hDC );
ReleaseDC(hwnd,hDC);
}
EndPaint(hwnd, &ps);
}
}
/*
notifies md3view of resize event
*/
void SysOnSize(HWND hwnd, UINT state, int cx, int cy)
{
RECT rect;
GetClientRect( hwnd, &rect );
set_windowSize( rect.right, rect.bottom );
g_iScreenWidth = rect.right - rect.left;
g_iScreenHeight= rect.bottom- rect.top;
gbMinimised = (state == SIZE_MINIMIZED);
InvalidateRect( hwnd, NULL, FALSE );
}
/*
sets quit parameter to break out of the message loop
*/
int SysOnDestroy(HWND hWnd)
{
Text_Destroy(); // while GL context still valid
if (mdview.glrc)
{
wglDeleteContext( mdview.glrc );
mdview.glrc = NULL;
}
if (mdview.hdc)
{
ReleaseDC(mdview.hwnd,mdview.hdc);
mdview.hdc = NULL;
}
extern void FakeCvars_Shutdown(void);
FakeCvars_Shutdown();
mdview.done = true;
return 0;
}
/*
passes control to drag.cpp drag function
*/
POINT DragStartPoint;
void SysOnMouseMove(HWND hwnd, int x, int y, UINT keyFlags)
{
POINT point;
GetCursorPos(&point);
if (!(sys_rbuttondown || sys_lbuttondown || sys_mbuttondown))
{
//ScreenToClient(&point);
return;
}
if (drag( (mkey_enum)keyFlags, point.x, point.y ))
{
SetCursorPos(DragStartPoint.x,DragStartPoint.y);
}
}
/*
releases and shows the cursor again
*/
void SysOnRButtonUp(HWND hwnd, int x, int y, UINT flags)
{
if (!sys_rbuttondown) return;
ReleaseCapture();
ShowCursor( true );
end_drag( (mkey_enum)flags, x, y );
sys_rbuttondown = false;
}
/*
same as above
*/
void SysOnLButtonUp(HWND hwnd, int x, int y, UINT flags)
{
if (!sys_lbuttondown) return;
ReleaseCapture();
ShowCursor( true );
end_drag( (mkey_enum)flags, x, y );
sys_lbuttondown = false;
}
/*
on mouse down, hide the cursor and capture it to window
*/
void SysOnRButtonDown(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags)
{
GetCursorPos(&DragStartPoint);
start_drag( (mkey_enum)keyFlags, DragStartPoint.x, DragStartPoint.y );
SetCapture( hwnd );
ShowCursor( false );
sys_rbuttondown = true;
}
/*
*/
void SysOnLButtonDown(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags)
{
GetCursorPos(&DragStartPoint);
start_drag( (mkey_enum)keyFlags, DragStartPoint.x, DragStartPoint.y );
SetCapture( hwnd );
ShowCursor( false );
sys_lbuttondown = true;
}
/*
processes command issued from the tag menu
*/
// I've added an extra param to this call, it won't affect anyone else if you pass NULL as that param,
// this involved a slight change below, but it's safe -slc
//
void SysOnTagCommand( HWND hwnd, int id, HWND hwndCtl, UINT codeNotify, char *psFullFilenameToUseInstead )
{
int i = 0, tagID = id - ID_TAG_START;
NodePosition pos;
GLMODEL_DBLPTR dblptr;
for (pos=tagMenuList.first() ; pos!=NULL ; pos=tagMenuList.after(pos)) {
if (i == tagID) break;
i++;
}
#ifdef DEBUG_PARANOID
if (pos==NULL) Debug("tagMenuList entry not found");
#endif
dblptr = (GLMODEL_DBLPTR)pos->element();
char fullName[256]={0};
OPENFILENAME *ofn=NULL;
if (psFullFilenameToUseInstead)
{
strcpy(fullName,psFullFilenameToUseInstead);
}
else
{
ofn = FileOpenDialog(hwnd, id, codeNotify, hwndCtl, IDS_FILESTRING );
if (ofn)
{
strcpy( fullName, ofn->lpstrFile );
strcat( fullName, ofn->lpstrFileTitle );
}
}
if (strlen(fullName))
{
if (dblptr != 0) freemdl_fromtag(dblptr);
loadmdl_totag( fullName, dblptr );
InvalidateRect( hwnd, NULL, FALSE );
//leave this here!! without the screen doesn't
//refresh properly sometimes!!
InvalidateRect( mdview.hwnd, NULL, FALSE );
if (ofn)
free( ofn );
}
else
{
if (dblptr != 0)
{
freemdl_fromtag( dblptr );
}
}
}
// we get here when the user selects one of the anim sequences on the new pulldown menus...
//
void SysOnAnimsCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
{
// OutputDebugString(va("Menu item code %d\n",id));
if (id < ID_MENUITEMS_LOWERANIMS)
{
// upper anim clicked on...
//
int iSelection = id-ID_MENUITEMS_UPPERANIMS;
// 0 = choose seq
// 1 = choose multi-seq
// 2 = none
// 3 = 1st seq
// 4 = 2nd seq etc...
switch (iSelection)
{
case 0: // choose seq
case 1: // choose multi-seq
ErrorBox("Ignore this for now");
iAnimLockNumber_Upper = 0; // xxxxxxxxxxxxxxxxxxxxx for now...
break;
default:
iAnimLockNumber_Upper = iSelection-2;
break;
}
}
else
{
// lower anim clicked on...
//
int iSelection = id-ID_MENUITEMS_LOWERANIMS;
// 0 = choose seq
// 1 = choose multi-seq
// 2 = none
// 3 = 1st seq
// 4 = 2nd seq etc...
switch (iSelection)
{
case 0: // choose seq
case 1: // choose multi-seq
ErrorBox("Ignore this for now");
iAnimLockNumber_Lower = 0; // xxxxxxxxxxxxxxxxxxxxx for now...
break;
default:
iAnimLockNumber_Lower = iSelection-2;
break;
}
}
}
#if 0
// takes (eg) "q:\quake\baseq3\textures\borg\name.tga"
//
// and produces "q:\quake\baseq3\" // note the trailing backslash, for this app only!!!!!!!!!!!!!!!!!!!!
//
// (copied from ShaderEd, but this app doesn't have MFC, so no CStrings...)
//
LPCSTR Filename_QUAKEBASEONLY(LPCSTR psFullPathedName /* CString &string */)
{
static char sLine[1024];
char *p;
strcpy(sLine,psFullPathedName);
while ((p=strchr(sLine,'/'))!=0) *p='\\'; // string.Replace("/","\\");
strlwr(sLine); // string.MakeLower();
/* int loc = string.Find("\\quake");
if (loc>=0)
{
loc = string.Find("\\",loc+1); // pointing at "\\baseq3" (or "demoq3" etc)
if (loc>=0)
{
loc = string.Find("\\",loc+1); // pointing at first part of string past the quake dir stuff
string = string.Left(loc);
}
}
*/
p = strstr(sLine,"\\quake");
if (p)
{
p = strstr(p+1,"\\"); // pointing at "\\baseq3" (or "demoq3" etc)
if (p)
{
p = p = strstr(p+1,"\\"); // pointing at first part of string past the quake dir stuff
*(p+1)=0; // +1 ensures trailing slash is left on as well
}
}
return sLine;
}
#endif
#define BASEDIRNAME "base"
char qdir[1024];
char gamedir[1024]; // q:\quake\baseef
// totally hacky and awful code pasted from other bits of crud
LPCSTR Filename_QUAKEBASEONLY(LPCSTR psFullPathedName )
{
static char sLine[1024];
char temp[1024];
char *path = temp;
const char *c;
const char *sep;
int len, count;
sLine[0]=0;
strcpy(path,psFullPathedName);
_strlwr(path);
// search for "base" in path from the RIGHT hand side (and must have a [back]slash just before it)
len = strlen(BASEDIRNAME);
for (c=path+strlen(path)-1 ; c != path ; c--)
{
// int i;
if (!strnicmp (c, BASEDIRNAME, len)
&&
(*(c-1) == '/' || *(c-1) == '\\') // would be more efficient to do this first, but only checking after a strncasecmp ok ensures no invalid pointer-1 access
)
{
sep = c + len;
count = 1;
while (*sep && *sep != '/' && *sep != '\\')
{
sep++;
count++;
}
strncpy (gamedir, path, c+len+count-path);
gamedir[c+len+count-path]=0;
strncpy (qdir, path, c-path);
qdir[c-path] = 0;
}
}
strcpy(sLine,gamedir);
while ((path=strchr(sLine,'/'))!=NULL) *path='\\';
return sLine;
}
bool ExportThisModel( LPCSTR psFilename, gl_model* pModel, bool bExportAsMD3);
bool R_ExportModel( gl_model* pModel, bool bMD3)
{
bool bReturn = true;
if (pModel)
{
OutputDebugString(va("Exporting model \"%s\"\n",pModel->sMDXFullPathname));
// export this model...
//
ExportThisModel( va("%s%s",Filename_WithoutExt(pModel->sMDXFullPathname), bMD3?".md3":".glm"), pModel, bMD3 );
// export its children...
//
for (UINT j=0; j<pModel->iNumTags ; j++)
{
gl_model *pChild = pModel->linkedModels[j];
if (pChild)
{
if (!R_ExportModel(pChild, bMD3))
{
bReturn = false;
}
}
}
}
return bReturn;
}
void ExportMD3(void)
{
if (GetYesNo("Export as MD3, are you sure?"))
{
if (!R_ExportModel( mdview.baseModel, true ))
{
ErrorBox("Errors occured, unable to export as MD3!");
}
else
{
ExportThisModel( NULL, NULL, true); // bool bExportAsMD3
}
}
}
bool g_bPerfect = false;
void ExportG2(bool bPerfect)
{
g_bPerfect = bPerfect;
if ( mdview.baseModel )
{
if (GetYesNo(va("Export as Ghoul2 .GLM/.GLA files%s, are you sure?",bPerfect?" ( *without* 90-degree skew )":"")))
{
if (!R_ExportModel( mdview.baseModel, false ))
{
ErrorBox("Errors occured, unable to export as Ghoul2!");
}
else
{
ExportThisModel( NULL, NULL, false); // bool bExportAsMD3
}
}
}
else
{
ErrorBox( "No model loaded!");
}
}
/*
processes events from the menu
*/
void SysOnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
{
// process tag menu requests
if ((id >= ID_TAG_START) && (id < ID_TAG_START+tagMenuList.size())) {
SysOnTagCommand( hwnd, id, hwndCtl, codeNotify, NULL );
InvalidateRect( mdview.hwnd, NULL, FALSE );
}
if (id >= ID_MENUITEMS_UPPERANIMS && id<ID_MENUITEMS_NEXT)
{
SysOnAnimsCommand(hwnd, id, hwndCtl, codeNotify );
FrameAdvanceAnim(0); // cheat, force it to re-evaluate legaliser in case new locks are on
InvalidateRect( hwnd, NULL, FALSE );
}
switch(id)
{
case ID_FILE_OPEN:
{
char sFullName[256];
strcpy(sFullName,"");
if (getCmdLine())
{
strcpy( sFullName, getCmdLine() );
FreeCmdLine();
}
else
{
OPENFILENAME *ofn;
ofn = FileOpenDialog(hwnd, id, codeNotify, hwndCtl, IDS_FILESTRING );
if (ofn)
{
strcpy( sFullName, ofn->lpstrFile );
strcat( sFullName, ofn->lpstrFileTitle );
free( ofn );
}
}
if (strlen(sFullName))
{
strcpy( mdview.basepath, Filename_QUAKEBASEONLY(sFullName));
free_mdviewdata();
bool bOk = loadmdl( sFullName );
// if model loaded ok, and it was called lower.md3, and had a tag called "tag_torso", then
// automatically (try) load "upper.md3" from the same place
bool bLowerMD3 = !stricmp(Filename_WithoutPath(sFullName),"lower.md3");
bool bLowerMDR = !stricmp(Filename_WithoutPath(sFullName),"lower.mdr");
if (bOk)
{
if ((bLowerMD3||bLowerMDR) && giTagMenuSubtractValue_Torso!=-1)
{
char sFullPathedName_Upper[MAX_PATH];
strcpy(sFullPathedName_Upper,va("%s\\upper.%s",Filename_PathOnly(sFullName),bLowerMD3?"md3":"mdr"));
if (file_exists(sFullPathedName_Upper))
{
pModel_Lower = pLastLoadedModel;
pLastLoadedModel = NULL;
int newID = tagMenuList.size(); // get to end of tag list
newID-= giTagMenuSubtractValue_Torso; // back up to "tag_torso"
newID+= ID_TAG_START; // account for resource.h value
SysOnTagCommand( hwnd, newID, hwndCtl, codeNotify, sFullPathedName_Upper);
pModel_Upper = pLastLoadedModel; // NULL or ptr
// switch on flat texturing and filtering (looks better for what we need)...
//
SysOnCommand(hwnd, ID_VIEW_TEXTURED, hwndCtl, codeNotify);
SysOnCommand(hwnd, ID_VIEW_FILTEREDTEXTURE, hwndCtl, codeNotify);
// now try auto-loading the head...
//
if (giTagMenuSubtractValue_Head!=-1)
{
char sFullPathedName_Head[MAX_PATH];
strcpy(sFullPathedName_Head,va("%s\\head.md3",Filename_PathOnly(sFullName)));
if (file_exists(sFullPathedName_Head))
{
pLastLoadedModel = NULL;
int newID = tagMenuList.size(); // get to end of tag list
newID-= giTagMenuSubtractValue_Head; // back up to "tag_head"
newID+= ID_TAG_START; // account for resource.h value
SysOnTagCommand( hwnd, newID, hwndCtl, codeNotify, sFullPathedName_Head);
}
}
}
// now attempt the animation stuff... (this is now done whether or not an UPPER model exists, to
// cope with weird stuff like the vermin model)
//
HDC hDC = GetDC(hwnd);
LoadAnimationCFG(va("%s\\animation.cfg",Filename_PathOnly(sFullName)),hDC);
ReleaseDC(hwnd,hDC);
InvalidateRect( hwnd, NULL, FALSE );
}
else
{
// if you load something with "weapon" in it's path somewhere, and that ends in "_hand.md3", then
// try and auto-load the main components of a weapon onto the appropriate tags...
//
if (strstr(String_ToLower(sFullName),"weapon") && strstr(String_ToLower(sFullName),"_hand.md3"))
{
char sWeaponBasename[MAX_PATH];
strcpy(sWeaponBasename,Filename_WithoutExt(Filename_WithoutPath(sFullName)));
*strrchr(sWeaponBasename,'_')=0; // '_' will be present at this point
int iWeaponID = tagMenuList.size(); // get to end of tag list
iWeaponID-= giTagMenuSubtractValue_Weapon; // back up to correct tag
iWeaponID+= ID_TAG_START; // account for resource.h value
int iBarrelID = tagMenuList.size(); // get to end of tag list
iBarrelID-= giTagMenuSubtractValue_Barrel; // back up to correct tag
iBarrelID+= ID_TAG_START; // account for resource.h value
int iBarrel2ID = tagMenuList.size(); // get to end of tag list
iBarrel2ID-= giTagMenuSubtractValue_Barrel2; // back up to correct tag
iBarrel2ID+= ID_TAG_START; // account for resource.h value
int iBarrel3ID = tagMenuList.size(); // get to end of tag list
iBarrel3ID-= giTagMenuSubtractValue_Barrel3; // back up to correct tag
iBarrel3ID+= ID_TAG_START; // account for resource.h value
int iBarrel4ID = tagMenuList.size(); // get to end of tag list
iBarrel4ID-= giTagMenuSubtractValue_Barrel4; // back up to correct tag
iBarrel4ID+= ID_TAG_START; // account for resource.h value
int iTagMenuSubtractValue_Weapon = giTagMenuSubtractValue_Weapon;
int iTagMenuSubtractValue_Barrel = giTagMenuSubtractValue_Barrel;
int iTagMenuSubtractValue_Barrel2 = giTagMenuSubtractValue_Barrel2;
int iTagMenuSubtractValue_Barrel3 = giTagMenuSubtractValue_Barrel3;
int iTagMenuSubtractValue_Barrel4 = giTagMenuSubtractValue_Barrel4;
if (iTagMenuSubtractValue_Weapon != -1)
SysOnTagCommand( hwnd, iWeaponID, hwndCtl, codeNotify, va("%s\\%s.md3", Filename_PathOnly(sFullName),sWeaponBasename));
if (iTagMenuSubtractValue_Barrel != -1)
SysOnTagCommand( hwnd, iBarrelID, hwndCtl, codeNotify, va("%s\\%s_barrel.md3", Filename_PathOnly(sFullName),sWeaponBasename));
if (iTagMenuSubtractValue_Barrel2 != -1)
SysOnTagCommand( hwnd, iBarrel2ID,hwndCtl, codeNotify, va("%s\\%s_barrel2.md3",Filename_PathOnly(sFullName),sWeaponBasename));
if (iTagMenuSubtractValue_Barrel3 != -1)
SysOnTagCommand( hwnd, iBarrel3ID,hwndCtl, codeNotify, va("%s\\%s_barrel3.md3",Filename_PathOnly(sFullName),sWeaponBasename));
if (iTagMenuSubtractValue_Barrel4 != -1)
SysOnTagCommand( hwnd, iBarrel4ID,hwndCtl, codeNotify, va("%s\\%s_barrel4.md3",Filename_PathOnly(sFullName),sWeaponBasename));
}
}
}
InvalidateRect( hwnd, NULL, FALSE );
//leave this here!! without the screen doesn't
//refresh properly sometimes!!
InvalidateRect( mdview.hwnd, NULL, FALSE );
}
break;
}
case ID_FILE_EXPORTTORAW:
{
OPENFILENAME *ofn;
ofn = FileSaveDialog(hwnd, id, codeNotify, hwndCtl, IDS_RAWFILEFILTER );
if (ofn)
{
char fullName[256];
strcpy( fullName, ofn->lpstrFileTitle );
write_baseModelToRaw( fullName );
free( ofn );
}
break;
}
case ID_FILE_SAVE_MD3:
{
ExportMD3();
break;
}
case ID_FILE_SAVE_G2:
{
ExportG2(false);
break;
}
case ID_FILE_SAVE_G2_PERFECT:
{
ExportG2(true);
break;
}
case ID_FILE_IMPORTSKIN:
{
OPENFILENAME *ofn;
ofn = FileOpenDialog(hwnd, id, codeNotify, hwndCtl, IDS_SKINFILEFILTER );
if (ofn)
{
char fullName[256];
strcpy( fullName, ofn->lpstrFile );
strcat( fullName, ofn->lpstrFileTitle );
importNewSkin( fullName );
InvalidateRect( hwnd, NULL, FALSE );
//leave this here!! without the screen doesn't
//refresh properly sometimes!!
InvalidateRect( mdview.hwnd, NULL, FALSE );
free( ofn );
}
break;
}
case ID_FILE_IMPORTMULTISEQ:
{
OPENFILENAME *ofn;
ofn = FileOpenDialog(hwnd, id, codeNotify, hwndCtl, IDS_SEQFILTER );
if (ofn)
{
char fullName[256];
strcpy( fullName, ofn->lpstrFile );
strcat( fullName, ofn->lpstrFileTitle );
ParseSequenceLockFile( fullName );
InvalidateRect( hwnd, NULL, FALSE );
//leave this here!! without the screen doesn't
//refresh properly sometimes!!
InvalidateRect( mdview.hwnd, NULL, FALSE );
free( ofn );
}
break;
}
case ID_FILE_EXIT:
{
mdview.done = true;
break;
}
case ID_ABOUT:
{
MessageBox(hwnd, ABOUT_TEXT, "About",MB_OK | MB_ICONINFORMATION);
break;
}
case ID_SCREENSHOT_CLIPBOARD:
{
StartWait();
gbTextInhibit = true;
SysOnPaint( hwnd, false ); // false = no buffer flip
ScreenShot(NULL,"(C) Raven Software 2000");
gbTextInhibit = false;
void *pvDIB;
int iBytes;
if (BMP_GetMemDIB(pvDIB, iBytes))
{
ClipBoard_SendDIB(pvDIB, iBytes);
}
EndWait();
InvalidateRect( hwnd, NULL, FALSE );
break;
}
case ID_SCREENSHOT_FILE:
{
gbTextInhibit = true;
SysOnPaint( hwnd, false ); // false = no buffer flip
gl_model *model = NULL;
// get the last model loaded to use as snapshot name base...
//
if (!mdview.modelList->isEmpty())
{
for (NodePosition pos=mdview.modelList->first(); pos!=NULL ; pos=mdview.modelList->after(pos))
{
model = (gl_model *)pos->element();
}
assert(model);
if (model)
{
char sBaseName[MAX_PATH];
sprintf(sBaseName, Filename_WithoutPath(Filename_PathOnly(model->sMDXFullPathname)));
int iName;
for (iName=0; iName<1000; iName++)
{
char sFilename[MAX_PATH];
sprintf(sFilename, "c:\\%s_%03d.bmp",sBaseName,iName);
if (!FileExists(sFilename))
{
StartWait();
ScreenShot(sFilename,"(C) Raven Software 2000");
EndWait();
break;
}
}
if (iName==1000)
{
ErrorBox("Couldn't find a free save slot!");
}
}
}
else
{
ErrorBox("No model load to work out path from!\n\n( So why take a snapshot, dopey? :-)");
}
gbTextInhibit = false;
InvalidateRect( hwnd, NULL, FALSE );
break;
}
case ID_VIEW_COLOURPICKER:
{
CHOOSECOLOR cc;
static COLORREF crefs[16];
memset(&cc,0,sizeof(cc));
cc.lStructSize = sizeof(cc);
cc.hwndOwner = mdview.hwnd;
// cc.hInstance = NULL;
cc.lpCustColors = crefs;
cc.rgbResult = mdview._B<<16 | mdview._G<<8 | mdview._R; // COLORREF rgbResult;
cc.Flags = CC_RGBINIT | CC_ANYCOLOR | CC_SOLIDCOLOR | /*CC_FULLOPEN | */ 0;
if (ChooseColor(&cc))
{
DWORD d = cc.rgbResult;
mdview._B = (cc.rgbResult>>16) & 0xFF;
mdview._G = (cc.rgbResult>>8 ) & 0xFF;
mdview._R = (cc.rgbResult>>0 ) & 0xFF;
}
}
break;
case ID_VIEW_REFRESHTEXTURE:
refreshTextureRes();
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_VIEW_WIREFRAME:
oglStateWireframe();
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_VIEW_FLATSHADED:
oglStateShadedFlat();
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_VIEW_TEXTURED:
oglStateFlatTextured();
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_VIEWPOS_RESET:
extern void reset_viewpos(void);
reset_viewpos();
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_VIEW_TEXTUREDWIREFRAME:
oglStateShadedTexturedAndWireFrame();
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_VIEW_TEXTUREDSHADED:
oglStateShadedTextured();
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_VIEW_NEAREST:
mdview.texMode = TEX_FAST;
setTextureFilter();
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_VIEW_UNFILTEREDTEXTURE:
mdview.texMode = TEX_UNFILTERED;
setTextureFilter();
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_VIEW_FILTEREDTEXTURE:
mdview.texMode = TEX_FILTERED;
setTextureFilter();
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_VIEW_LOADEDSTUFF:
char *GetLoadedModelInfo(void);
InfoBox(GetLoadedModelInfo());
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_ANIMATION_SLOWER:
mdview.animSpeed *= ANIM_SLOWER;
break;
case ID_ANIMATION_FASTER:
mdview.animSpeed *= ANIM_FASTER;
break;
case ID_ANIMATION_STOP:
mdview.animate = false;
break;
case ID_ANIMATION_START:
mdview.animate = true;
break;
case ID_ANIMATION_REWIND:
rewindAnim();
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_FRAME_DW:
FrameAdvanceAnim(-1);
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_FRAME_UP:
FrameAdvanceAnim(1) ;
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_LOD0:
SetLODLevel(0);
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_LOD1:
SetLODLevel(1);
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_LOD2:
SetLODLevel(2);
InvalidateRect( hwnd, NULL, FALSE );
break;
extern void TextureList_ReMip(int iMIPLevel);
case ID_PICMIP0:
TextureList_ReMip(0);
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_PICMIP1:
TextureList_ReMip(1);
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_PICMIP2:
TextureList_ReMip(2);
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_PICMIP3:
TextureList_ReMip(3);
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_PICMIP4:
TextureList_ReMip(4);
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_PICMIP5:
TextureList_ReMip(5);
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_PICMIP6:
TextureList_ReMip(6);
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_PICMIP7:
TextureList_ReMip(7);
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_FACE_INCANIM:
SetFaceSkin(1);
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_FACE_DECANIM:
SetFaceSkin(-1);
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_FACE_RESANIM:
SetFaceSkin(0);
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_VIEWAXIS:
mdview.bAxisView = !mdview.bAxisView;
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_VIEWALPHA:
mdview.bUseAlpha = !mdview.bUseAlpha;
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_VIEW_FOVTOGGLE:
mdview.dFOV = (mdview.dFOV == 10.0f)?80.0f:(mdview.dFOV == 80.0f)?90:10.0f;
RECT rect;
GetClientRect( hwnd, &rect );
set_windowSize( rect.right, rect.bottom );
InvalidateRect( hwnd, NULL, FALSE);
break;
case ID_VIEW_BOUNDSTOGGLE:
mdview.bBBox = !mdview.bBBox;
InvalidateRect( hwnd, NULL, FALSE );
break;
case ID_VIEWLOWERANIM_INC:
if (RunningNT() == 4)
{
if (++iAnimDisplayNumber_Lower > Animation_GetNumLowerSequences()) // num can be size+1 @ max (0=no seq lock)
iAnimDisplayNumber_Lower = 0;
InvalidateRect( hwnd, NULL, FALSE );
}
break;
case ID_VIEWLOWERANIM_DEC:
if (RunningNT() == 4)
{
if (--iAnimDisplayNumber_Lower < 0)
iAnimDisplayNumber_Lower = Animation_GetNumLowerSequences();
InvalidateRect( hwnd, NULL, FALSE );
}
break;
case ID_VIEWLOWERANIM_LOCK:
if (RunningNT() == 4)
{
iAnimLockNumber_Lower = iAnimDisplayNumber_Lower;
FrameAdvanceAnim(0); // cheat, force it to re-evaluate legaliser in case new locks are on
InvalidateRect( hwnd, NULL, FALSE );
}
break;
case ID_VIEWUPPERANIM_INC:
if (RunningNT() == 4)
{
if (++iAnimDisplayNumber_Upper > Animation_GetNumUpperSequences()) // num can be size+1 @ max (0=no seq lock)
iAnimDisplayNumber_Upper = 0;
InvalidateRect( hwnd, NULL, FALSE );
}
break;
case ID_VIEWUPPERANIM_DEC:
if (RunningNT() == 4)
{
if (--iAnimDisplayNumber_Upper < 0)
iAnimDisplayNumber_Upper = Animation_GetNumUpperSequences();
InvalidateRect( hwnd, NULL, FALSE );
}
break;
case ID_VIEWUPPERANIM_LOCK:
if (RunningNT() == 4)
{
iAnimLockNumber_Upper = iAnimDisplayNumber_Upper;
FrameAdvanceAnim(0); // cheat, force it to re-evaluate legaliser in case new locks are on
InvalidateRect( hwnd, NULL, FALSE );
}
break;
case ID_ANIMATION_INTERPOLATE:
if (mdview.interpolate) mdview.interpolate = false;
else mdview.interpolate = true;
break;
}
// I see no reason not to do this, it also helps with things like toggling interp OFF when doing a slow anim, which
// wouldn't otherwise instantly cause a screen redraw to remove the work "(interpolated)" from the screen...
//
InvalidateRect( hwnd, NULL, FALSE );
}
void SysOnKeyDown(HWND hwnd, UINT vk, BOOL fDown, int cRepeat, UINT flags) {
}
void SysOnKeyUp(HWND hwnd, UINT vk, BOOL fDown, int cRepeat, UINT flags) { }
bool SysOnCreate(HWND hwnd, CREATESTRUCT FAR* lpCreateStruct)
{
mdview.hwnd = hwnd;
InitOpenGL( hwnd );
initialize_glstate();
extern void OnceOnly_GLVarsInit(void);
OnceOnly_GLVarsInit();
extern void FakeCvars_OnceOnlyInit(void);
FakeCvars_OnceOnlyInit();
RECT rect;
GetClientRect( hwnd, &rect );
set_windowSize( rect.right, rect.bottom );
return true;
}
/* ---------------------------------------------- dialog code -------------------------------------------- */
/*
saves the directory name after every dialog use
*/
char szDirName[256]={0};
void SetDirectory(LPOPENFILENAME lpofn)
{
lpofn->lpstrFile[lpofn->nFileOffset] = '\0';
lstrcpy(szDirName, lpofn->lpstrFile);
//lstrcpy(mdview.basepath, lpofn->lpstrFile);
}
/*
handles the file open dialog
*/
OPENFILENAME *FileOpenDialog(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl, int type)
{
OPENFILENAME *ofn = (OPENFILENAME *)malloc(sizeof( OPENFILENAME ));
memset( ofn, 0, sizeof( OPENFILENAME ) );
static char szFile[256]; // filename string
static char szFileTitle[256]; // file-title string
static char szFilter[256]; // filter string
char chReplace; // strparator for szFilter
int i, cbString; // integer count variables
// Retrieve the current directory name and store it in szDirName.
if (szDirName[0] == '\0')
{
GetCurrentDirectory(256,szDirName);
}
// Place the terminating null character in the szFile.
szFile[0] = '\0';
// Load the filter string from the resource file.
cbString = LoadString(WinhInstance, type, szFilter, sizeof(szFilter));
// Add a terminating null character to the filter string.
chReplace = szFilter[cbString - 1];
for (i = 0; szFilter[i] != '\0'; i++)
{
if (szFilter[i] == chReplace)
szFilter[i] = '\0';
}
// Set the members of the OPENFILENAME structure.
ofn->lStructSize = sizeof(OPENFILENAME);
ofn->hwndOwner = hwnd;
ofn->lpstrFilter = szFilter;
ofn->nFilterIndex = 1;
ofn->lpstrFile = szFile;
ofn->nMaxFile = sizeof(szFile);
ofn->lpstrFileTitle = szFileTitle;
ofn->nMaxFileTitle = sizeof(szFileTitle);
ofn->lpstrInitialDir = szDirName;
ofn->Flags = OFN_SHOWHELP | OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
// Display the Open dialog box.
if (GetOpenFileName(ofn))
{
SetDirectory(ofn);
return ofn;
}
return NULL;
}
/*
handles the file save dialog
*/
OPENFILENAME *FileSaveDialog(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl, int type)
{
OPENFILENAME *ofn = (OPENFILENAME *)malloc(sizeof( OPENFILENAME ));
memset( ofn, 0, sizeof( OPENFILENAME ) );
static char szFile[256]; // filename string
static char szFileTitle[256]; // file-title string
static char szFilter[256]; // filter string
char chReplace; // strparator for szFilter
int i, cbString; // integer count variables
// Retrieve the current directory name and store it in szDirName.
if (szDirName[0] == '\0')
{
GetCurrentDirectory(256,szDirName);
}
// Place the terminating null character in the szFile.
szFile[0] = '\0';
// Load the filter string from the resource file.
cbString = LoadString(WinhInstance, type, szFilter, sizeof(szFilter));
// Add a terminating null character to the filter string.
chReplace = szFilter[cbString - 1];
for (i = 0; szFilter[i] != '\0'; i++)
{
if (szFilter[i] == chReplace)
szFilter[i] = '\0';
}
// Set the members of the OPENFILENAME structure.
ofn->lStructSize = sizeof(OPENFILENAME);
ofn->hwndOwner = hwnd;
ofn->lpstrFilter = szFilter;
ofn->nFilterIndex = 1;
ofn->lpstrFile = szFile;
ofn->nMaxFile = sizeof(szFile);
ofn->lpstrFileTitle = szFileTitle;
ofn->nMaxFileTitle = sizeof(szFileTitle);
ofn->lpstrInitialDir = szDirName;
ofn->Flags = OFN_SHOWHELP | OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
// Display the Open dialog box.
if (GetSaveFileName(ofn))
{
//SetDirectory(ofn);
return ofn;
}
return NULL;
}
#endif
Reference in a new issue View git blame Copy permalink