FWGS
/
Xash3DArchive
Archived
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

26 Aug 2009

This commit is contained in:
g-cont 2009-08-26 00:00:00 +04:00 committed by Alibek Omarov
parent 0abdaf964b
commit f79320e464
31 changed files with 549 additions and 840 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
baserc/baserc.plg
View File

@ -1,16 +0,0 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: baserc - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
<h3>Results</h3>
baserc.dll - 0 error(s), 0 warning(s)
</pre>
</body>
</html>

102
client/client.plg
View File

@ -6,6 +6,108 @@
--------------------Configuration: client - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP46C4.tmp" with contents
[
/nologo /MDd /W3 /Gm /Gi /GX /ZI /Od /I "./" /I "../common" /I "global" /I "hud" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /FR"..\temp\client\!debug/" /Fo"..\temp\client\!debug/" /Fd"..\temp\client\!debug/" /FD /c
"D:\Xash3D\src_main\client\global\dll_int.cpp"
"D:\Xash3D\src_main\client\hud\hud.cpp"
"D:\Xash3D\src_main\client\hud\hud_ammo.cpp"
"D:\Xash3D\src_main\client\hud\hud_ammohistory.cpp"
"D:\Xash3D\src_main\client\hud\hud_battery.cpp"
"D:\Xash3D\src_main\client\hud\hud_death.cpp"
"D:\Xash3D\src_main\client\hud\hud_flashlight.cpp"
"D:\Xash3D\src_main\client\hud\hud_geiger.cpp"
"D:\Xash3D\src_main\client\hud\hud_health.cpp"
"D:\Xash3D\src_main\client\hud\hud_icons.cpp"
"D:\Xash3D\src_main\client\hud\hud_menu.cpp"
"D:\Xash3D\src_main\client\hud\hud_message.cpp"
"D:\Xash3D\src_main\client\hud\hud_motd.cpp"
"D:\Xash3D\src_main\client\hud\hud_msg.cpp"
"D:\Xash3D\src_main\client\hud\hud_saytext.cpp"
"D:\Xash3D\src_main\client\hud\hud_scoreboard.cpp"
"D:\Xash3D\src_main\client\hud\hud_sound.cpp"
"D:\Xash3D\src_main\client\hud\hud_statusbar.cpp"
"D:\Xash3D\src_main\client\hud\hud_text.cpp"
"D:\Xash3D\src_main\client\hud\hud_train.cpp"
"D:\Xash3D\src_main\client\hud\hud_warhead.cpp"
"D:\Xash3D\src_main\client\hud\hud_zoom.cpp"
"D:\Xash3D\src_main\client\global\tempents.cpp"
"D:\Xash3D\src_main\client\global\utils.cpp"
"D:\Xash3D\src_main\client\global\view.cpp"
]
Creating command line "cl.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP46C4.tmp"
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP46C5.tmp" with contents
[
msvcrtd.lib /nologo /subsystem:windows /dll /incremental:yes /pdb:"..\temp\client\!debug/client.pdb" /debug /machine:I386 /nodefaultlib:"libc.lib" /def:".\client.def" /out:"..\temp\client\!debug/client.dll" /implib:"..\temp\client\!debug/client.lib" /pdbtype:sept /libpath:"..\common\libs"
"\Xash3D\src_main\temp\client\!debug\dll_int.obj"
"\Xash3D\src_main\temp\client\!debug\hud.obj"
"\Xash3D\src_main\temp\client\!debug\hud_ammo.obj"
"\Xash3D\src_main\temp\client\!debug\hud_ammohistory.obj"
"\Xash3D\src_main\temp\client\!debug\hud_battery.obj"
"\Xash3D\src_main\temp\client\!debug\hud_death.obj"
"\Xash3D\src_main\temp\client\!debug\hud_flashlight.obj"
"\Xash3D\src_main\temp\client\!debug\hud_geiger.obj"
"\Xash3D\src_main\temp\client\!debug\hud_health.obj"
"\Xash3D\src_main\temp\client\!debug\hud_icons.obj"
"\Xash3D\src_main\temp\client\!debug\hud_menu.obj"
"\Xash3D\src_main\temp\client\!debug\hud_message.obj"
"\Xash3D\src_main\temp\client\!debug\hud_motd.obj"
"\Xash3D\src_main\temp\client\!debug\hud_msg.obj"
"\Xash3D\src_main\temp\client\!debug\hud_saytext.obj"
"\Xash3D\src_main\temp\client\!debug\hud_scoreboard.obj"
"\Xash3D\src_main\temp\client\!debug\hud_sound.obj"
"\Xash3D\src_main\temp\client\!debug\hud_statusbar.obj"
"\Xash3D\src_main\temp\client\!debug\hud_text.obj"
"\Xash3D\src_main\temp\client\!debug\hud_train.obj"
"\Xash3D\src_main\temp\client\!debug\hud_warhead.obj"
"\Xash3D\src_main\temp\client\!debug\hud_zoom.obj"
"\Xash3D\src_main\temp\client\!debug\tempents.obj"
"\Xash3D\src_main\temp\client\!debug\triapi.obj"
"\Xash3D\src_main\temp\client\!debug\utils.obj"
"\Xash3D\src_main\temp\client\!debug\view.obj"
]
Creating command line "link.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP46C5.tmp"
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP46C6.bat" with contents
[
@echo off
copy \Xash3D\src_main\temp\client\!debug\client.dll "D:\Xash3D\bin\client.dll"
]
Creating command line "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP46C6.bat"
Compiling...
hud_warhead.cpp
Generating Code...
Compiling...
dll_int.cpp
hud.cpp
hud_ammo.cpp
hud_ammohistory.cpp
hud_battery.cpp
hud_death.cpp
hud_flashlight.cpp
hud_geiger.cpp
hud_health.cpp
hud_icons.cpp
hud_menu.cpp
hud_message.cpp
hud_motd.cpp
hud_msg.cpp
hud_saytext.cpp
hud_scoreboard.cpp
hud_sound.cpp
hud_statusbar.cpp
hud_text.cpp
hud_train.cpp
Generating Code...
Compiling...
hud_zoom.cpp
tempents.cpp
utils.cpp
view.cpp
Generating Code...
Linking...
<h3>Output Window</h3>
Performing Custom Build Step on \Xash3D\src_main\temp\client\!debug\client.dll
‘ª®¯¨à®¢ ­® ä ©«®¢: 1.

169
client/global/utils.cpp
View File

@ -166,19 +166,7 @@ typedef struct
bool noCrosshair;
} draw_stuff_t;
typedef struct
{
float fadeSpeed; // How fast to fade (tics / second) (+ fade in, - fade out)
float fadeEnd; // When the fading hits maximum
float fadeTotalEnd; // Total End Time of the fade (used for FFADE_OUT)
float fadeReset; // When to reset to not fading (for fadeout and hold)
Vector fadeColor;
float fadealpha;
int fadeFlags; // Fading flags
} screenfade_t;
static draw_stuff_t ds;
static screenfade_t sf;
int SPR_Frames( HSPRITE hPic )
{
@ -579,19 +567,162 @@ void V_RenderSplash( void )
DrawImageRectangle( SPR_Load( "gfx/shell/splash" ));
}
//
// hl2 fade - this supports multiple fading
// FIXME: make Class CHudFade instead of C-style code?
//
void SetScreenFade( Vector fadeColor, float alpha, float duration, float holdTime, int fadeFlags )
{
sf.fadeColor = fadeColor;
sf.fadealpha = alpha;
sf.fadeFlags = fadeFlags;
sf.fadeEnd = gHUD.m_flTime + duration;
sf.fadeTotalEnd = sf.fadeEnd + holdTime;
sf.fadeSpeed = duration / gHUD.m_flTimeDelta;
ScreenFade *sf = NULL;
for( int i = 0; i < HUD_MAX_FADES; i++ )
{
// search for free spot
if( gHUD.m_FadeList[i].fadeFlags == 0 )
{
sf = &gHUD.m_FadeList[i];
break;
}
}
if( !sf ) return; // no free fades found
sf->fadeEnd = duration;
sf->fadeReset = holdTime;
sf->fadeColor = fadeColor;
sf->fadeAlpha = alpha;
sf->fadeFlags = fadeFlags;
sf->fadeSpeed = 0;
// calc fade speed
if( duration > 0 )
{
if( fadeFlags & FFADE_OUT )
{
if( sf->fadeEnd )
{
sf->fadeSpeed = -(float)sf->fadeAlpha / sf->fadeEnd;
}
sf->fadeEnd += gHUD.m_flTime;
sf->fadeReset += sf->fadeEnd;
}
else
{
if( sf->fadeEnd )
{
sf->fadeSpeed = (float)sf->fadeAlpha / sf->fadeEnd;
}
sf->fadeReset += gHUD.m_flTime;
sf->fadeEnd += sf->fadeReset;
}
}
if( fadeFlags & FFADE_PURGE )
{
ClearAllFades();
}
}
void DrawScreenFade( void )
{
// FIXME: implement
int i, numFades = 0;
// Cycle through all fades and remove any that have finished (work backwards)
for( i = HUD_MAX_FADES - 1; i >= 0; i-- )
{
ScreenFade *pFade = &gHUD.m_FadeList[i];
if( pFade->fadeFlags == 0 ) continue; // free slot
// Keep pushing reset time out indefinitely
if( pFade->fadeFlags & FFADE_STAYOUT )
{
pFade->fadeReset = gHUD.m_flTime + 0.1f;
}
// All done?
if(( gHUD.m_flTime > pFade->fadeReset ) && ( gHUD.m_flTime > pFade->fadeEnd ))
{
// remove this Fade from the list
memset( pFade, 0, sizeof( ScreenFade ));
}
}
gHUD.m_bModulate = false;
gHUD.m_vFadeColor = Vector( 0, 0, 0 );
gHUD.m_fFadeAlpha = 0.0f;
// Cycle through all fades in the list and calculate the overall color/alpha
for ( i = 0; i < HUD_MAX_FADES; i++ )
{
ScreenFade *pFade = &gHUD.m_FadeList[i];
if( pFade->fadeFlags == 0 ) continue; // free slot
// Color
gHUD.m_vFadeColor += pFade->fadeColor;
// Fading...
int iFadeAlpha;
if( pFade->fadeFlags & ( FFADE_OUT|FFADE_IN ))
{
iFadeAlpha = pFade->fadeSpeed * ( pFade->fadeEnd - gHUD.m_flTime );
if( pFade->fadeFlags & FFADE_OUT )
{
iFadeAlpha += pFade->fadeAlpha;
}
iFadeAlpha = min( iFadeAlpha, pFade->fadeAlpha );
iFadeAlpha = max( 0, iFadeAlpha );
}
else
{
iFadeAlpha = pFade->fadeAlpha;
}
// Use highest alpha
if( iFadeAlpha > gHUD.m_fFadeAlpha )
{
gHUD.m_fFadeAlpha = iFadeAlpha;
}
// Modulate?
if( pFade->fadeFlags & FFADE_MODULATE )
{
gHUD.m_bModulate = true;
}
numFades++;
}
// Divide colors
if( numFades ) gHUD.m_vFadeColor /= numFades;
if( gHUD.m_vFadeColor == Vector( 0, 0, 0 )) return;
const float *RGB = gHUD.m_vFadeColor;
FillRGBA( 0, 0, ScreenWidth, ScreenHeight, RGB[0], RGB[1], RGB[2], gHUD.m_fFadeAlpha );
}
void ClearPermanentFades( void )
{
for( int i = HUD_MAX_FADES - 1; i >= 0; i-- )
{
ScreenFade *pFade = &gHUD.m_FadeList[i];
if( pFade->fadeFlags == 0 ) continue; // free slot
if( pFade->fadeFlags & FFADE_STAYOUT )
{
// remove this Fade from the list
ALERT( at_console, "remove fade %i\n", i );
memset( pFade, 0, sizeof( ScreenFade ));
}
}
}
void ClearAllFades( void )
{
memset( gHUD.m_FadeList, 0, sizeof( gHUD.m_FadeList ));
}
/*

2
client/global/utils.h
View File

@ -189,6 +189,8 @@ extern void HideCrosshair( bool hide );
extern void DrawCrosshair( void );
extern void DrawPause( void );
extern void SetScreenFade( Vector fadeColor, float alpha, float duration, float holdTime, int fadeFlags );
extern void ClearAllFades( void );
extern void ClearPermanentFades( void );
extern void DrawScreenFade( void );
extern void DrawImageBar( float percent, const char *szSpriteName );
extern void DrawImageBar( float percent, const char *szSpriteName, int x, int y );

3
client/hud/hud.cpp
View File

@ -75,7 +75,8 @@ void CHud :: VidInit( void )
m_hHudFont = 0;
spot = NULL; // clear intermission spot
Draw_VidInit();
Draw_VidInit ();
ClearAllFades ();
// setup screen info
m_scrinfo.iRealWidth = CVAR_GET_FLOAT( "width" );

24
client/hud/hud.h
View File

@ -15,6 +15,7 @@
#define MIN_ALPHA 100
#define HUDELEM_ACTIVE 1
#define HUD_MAX_FADES 8 // can be blindly increased
typedef struct
{
@ -35,6 +36,16 @@ typedef struct
float appliedAngle;
} ScreenShake;
typedef struct
{
float fadeSpeed; // How fast to fade (tics / second) (+ fade in, - fade out)
float fadeEnd; // When the fading hits maximum
float fadeReset; // When to reset to not fading (for fadeout and hold)
Vector fadeColor;
float fadeAlpha;
int fadeFlags; // Fading flags
} ScreenFade;
typedef struct
{
int dripsPerSecond;
@ -422,6 +433,8 @@ public:
int Draw( float flTime );
int MsgFunc_WarHUD( const char *pszName, int iSize, void *pbuf );
int m_iHudMode;
int m_iOldHudMode;
private:
HSPRITE m_hSprite;
HSPRITE m_hCrosshair;
@ -682,8 +695,15 @@ public:
int m_HUD_number_0;
// screen shake handler
ScreenShake m_Shake;
ScreenShake m_Shake;
// screen fade handler
ScreenFade m_FadeList[HUD_MAX_FADES];
Vector m_vFadeColor;
float m_fFadeAlpha;
BOOL m_bModulate;
// error sprite
int m_HUD_error;
HSPRITE m_hHudError;

41
client/hud/hud_warhead.cpp
View File

@ -31,7 +31,7 @@ int CHudRedeemer :: VidInit( void )
m_hStatic = SPR_Load( "sprites/static.spr" );
m_hCamera = SPR_Load( "sprites/camera.spr" );
m_iHudMode = 0;
m_iHudMode = m_iOldHudMode = 0;
return 1;
}
@ -39,6 +39,8 @@ int CHudRedeemer :: MsgFunc_WarHUD( const char *pszName, int iSize, void *pbuf )
{
BEGIN_READ( pszName, iSize, pbuf );
m_iHudMode = READ_BYTE();
m_iOldHudMode = -1; // force to update
ClearPermanentFades ();
END_READ();
return 1;
@ -55,7 +57,7 @@ int CHudRedeemer :: Draw( float flTime )
rc.right = ScreenWidth;
rc.bottom = ScreenHeight;
if( m_iHudMode == 1 ) // draw crosshair and readout
if( m_iHudMode == 1 ) // draw warhead screen (controllable rocket)
{
y = (ScreenWidth - GUIDE_S) / 2;
x = (ScreenHeight - GUIDE_S) / 2;
@ -71,9 +73,14 @@ int CHudRedeemer :: Draw( float flTime )
SPR_DrawAdditive( 0, 0, yOffset, READOUT_S>>1, READOUT_S );
yOffset -= READOUT_S;
}
SetScreenFade( Vector( 1, 0, 0 ), 0.25, 0, 0, FFADE_STAYOUT ); // enable red fade
if( m_iOldHudMode != m_iHudMode )
{
// enable red fade
SetScreenFade( Vector( 255, 0, 0 ), 64, 0, 0, FFADE_STAYOUT );
}
}
else if( m_iHudMode == 2 ) // draw alpha noise
else if( m_iHudMode == 2 ) // draw warhead screen with alpha noise (underwater)
{
// play at 15fps
frame = (int)(flTime * 15) % SPR_Frames( m_hStatic );
@ -82,9 +89,9 @@ int CHudRedeemer :: Draw( float flTime )
w = SPR_Width( m_hStatic, 0 );
h = SPR_Height( m_hStatic, 0 );
for( y = -(rand() % h); y < ScreenHeight; y += h )
for( y = -(RANDOM_LONG( 0, h )); y < ScreenHeight; y += h )
{
for( x = -(rand() % w); x < ScreenWidth; x += w )
for( x = -(RANDOM_LONG( 0, w )); x < ScreenWidth; x += w )
{
SPR_Set( m_hStatic, 255, 255, 255, 100 );
SPR_DrawAdditive( frame, x, y, NULL );
@ -105,21 +112,26 @@ int CHudRedeemer :: Draw( float flTime )
SPR_DrawAdditive( 0, 0, yOffset, READOUT_S>>1, READOUT_S );
yOffset -= READOUT_S;
}
SetScreenFade( Vector( 1, 0, 0 ), 0.25, 0, 0, FFADE_STAYOUT ); // enable red fade
if( m_iOldHudMode != m_iHudMode )
{
// enable red fade
SetScreenFade( Vector( 255, 0, 0 ), 64, 0, 0, FFADE_STAYOUT );
}
}
else if( m_iHudMode == 3 ) // draw static noise
else if( m_iHudMode == 3 ) // draw static noise (self destroyed)
{
// play at 15fps
frame = (int)(flTime * 15) % SPR_Frames( m_hStatic );
SPR_Set( m_hStatic, 255, 255, 255 );
SPR_Draw( frame, 0, 0, ScreenWidth, ScreenHeight );
// disable fade
SetScreenFade( Vector( 1, 1, 1 ), 0, 0, 0, FFADE_OUT );
}
else if( m_iHudMode == 4 ) // draw videocamera screen
else if( m_iHudMode == 4 )
{
// HACKHACK draw videocamera screen
// g-cont. i'm lazy same as BUzer, i won't to create new class :)
// play at 1.5 fps
frame = (int)(flTime * 1.5f) % SPR_Frames( m_hCamRec );
@ -138,9 +150,8 @@ int CHudRedeemer :: Draw( float flTime )
x = ScreenWidth - (w * 1.5f);
y = w * 0.4f;
SPR_DrawAdditive( frame, x, y, w, h );
// disable fade
SetScreenFade( Vector( 1, 1, 1 ), 0, 0, 0, FFADE_OUT );
}
m_iOldHudMode = m_iHudMode;
return 1;
}

11
common/game_shared.h
View File

@ -27,11 +27,12 @@ enum ShakeCommand_t
SHAKE_FREQUENCY, // Modifies the frequency of an active screen shake for all players within the radius.
};
#define FFADE_IN 0x0000 // Just here so we don't pass 0 into the function
#define FFADE_OUT 0x0001 // Fade out (not in)
#define FFADE_MODULATE 0x0002 // Modulate (don't blend)
#define FFADE_STAYOUT 0x0004 // ignores the duration, stays faded out until new ScreenFade message received
#define FFADE_CUSTOMVIEW 0x0008 // fading only at custom viewing (don't sending this to engine )
#define FFADE_IN 0x0001 // Fade in (not out)
#define FFADE_OUT 0x0002 // Fade out (not in)
#define FFADE_MODULATE 0x0004 // Modulate (don't blend)
#define FFADE_STAYOUT 0x0008 // ignores the duration, stays faded out until new ScreenFade message received
#define FFADE_CUSTOMVIEW 0x0010 // fading only at custom viewing (don't sending this to engine )
#define FFADE_PURGE 0x0020 // Purges all other fades, replacing them with this one
// camera flags
#define CAMERA_ON 1

1
common/studio_ref.h
View File

@ -49,6 +49,7 @@ Studio models are position independent, so the cache manager can move them.
#define STUDIO_NF_BLENDED 0x0010 // rendering as semiblended
#define STUDIO_NF_ADDITIVE 0x0020 // rendering with additive mode
#define STUDIO_NF_TRANSPARENT 0x0040 // use texture with alpha channel
#define STUDIO_NF_QUAKESKIN 0x8000 // special hack for determine alias skins
// motion flags
#define STUDIO_X 0x0001

16
engine/engine.plg
View File

@ -1,16 +0,0 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: engine - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
<h3>Results</h3>
engine.dll - 0 error(s), 0 warning(s)
</pre>
</body>
</html>

498
launch/imagelib/img_jpg.old
View File

@ -1,498 +0,0 @@
//=======================================================================
// Copyright XashXT Group 2007 ©
// img_jpg.c - jpg format load & save
//=======================================================================
#include "imagelib.h"
jpg_t jpg_file; // jpeg read struct
int jpeg_read_byte( void )
{
// read byte
jpg_file.curbyte = *jpg_file.buffer++;
jpg_file.curbit = 0;
return jpg_file.curbyte;
}
int jpeg_read_word( void )
{
// read word
word i = BuffLittleShort( jpg_file.buffer);
i = ((i << 8) & 0xFF00) + ((i >> 8) & 0x00FF);
jpg_file.buffer += 2;
return i;
}
int jpeg_read_bit( void )
{
// read bit
register int i;
if(jpg_file.curbit == 0)
{
jpeg_read_byte();
if(jpg_file.curbyte == 0xFF)
{
while(jpg_file.curbyte == 0xFF) jpeg_read_byte();
if(jpg_file.curbyte >= 0xD0 && jpg_file.curbyte <= 0xD7)
Mem_Set(jpg_file.dc, 0, sizeof(int) * 3);
if(jpg_file.curbyte == 0) jpg_file.curbyte = 0xFF;
else jpeg_read_byte();
}
}
i = (jpg_file.curbyte >> (7 - jpg_file.curbit++)) & 0x01;
if(jpg_file.curbit == 8) jpg_file.curbit = 0;
return i;
}
int jpeg_read_bits( int num )
{
// read num bit
register int i, j;
for(i = 0, j = 0; i < num; i++)
{
j <<= 1;
j |= jpeg_read_bit();
}
return j;
}
int jpeg_bit2int( int bit, int i )
{
// convert bit code to int
if((i & (1 << (bit - 1))) > 0) return i;
return -(i ^ ((1 << bit) - 1));
}
int jpeg_huffmancode( huffman_table_t *table )
{
// get Huffman code
register int i,size,code;
for(size = 1, code = 0, i = 0; size < 17; size++)
{
code <<= 1;
code |= jpeg_read_bit();
while(table->size[i] <= size)
{
if( table->code[i] == code )
return table->hval[i];
i++;
}
}
return code;
}
void jpeg_idct( float *data )
{
// aa&n algorithm inverse DCT
float t0, t1, t2, t3, t4, t5, t6, t7;
float t10, t11, t12, t13;
float z5, z10, z11, z12, z13;
float *dataptr;
int i;
dataptr = data;
for(i = 0; i < 8; i++)
{
t0 = dataptr[8 * 0];
t1 = dataptr[8 * 2];
t2 = dataptr[8 * 4];
t3 = dataptr[8 * 6];
t10 = t0 + t2;
t11 = t0 - t2;
t13 = t1 + t3;
t12 = - t13 + (t1 - t3) * 1.414213562;//??
t0 = t10 + t13;
t3 = t10 - t13;
t1 = t11 + t12;
t2 = t11 - t12;
t4 = dataptr[8 * 1];
t5 = dataptr[8 * 3];
t6 = dataptr[8 * 5];
t7 = dataptr[8 * 7];
z13 = t6 + t5;
z10 = t6 - t5;
z11 = t4 + t7;
z12 = t4 - t7;
t7 = z11 + z13;
t11 = (z11 - z13) * 1.414213562;
z5 = (z10 + z12) * 1.847759065;
t10 = - z5 + z12 * 1.082392200;
t12 = z5 - z10 * 2.613125930;
t6 = t12 - t7;
t5 = t11 - t6;
t4 = t10 + t5;
dataptr[8 * 0] = t0 + t7;
dataptr[8 * 7] = t0 - t7;
dataptr[8 * 1] = t1 + t6;
dataptr[8 * 6] = t1 - t6;
dataptr[8 * 2] = t2 + t5;
dataptr[8 * 5] = t2 - t5;
dataptr[8 * 4] = t3 + t4;
dataptr[8 * 3] = t3 - t4;
dataptr++;
}
dataptr = data;
for(i = 0; i < 8; i++)
{
t10 = dataptr[0] + dataptr[4];
t11 = dataptr[0] - dataptr[4];
t13 = dataptr[2] + dataptr[6];
t12 = - t13 + (dataptr[2] - dataptr[6]) * 1.414213562;//??
t0 = t10 + t13;
t3 = t10 - t13;
t1 = t11 + t12;
t2 = t11 - t12;
z13 = dataptr[5] + dataptr[3];
z10 = dataptr[5] - dataptr[3];
z11 = dataptr[1] + dataptr[7];
z12 = dataptr[1] - dataptr[7];
t7 = z11 + z13;
t11 = (z11 - z13) * 1.414213562;
z5 = (z10 + z12) * 1.847759065;
t10 = - z5 + z12 * 1.082392200;
t12 = z5 - z10 * 2.613125930;
t6 = t12 - t7;
t5 = t11 - t6;
t4 = t10 + t5;
dataptr[0] = t0 + t7;
dataptr[7] = t0 - t7;
dataptr[1] = t1 + t6;
dataptr[6] = t1 - t6;
dataptr[2] = t2 + t5;
dataptr[5] = t2 - t5;
dataptr[4] = t3 + t4;
dataptr[3] = t3 - t4;
dataptr += 8;//move ptr
}
}
int jpeg_readmarkers( void )
{
// read jpeg markers
int marker, length, i, j, k, l, m;
huffman_table_t *hptr;
while( 1 )
{
marker = jpeg_read_byte();
if( marker != 0xFF ) return 0;
marker = jpeg_read_byte();
if( marker != 0xD8 )
{
length = jpeg_read_word();
length -= 2;
switch( marker )
{
case 0xC0: // baseline
jpg_file.data_precision = jpeg_read_byte();
jpg_file.height = jpeg_read_word();
jpg_file.width = jpeg_read_word();
jpg_file.num_components = jpeg_read_byte();
if(length - 6 != jpg_file.num_components * 3) return 0;
for(i = 0; i < jpg_file.num_components; i++)
{
jpg_file.component_info[i].id = jpeg_read_byte();
j = jpeg_read_byte();
jpg_file.component_info[i].h = (j >> 4) & 0x0F;
jpg_file.component_info[i].v = j & 0x0F;
jpg_file.component_info[i].t = jpeg_read_byte();
}
break;
case 0xC1: // extended sequetial, Huffman
case 0xC2: // progressive, Huffman
case 0xC3: // lossless, Huffman
case 0xC5: // differential sequential, Huffman
case 0xC6: // differential progressive, Huffman
case 0xC7: // differential lossless, Huffman
case 0xC8: // reserved for JPEG extensions
case 0xC9: // extended sequential, arithmetic
case 0xCA: // progressive, arithmetic
case 0xCB: // lossless, arithmetic
case 0xCD: // differential sequential, arithmetic
case 0xCE: // differential progressive, arithmetic
case 0xCF: // differential lossless, arithmetic
return 0; // not supported yet
case 0xC4: // huffman table
while( length > 0 )
{
k = jpeg_read_byte();
if(k & 0x10) hptr = &jpg_file.hac[k & 0x0F];
else hptr = &jpg_file.hdc[k & 0x0F];
for(i = 0, j = 0; i < 16; i++)
{
hptr->bits[i] = jpeg_read_byte();
j += hptr->bits[i];
}
length -= 17;
for(i = 0; i < j; i++) hptr->hval[i] = jpeg_read_byte();
length -= j;
for(i = 0, k = 0, l = 0; i < 16; i++)
{
for(j = 0; j < hptr->bits[i]; j++, k++)
{
hptr->size[k] = i + 1;
hptr->code[k] = l++;
}
l <<= 1;
}
}
break;
case 0xDB: // quantization table
while( length > 0 )
{
j = jpeg_read_byte();
k = (j >> 4) & 0x0F;
for(i = 0; i < 64; i++)
{
if( k )jpg_file.qtable[j][i] = jpeg_read_word();
else jpg_file.qtable[j][i] = jpeg_read_byte();
}
length -= 65;
if( k )length -= 64;
}
break;
case 0xD9: // end of image (EOI)
return 0;
case 0xDA: // start of scan (SOS)
j = jpeg_read_byte();
for(i = 0; i < j; i++)
{
k = jpeg_read_byte();
m = jpeg_read_byte();
for( l = 0; l < jpg_file.num_components; l++ )
{
if( jpg_file.component_info[l].id == k )
{
jpg_file.component_info[l].td = (m >> 4) & 0x0F;
jpg_file.component_info[l].ta = m & 0x0F;
}
}
}
jpg_file.scan.ss = jpeg_read_byte();
jpg_file.scan.se = jpeg_read_byte();
k = jpeg_read_byte();
jpg_file.scan.ah = (k >> 4) & 0x0F;
jpg_file.scan.al = k & 0x0F;
return 1;
case 0xDD: // restart interval
jpg_file.restart_interval = jpeg_read_word();
break;
default:
jpg_file.buffer += length; // move ptr
break;
}
}
}
}
void jpeg_decompress( void )
{
// decompress jpeg file (baseline algorithm)
register int x, y, i, j, k, l, c;
int X, Y, H, V, plane, scaleh[3], scalev[3];
static float vector[64], dct[64];
static const int jpeg_zigzag[64] =
{
0, 1, 5, 6, 14, 15, 27, 28,
2, 4, 7, 13, 16, 26, 29, 42,
3, 8, 12, 17, 25, 30, 41, 43,
9, 11, 18, 24, 31, 40, 44, 53,
10, 19, 23, 32, 39, 45, 52, 54,
20, 22, 33, 38, 46, 51, 55, 60,
21, 34, 37, 47, 50, 56, 59, 61,
35, 36, 48, 49, 57, 58, 62, 63
};
// 1.0, k = 0; cos(k * PI / 16) * sqrt(2), k = 1...7
static const float aanscale[8] =
{
1.0, 1.387039845, 1.306562965, 1.175875602,
1.0, 0.785694958, 0.541196100, 0.275899379
};
scaleh[0] = 1;
scalev[0] = 1;
if(jpg_file.num_components == 3)
{
scaleh[1] = jpg_file.component_info[0].h / jpg_file.component_info[1].h;
scalev[1] = jpg_file.component_info[0].v / jpg_file.component_info[1].v;
scaleh[2] = jpg_file.component_info[0].h / jpg_file.component_info[2].h;
scalev[2] = jpg_file.component_info[0].v / jpg_file.component_info[2].v;
}
Mem_Set( jpg_file.dc, 0, sizeof(int) * 3);
for( Y = 0; Y < jpg_file.height; Y += jpg_file.component_info[0].v << 3 )
{
if( jpg_file.restart_interval > 0 ) jpg_file.curbit = 0;
for( X = 0; X < jpg_file.width; X += jpg_file.component_info[0].h << 3 )
{
for(plane = 0; plane < jpg_file.num_components; plane++)
{
for(V = 0; V < jpg_file.component_info[plane].v; V++)
{
for(H = 0; H < jpg_file.component_info[plane].h; H++)
{
i = jpeg_huffmancode(&jpg_file.hdc[jpg_file.component_info[plane].td]);
i &= 0x0F;
vector[0] = jpg_file.dc[plane] + jpeg_bit2int(i,jpeg_read_bits(i));
jpg_file.dc[plane] = vector[0];
i = 1;
while(i < 64)
{
j = jpeg_huffmancode(&jpg_file.hac[jpg_file.component_info[plane].ta]);
if(j == 0) while(i < 64) vector[i++] = 0;
else
{
k = i + ((j >> 4) & 0x0F);
while(i < k) vector[i++] = 0;
j &= 0x0F;
vector[i++] = jpeg_bit2int(j,jpeg_read_bits(j));
}
}
k = jpg_file.component_info[plane].t;
for(y = 0, i = 0; y < 8; y++)
{
for(x = 0; x < 8; x++, i++)
{
j = jpeg_zigzag[i];
dct[i] = vector[j] * jpg_file.qtable[k][j] * aanscale[x] * aanscale[y];
}
}
jpeg_idct(dct);
for(y = 0; y < 8; y++)
{
for(x = 0; x < 8; x++)
{
c = ((int)dct[(y << 3) + x] >> 3) + 128;
if(c < 0) c = 0;
else if(c > 255) c = 255;
if(scaleh[plane] == 1 && scalev[plane] == 1)
{
i = X + x + (H << 3);
j = Y + y + (V << 3);
if(i < jpg_file.width && j < jpg_file.height)
jpg_file.data[((j * jpg_file.width + i) << 2) + plane] = c;
}
else for(l = 0; l < scalev[plane]; l++)//else for, heh...
{
for(k = 0; k < scaleh[plane]; k++)
{
i = X + (x + (H << 3)) * scaleh[plane] + k;
j = Y + (y + (V << 3)) * scalev[plane] + l;
if(i < jpg_file.width && j < jpg_file.height)
jpg_file.data[((j * jpg_file.width + i) << 2) + plane] = c;
}
}
}
}
}
}
}
}
}
}
void jpeg_ycbcr2rgba( void )
{
int i, Y, Cb, Cr, R, G, B;
// convert YCbCr image to RGBA
for( i = 0; i < jpg_file.width * jpg_file.height << 2; i += 4 )
{
Y = jpg_file.data[i+0];
Cb = jpg_file.data[i+1] - 128;
Cr = jpg_file.data[i+2] - 128;
R = Y + 1.40200 * Cr;
G = Y - 0.34414 * Cb - 0.71414 * Cr;
B = Y + 1.77200 * Cb;
// bound colors
R = bound( 0, R, 255 );
G = bound( 0, G, 255 );
B = bound( 0, B, 255 );
jpg_file.data[i+0] = R;
jpg_file.data[i+1] = G;
jpg_file.data[i+2] = B;
jpg_file.data[i+3] = 0xff; // no alpha channel
}
image.flags |= IMAGE_HAS_COLOR;
}
void jpeg_gray2rgba( void )
{
int i, j;
// grayscale image to RGBA
for(i = 0; i < jpg_file.width * jpg_file.height << 2; i += 4)
{
j = jpg_file.data[i];
jpg_file.data[i+0] = j;
jpg_file.data[i+1] = j;
jpg_file.data[i+2] = j;
jpg_file.data[i+3] = 0xff;
}
}
/*
=============
Image_LoadJPG
=============
*/
bool Image_LoadJPG( const char *name, const byte *buffer, size_t filesize )
{
Mem_Set( &jpg_file, 0, sizeof( jpg_file ));
jpg_file.buffer = (byte *)buffer;
if(!jpeg_readmarkers())
return false; // it's not a jpg file, just skip it
image.width = jpg_file.width;
image.height = jpg_file.height;
if(!Image_ValidSize( name )) return false;
image.size = jpg_file.width * jpg_file.height * 4;
jpg_file.data = Mem_Alloc( Sys.imagepool, image.size );
jpeg_decompress();
if( jpg_file.num_components == 1 ) jpeg_gray2rgba();
if( jpg_file.num_components == 3 ) jpeg_ycbcr2rgba();
image.rgba = jpg_file.data;
image.type = PF_RGBA_32;
image.depth = 1;
image.num_mips = 1;
return true;
}

4
launch/imagelib/img_utils.c
View File

@ -244,9 +244,9 @@ static const loadformat_t load_xash051[] =
{ "%s%s.%s", "tga", Image_LoadTGA, IL_HINT_NO }, // screenshots, etc
{ "%s%s.%s", "jpg", Image_LoadJPG, IL_HINT_NO }, // 2d textures
{ "%s%s.%s", "mip", Image_LoadMIP, IL_HINT_HL }, // hl textures (WorldCraft support)
{ "%s%s.%s", "mdl", Image_LoadMDL, IL_HINT_HL }, // hl studio model skins
{ "%s%s.%s", "mdl", Image_LoadMDL, IL_HINT_NO }, // hl or q1 model skins
{ "%s%s.%s", "spr", Image_LoadSPR, IL_HINT_HL }, // hl sprite frames
{ "%s%s.%s", "pal", Image_LoadPAL, IL_HINT_HL }, // install studio palette
{ "%s%s.%s", "pal", Image_LoadPAL, IL_HINT_NO }, // install palettes
{ NULL, NULL, NULL, IL_HINT_NO }
};

64
launch/imagelib/img_wad.c
View File

@ -32,6 +32,8 @@ bool Image_LoadPAL( const char *name, const byte *buffer, size_t filesize )
rendermode = LUMP_DECAL;
else if( com.stristr( name, "qfont" ))
rendermode = LUMP_QFONT;
else if( com.stristr( name, "quake" ))
buffer = NULL; // force to get Q1 palette
}
// NOTE: image.d_currentpal not cleared with Image_Reset()
@ -57,17 +59,8 @@ bool Image_LoadMDL( const char *name, const byte *buffer, size_t filesize )
byte *fin;
size_t pixels;
dstudiotexture_t *pin;
int flags;
int i, flags;
// check palette first
if( image.hint != IL_HINT_HL ) return false; // unknown mode rejected
if( !image.d_currentpal )
{
MsgDev( D_ERROR, "Image_LoadMDL: (%s) palette not installed\n", name );
return false;
}
pin = (dstudiotexture_t *)buffer;
flags = LittleLong( pin->flags );
@ -75,21 +68,46 @@ bool Image_LoadMDL( const char *name, const byte *buffer, size_t filesize )
image.width = LittleLong( pin->width );
image.height = LittleLong( pin->height );
pixels = image.width * image.height;
if( filesize < pixels + sizeof( dstudiotexture_t ) + 768 )
{
MsgDev( D_ERROR, "Image_LoadMDL: file (%s) have invalid size\n", pin->name );
return false;
}
if( flags & STUDIO_NF_TRANSPARENT )
{
if( image.d_rendermode != LUMP_TRANSPARENT )
MsgDev( D_WARN, "Image_LoadMDL: (%s) using normal palette for alpha-skin\n", pin->name );
image.flags |= IMAGE_HAS_ALPHA;
}
fin = (byte *)pin->index; // setup buffer
if( image.hint != IL_HINT_Q1 && !( flags & STUDIO_NF_QUAKESKIN ))
{
// studio models setup
if( !image.d_currentpal )
{
MsgDev( D_ERROR, "Image_LoadMDL: (%s) palette not installed\n", name );
return false;
}
if( flags & STUDIO_NF_TRANSPARENT )
{
if( image.d_rendermode != LUMP_TRANSPARENT )
MsgDev( D_WARN, "Image_LoadMDL: (%s) using normal pal for alpha-skin\n", name );
image.flags |= IMAGE_HAS_ALPHA;
}
}
else if( image.hint != IL_HINT_HL && flags & STUDIO_NF_QUAKESKIN )
{
// alias models setup
Image_GetPaletteQ1();
// check for luma pixels
for( i = 0; i < pixels; i++ )
{
if( fin[i] > 224 )
{
Msg( "%s has luma-pixels\n", name );
image.flags |= IMAGE_HAS_LUMA_Q1;
break;
}
}
}
else
{
if( image.hint == IL_HINT_NO )
MsgDev( D_ERROR, "Image_LoadMDL: lump (%s) is corrupted\n", name );
return false; // unknown or unsupported mode rejected
}
if(!Image_LumpValidSize( name )) return false;
image.depth = 1;
image.type = PF_INDEXED_32; // 32-bit palete

16
launch/launch.plg
View File

@ -1,16 +0,0 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: launch - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
<h3>Results</h3>
launch.dll - 0 error(s), 0 warning(s)
</pre>
</body>
</html>

16
physic/physic.plg
View File

@ -1,16 +0,0 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: physic - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
<h3>Results</h3>
physic.dll - 0 error(s), 0 warning(s)
</pre>
</body>
</html>

2
render/r_alias.c
View File

@ -233,7 +233,7 @@ void Mod_AliasLoadModel( ref_model_t *mod, ref_model_t *parent, const void *buff
for( j = 0; j < poutmesh->numskins; j++, pinskin++, poutskin++ )
{
FS_StripExtension( pinskin->name );
poutskin->shader = R_LoadShader( pinskin->name, SHADER_ALIAS, false, 0, SHADER_INVALID );
poutskin->shader = R_LoadShader( pinskin->name, SHADER_ALIAS_MD3, false, 0, SHADER_INVALID );
R_DeformvBBoxForShader( poutskin->shader, ebbox );
}

41
render/r_aliasq.c
View File

@ -133,7 +133,7 @@ void Mod_FloodFillSkin( byte *skin, int skinwidth, int skinheight )
floodfill_t fifo[FLOODFILL_FIFO_SIZE];
int inpt = 0, outpt = 0;
int filledcolor = -1;
rgbdata_t *pal = FS_LoadImage( "#normal.pal", NULL, 768 ); // null buffer force to get Q1 palette
rgbdata_t *pal = FS_LoadImage( "#quake1.pal", skin, 768 );
uint *d_8to24table = (uint *)pal->palette;
int i;
@ -183,18 +183,25 @@ void *Mod_AliasLoadSkins( ref_model_t *mod, int numskins, daliasskintype_t *pski
{
int i, j, k, s;
string shadername;
string modname;
byte *skin;
byte *texels;
int groupskins;
daliasskingroup_t *pinskingroup;
daliasskininterval_t *pinskinintervals;
dstudiotexture_t *ptexture; // apply studio header for alias texture
texture_t *tex;
FS_FileBase( mod->name, modname );
skin = (byte *)(pskintype + 1);
if( numskins < 1 || numskins > MAX_SKINS )
Host_Error( "Mod_LoadAliasModel: Invalid # of skins: %d\n", numskins );
s = pheader->skinwidth * pheader->skinheight;
ptexture = Mod_Malloc( mod, sizeof( *ptexture ));
ptexture->height = pheader->skinheight;
ptexture->width = pheader->skinwidth;
ptexture->flags = STUDIO_NF_QUAKESKIN; // indicates alias models
for( i = 0; i < numskins; i++ )
{
@ -202,13 +209,13 @@ void *Mod_AliasLoadSkins( ref_model_t *mod, int numskins, daliasskintype_t *pski
{
Mod_FloodFillSkin( skin, pheader->skinwidth, pheader->skinheight );
// save 8 bit texels for the player model to remap
texels = Mod_Malloc( mod, s );
pheader->texels[i] = texels - (byte *)pheader;
Mem_Copy( texels, (byte *)(pskintype + 1), s );
com.sprintf( shadername, "%s_%i", mod->name, i );
com.sprintf( shadername, "%s.mdl/%s_%i.bmp", modname, modname, i );
com.sprintf( ptexture->name, "Alias( %s_%i )", modname, i );
ptexture->index = (int)skin;// don't copy, just set ptr
tex = R_FindTexture( ptexture->name, (byte *)ptexture, s, 0 );
R_ShaderAddStageTexture( tex );
pheader->skins[i][0] = pheader->skins[i][1] = pheader->skins[i][2] =
pheader->skins[i][3] = R_LoadShader( shadername, SHADER_ALIAS, 0, 0, -1 );
pheader->skins[i][3] = R_LoadShader( shadername, SHADER_ALIAS, false, tex->flags, SHADER_INVALID );
pskintype = (daliasskintype_t *)((byte *)(pskintype + 1) + s );
}
else
@ -224,14 +231,12 @@ void *Mod_AliasLoadSkins( ref_model_t *mod, int numskins, daliasskintype_t *pski
for( j = 0; j < groupskins; j++ )
{
Mod_FloodFillSkin( skin, pheader->skinwidth, pheader->skinheight );
if( j == 0 )
{
texels = Mod_Malloc( mod, s );
pheader->texels[i] = texels - (byte *)pheader;
Mem_Copy( texels, (byte *)(pskintype), s );
}
com.sprintf( shadername, "%s_%i_%i", mod->name, i, j );
pheader->skins[i][j&3] = R_LoadShader( shadername, SHADER_ALIAS, 0, 0, -1 );
com.sprintf( shadername, "%s.mdl/%s_%i_%i", modname, modname, i, j );
com.sprintf( ptexture->name, "Alias( %s_%i_%i )", modname, i, j );
ptexture->index = (int)skin;// don't copy, just set ptr
tex = R_FindTexture( ptexture->name, (byte *)ptexture, s, 0 );
R_ShaderAddStageTexture( tex );
pheader->skins[i][j&3] = R_LoadShader( shadername, SHADER_ALIAS, false, tex->flags, SHADER_INVALID );
pskintype = (daliasskintype_t *)((byte *)(pskintype) + s );
}
for( k = j; j < 4; j++ )
@ -267,7 +272,7 @@ void Mod_QAliasLoadModel( ref_model_t *mod, ref_model_t *parent, const void *buf
// skin and group info
size = sizeof( maliashdr_t ) + (LittleLong( pinmodel->numframes ) - 1) * sizeof( pheader->frames[0] );
mod->extradata = pheader = Mod_Malloc( mod, size );
mod->type = mod_alias;
mod->type = mod_bad; // temporary disabled
// endian-adjust and copy the data, starting with the alias model header
pheader->flags = LittleLong( pinmodel->flags );

4
render/r_backend.c
View File

@ -1244,11 +1244,11 @@ static _inline texture_t *R_ShaderpassTex( const ref_stage_t *pass, int unit )
if( RI.currententity )
{
if( RI.currententity->frame )
if( RI.currententity->frame && pass->animFrequency[1] != 0.0f )
{
numframes = bound( 1, pass->num_textures - pass->anim_offset, MAX_STAGE_TEXTURES - 1 );
frame = (int)( pass->animFrequency[1] * r_currentShaderTime ) % numframes;
frame += pass->anim_offset; // bias
frame = bound( 0, frame + pass->anim_offset, pass->num_textures ); // bias
}
else
{

19
render/r_draw.c
View File

@ -34,6 +34,7 @@ void R_DrawStretchPic( float x, float y, float w, float h, float s1, float t1, f
{
int bcolor;
ref_shader_t *shader;
static int oldframe;
if( handle < 0 || handle > MAX_SHADERS || !(shader = &r_shaders[handle]))
return;
@ -76,6 +77,22 @@ void R_DrawStretchPic( float x, float y, float w, float h, float s1, float t1, f
// upload video right before rendering
if( shader->flags & SHADER_VIDEOMAP ) R_UploadCinematicShader( shader );
R_PushMesh( &pic_mesh, MF_TRIFAN|shader->features | ( r_shownormals->integer ? MF_NORMALS : 0 ));
if( oldframe != glState.draw_frame )
{
if( pic_mbuffer.shaderkey != (int)shader->sortkey )
{
// will be rendering on next call
oldframe = glState.draw_frame;
return;
}
if( pic_mbuffer.shaderkey )
{
pic_mbuffer.infokey = -1;
R_RenderMeshBuffer( &pic_mbuffer );
}
oldframe = glState.draw_frame;
}
}
/*
@ -180,7 +197,7 @@ void R_DrawFill( float x, float y, float w, float h )
pglDisable( GL_TEXTURE_2D );
pglColor4fv( glState.draw_color );
if( glState.draw_color[3] != 255 )
if( glState.draw_color[3] != 1.0f )
GL_SetState( GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE_MINUS_SRC_ALPHA );
else GL_SetState( GLSTATE_SRCBLEND_ONE|GLSTATE_DSTBLEND_ZERO );

37
render/r_image.c
View File

@ -2123,7 +2123,7 @@ static rgbdata_t *R_ParseMakeGlow( script_t *script, int *samples, texFlags_t *f
return R_MakeGlow( pic );
}
static rgbdata_t *R_ParseStudioSkin( script_t *script, int *samples, texFlags_t *flags )
static rgbdata_t *R_ParseStudioSkin( script_t *script, const byte *buf, size_t size, int *samples, texFlags_t *flags )
{
token_t token;
rgbdata_t *pic;
@ -2296,6 +2296,37 @@ static rgbdata_t *R_ParseSpriteFrame( script_t *script, const byte *buf, size_t
return pic;
}
static rgbdata_t *R_ParseAliasSkin( script_t *script, const byte *buf, size_t size, int *samples, texFlags_t *flags )
{
token_t token;
rgbdata_t *pic;
Com_ReadToken( script, 0, &token );
if( com.stricmp( token.string, "(" ))
{
MsgDev( D_WARN, "expected '(', found '%s' instead for 'Alias'\n", token.string );
return NULL;
}
if( !Com_ReadToken( script, SC_ALLOW_PATHNAMES2, &token ))
{
MsgDev( D_WARN, "missing parameters for 'Alias'\n" );
return NULL;
}
pic = R_LoadImage( script, va( "#%s.mdl", token.string ), buf, size, samples, flags );
if( !pic ) return NULL;
Com_ReadToken( script, 0, &token );
if( com.stricmp( token.string, ")" ))
{
MsgDev( D_WARN, "expected ')', found '%s' instead for 'Alias'\n", token.string );
FS_FreeImage( pic );
return NULL;
}
return pic;
}
/*
=================
R_ParseScrapBlock
@ -2722,7 +2753,9 @@ static rgbdata_t *R_LoadImage( script_t *script, const char *name, const byte *b
else if( !com.stricmp( name, "clearPixels" ))
return R_ParseClearPixels( script, samples, flags );
else if( !com.stricmp( name, "Studio" ))
return R_ParseStudioSkin( script, samples, flags );
return R_ParseStudioSkin( script, buf, size, samples, flags );
else if( !com.stricmp( name, "Alias" ))
return R_ParseAliasSkin( script, buf, size, samples, flags );
else if( !com.stricmp( name, "Sprite" ))
return R_ParseSpriteFrame( script, buf, size, samples, flags );
else

3
render/r_model.h
View File

@ -226,10 +226,9 @@ typedef struct
int numposes;
int poseverts;
int posedata; // numposes*poseverts trivert_t
int posedata; // numposes * poseverts trivert_t
int commands; // gl command list with embedded s/t
ref_shader_t *skins[MAX_SKINS][4];
int texels[MAX_SKINS]; // only for player skins
maliasframedesc_t frames[1]; // variable sized
} maliashdr_t;

136
render/r_shader.c
View File

@ -56,11 +56,11 @@ static waveFunc_t r_currentRGBgenFuncs[MAX_SHADER_STAGES], r_currentAlphagenFunc
static tcMod_t r_currentTcmods[MAX_SHADER_STAGES][MAX_SHADER_TCMODS];
static vec4_t r_currentTcGen[MAX_SHADER_STAGES][2];
const char *r_skyBoxSuffix[6] = { "rt", "bk", "lf", "ft", "up", "dn" }; // FIXME: get rid of this
static texture_t *r_spriteTexture[MAX_STAGE_TEXTURES]; // MAX_FRAMES in spritegen.c
static kRenderMode_t r_spriteRenderMode; // sprite or studiomodel rendermode
static int r_numSpriteTextures; // num textures in group
static float r_spriteFrequency; // sprite group auto-animate
static bool r_spriteTwoSided;
static texture_t *r_stageTexture[MAX_STAGE_TEXTURES]; // MAX_FRAMES in spritegen.c
static kRenderMode_t r_shaderRenderMode; // sprite, alias or studiomodel rendermode
static int r_numStageTextures; // num textures in group
static float r_stageAnimFrequency; // for auto-animate groups
static bool r_shaderTwoSided;
static bool r_shaderNoMipMaps;
static bool r_shaderNoPicMip;
static bool r_shaderNoCompress;
@ -2481,6 +2481,7 @@ void R_ShaderList_f( void )
Msg( "mdl " );
break;
case SHADER_ALIAS:
case SHADER_ALIAS_MD3:
Msg( "alias" );
break;
case SHADER_FONT:
@ -2603,12 +2604,12 @@ void R_InitShaders( void )
// init sprite frames
for( i = 0; i < MAX_STAGE_TEXTURES; i++ )
r_spriteTexture[i] = tr.defaultTexture;
r_stageTexture[i] = tr.defaultTexture;
r_spriteTwoSided = 0;
r_spriteFrequency = 0.0f;
r_numSpriteTextures = 0;
r_spriteRenderMode = kRenderNormal;
r_shaderTwoSided = 0;
r_stageAnimFrequency = 0.0f;
r_numStageTextures = 0;
r_shaderRenderMode = kRenderNormal;
R_RegisterBuiltinShaders ();
}
@ -3158,6 +3159,11 @@ void Shader_Finish( ref_shader_t *s )
for( i = 0, pass = s->stages; i < s->num_stages; i++, pass++ )
{
if( pass->flags & SHADERSTAGE_ANIMFREQUENCY && pass->anim_offset == 0 )
{
pass->anim_offset = pass->num_textures; // alt-anim is missing
pass->animFrequency[1] = 0.0f;
}
if( pass->cinHandle )
s->flags |= SHADER_VIDEOMAP;
if( pass->flags & SHADERSTAGE_LIGHTMAP )
@ -3350,8 +3356,8 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
pass->tcgen = TCGEN_BASE;
pass->num_textures++;
break;
case SHADER_ALIAS:
shader->type = SHADER_ALIAS;
case SHADER_ALIAS_MD3:
shader->type = SHADER_ALIAS_MD3;
shader->flags = SHADER_DEPTHWRITE|SHADER_CULL_FRONT;
shader->features = MF_STCOORDS|MF_NORMALS;
shader->sort = SORT_OPAQUE;
@ -3385,6 +3391,55 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
shader->flags |= SHADER_MATERIAL;
}
break;
case SHADER_ALIAS:
shader->type = SHADER_ALIAS;
shader->flags = SHADER_DEPTHWRITE|SHADER_CULL_FRONT;
shader->features = MF_STCOORDS;
shader->num_stages = 1;
shader->name = Shader_Malloc( length + 1 + sizeof( ref_stage_t ) * shader->num_stages );
strcpy( shader->name, shortname );
shader->stages = ( ref_stage_t * )(( byte * )shader->name + length + 1 );
pass = &shader->stages[0];
pass->tcgen = TCGEN_BASE;
if( r_numStageTextures > 1 )
{
// store group frames into one stage
pass->flags |= SHADERSTAGE_FRAMES;
if( r_stageAnimFrequency != 0.0f )
{
pass->flags |= SHADERSTAGE_ANIMFREQUENCY;
pass->animFrequency[0] = r_stageAnimFrequency;
}
for( i = 0; i < r_numStageTextures; i++ )
{
if( !r_stageTexture[i] ) pass->textures[i] = tr.defaultTexture;
else pass->textures[i] = r_stageTexture[i];
pass->num_textures++;
}
}
else
{
// single frame
pass->textures[0] = r_stageTexture[0];
pass->num_textures++;
if( !pass->textures[0] )
{
MsgDev( D_WARN, "couldn't find alias skin for shader '%s', using default...\n", shader->name );
pass->textures[0] = tr.defaultTexture;
}
}
// NOTE: all alias models allow to change their rendermodes but using kRenderNormal as default
pass->flags |= SHADERSTAGE_RENDERMODE;
pass->glState = GLSTATE_DEPTHWRITE;
pass->rgbGen.type = RGBGEN_LIGHTING_AMBIENT_ONLY;
pass->alphaGen.type = ALPHAGEN_IDENTITY;
shader->sort = SORT_OPAQUE;
break;
case SHADER_STUDIO:
shader->type = SHADER_STUDIO;
shader->flags = SHADER_DEPTHWRITE|SHADER_CULL_FRONT;
@ -3396,17 +3451,17 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
pass = &shader->stages[0];
pass->tcgen = TCGEN_BASE;
if( r_spriteRenderMode == kRenderTransAlpha ) // ignore mips for alpha-textures
if( r_shaderRenderMode == kRenderTransAlpha ) // ignore mips for alpha-textures
pass->textures[0] = R_FindTexture( va( "Studio( \"%s\" );", shader->name ), NULL, 0, addFlags|TF_CLAMP|TF_NOMIPMAP );
else pass->textures[0] = R_FindTexture( va( "Studio( \"%s\" );", shader->name ), NULL, 0, addFlags );
if( !pass->textures[0] )
{
MsgDev( D_WARN, "couldn't find studio texture for shader '%s', using default...\n", shader->name );
MsgDev( D_WARN, "couldn't find studio skin for shader '%s', using default...\n", shader->name );
pass->textures[0] = tr.defaultTexture;
}
pass->num_textures++;
switch( r_spriteRenderMode )
switch( r_shaderRenderMode )
{
case kRenderTransTexture:
// normal transparency
@ -3442,7 +3497,7 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
case SHADER_SPRITE:
shader->type = SHADER_SPRITE;
shader->flags = SHADER_DEPTHWRITE|SHADER_RENDERMODE;
shader->flags |= (r_spriteTwoSided) ? 0 : SHADER_CULL_FRONT;
shader->flags |= (r_shaderTwoSided) ? 0 : SHADER_CULL_FRONT;
shader->features = MF_STCOORDS|MF_COLORS;
shader->num_stages = 1;
shader->name = Shader_Malloc( length + 1 + sizeof( ref_stage_t ) * shader->num_stages );
@ -3450,28 +3505,31 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
shader->stages = (ref_stage_t *)( ( byte * )shader->name + length + 1 );
pass = &shader->stages[0];
pass->tcgen = TCGEN_BASE;
if( r_spriteFrequency == 0.0f && r_numSpriteTextures == 8 )
if( r_stageAnimFrequency == 0.0f && r_numStageTextures == 8 )
{
// store angled map into one bundle
pass->flags |= SHADERSTAGE_ANGLEDMAP;
for( i = 0; i < 8; i++ )
{
if( !r_spriteTexture[i] ) pass->textures[i] = tr.defaultTexture;
else pass->textures[i] = r_spriteTexture[i];
if( !r_stageTexture[i] ) pass->textures[i] = tr.defaultTexture;
else pass->textures[i] = r_stageTexture[i];
pass->num_textures++;
}
}
else if( r_numSpriteTextures > 1 )
else if( r_numStageTextures > 1 )
{
// store group frames into one stage
pass->flags |= SHADERSTAGE_FRAMES;
pass->animFrequency[0] = r_spriteFrequency;
for( i = 0; i < r_numSpriteTextures; i++ )
if( r_stageAnimFrequency != 0.0f )
{
if( !r_spriteTexture[i] ) pass->textures[i] = tr.defaultTexture;
else pass->textures[i] = r_spriteTexture[i];
pass->flags |= SHADERSTAGE_ANIMFREQUENCY;
pass->animFrequency[0] = r_stageAnimFrequency;
}
for( i = 0; i < r_numStageTextures; i++ )
{
if( !r_stageTexture[i] ) pass->textures[i] = tr.defaultTexture;
else pass->textures[i] = r_stageTexture[i];
pass->num_textures++;
}
@ -3479,7 +3537,7 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
else
{
// single frame
pass->textures[0] = r_spriteTexture[0];
pass->textures[0] = r_stageTexture[0];
pass->num_textures++;
if( !pass->textures[0] )
@ -3491,7 +3549,7 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
pass->flags |= SHADERSTAGE_RENDERMODE; // any sprite can overrided himself rendermode
switch( r_spriteRenderMode )
switch( r_shaderRenderMode )
{
case kRenderTransTexture:
// normal transparency
@ -3761,10 +3819,10 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
}
// reset parms
r_spriteTwoSided = 0;
r_numSpriteTextures = 0;
r_spriteFrequency = 0.0f;
r_spriteRenderMode = kRenderNormal;
r_shaderTwoSided = 0;
r_numStageTextures = 0;
r_stageAnimFrequency = 0.0f;
r_shaderRenderMode = kRenderNormal;
Shader_SetRenderMode( shader );
@ -3909,21 +3967,21 @@ void R_ShaderFreeUnused( void )
}
}
void R_ShaderSetSpriteTexture( texture_t *mipTex, bool twoSided )
void R_ShaderAddStageTexture( texture_t *mipTex )
{
if( r_numSpriteTextures >= MAX_STAGE_TEXTURES ) return;
r_spriteTexture[r_numSpriteTextures++] = mipTex;
r_spriteTwoSided = twoSided;
if( r_numStageTextures >= MAX_STAGE_TEXTURES ) return;
r_stageTexture[r_numStageTextures++] = mipTex;
}
void R_ShaderSetRenderMode( kRenderMode_t mode )
void R_ShaderSetRenderMode( kRenderMode_t mode, bool twoSided )
{
r_spriteRenderMode = mode;
r_shaderRenderMode = mode;
r_shaderTwoSided = twoSided;
}
void R_ShaderAddSpriteIntervals( float interval )
void R_ShaderAddStageIntervals( float interval )
{
r_spriteFrequency += interval;
r_stageAnimFrequency += interval;
}
/*

7
render/r_shader.h
View File

@ -48,6 +48,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#define SHADER_PLANAR_SHADOW 13
#define SHADER_OPAQUE_OCCLUDER 14
#define SHADER_OUTLINE 15
#define SHADER_ALIAS_MD3 16 // to be removed ...
// shader flags
typedef enum
@ -354,9 +355,9 @@ void R_ShaderFreeUnused( void );
float R_LookupTable( int tableIndex, float index );
float *R_GetTableByHandle( int tableIndex );
void Shader_TouchImages( ref_shader_t *shader, bool free_unused );
void R_ShaderSetSpriteTexture( texture_t *mipTex, bool twoSided );
void R_ShaderSetRenderMode( kRenderMode_t mode );
void R_ShaderAddSpriteIntervals( float interval );
void R_ShaderAddStageTexture( texture_t *mipTex );
void R_ShaderSetRenderMode( kRenderMode_t mode, bool twoSided );
void R_ShaderAddStageIntervals( float interval );
void R_UploadCinematicShader( const ref_shader_t *shader );
void R_DeformvBBoxForShader( const ref_shader_t *shader, vec3_t ebbox );

2
render/r_skin.c
View File

@ -124,7 +124,7 @@ static int SkinFile_ParseBuffer( char *buffer, mesh_shader_pair_t *pairs )
if( pairs )
{
pairs[numpairs].meshname = SkinFile_CopyString( meshname );
pairs[numpairs].shader = R_LoadShader( skinname, SHADER_ALIAS, false, 0, SHADER_INVALID );
pairs[numpairs].shader = R_LoadShader( skinname, SHADER_ALIAS_MD3, false, 0, SHADER_INVALID );
}
numpairs++;
}

18
render/r_sprite.c
View File

@ -19,7 +19,6 @@ string frame_prefix;
uint frame_type;
uint group_num;
string sp_name;
bool cull_none = false;
ref_shader_t **frames = NULL;
/*
@ -53,7 +52,7 @@ dframetype_t *R_SpriteLoadFrame( ref_model_t *mod, void *pin, mspriteframe_t **p
tex = R_FindTexture( name, (byte *)pin, pinframe->width * pinframe->height, 0 );
*ppframe = pspriteframe;
R_ShaderSetSpriteTexture( tex, cull_none );
R_ShaderAddStageTexture( tex );
if( frame_type == FRAME_SINGLE )
{
@ -92,7 +91,7 @@ dframetype_t *R_SpriteLoadGroup( ref_model_t *mod, void * pin, mspriteframe_t **
{
*poutintervals = LittleFloat( pin_intervals->interval );
if( *poutintervals <= 0.0 ) *poutintervals = 1.0f; // set error value
if( frame_type == FRAME_GROUP ) R_ShaderAddSpriteIntervals( *poutintervals );
if( frame_type == FRAME_GROUP ) R_ShaderAddStageIntervals( *poutintervals );
poutintervals++;
pin_intervals++;
}
@ -123,6 +122,7 @@ void Mod_SpriteLoadModel( ref_model_t *mod, ref_model_t *parent, const void *buf
msprite_t *psprite;
dframetype_t *pframetype;
int i, size, numframes;
bool twoSided;
pin = (dsprite_t *)buffer;
i = LittleLong( pin->version );
@ -143,7 +143,7 @@ void Mod_SpriteLoadModel( ref_model_t *mod, ref_model_t *parent, const void *buf
psprite->type = LittleLong( pin->type );
psprite->rendermode = LittleLong( pin->texFormat );
psprite->numframes = numframes;
cull_none = (LittleLong( pin->facetype == SPR_CULL_NONE )) ? true : false;
twoSided = (LittleLong( pin->facetype == SPR_CULL_NONE )) ? true : false;
mod->mins[0] = mod->mins[1] = -LittleLong( pin->bounds[0] ) / 2;
mod->maxs[0] = mod->maxs[1] = LittleLong( pin->bounds[0] ) / 2;
mod->mins[2] = -LittleLong( pin->bounds[1] ) / 2;
@ -160,24 +160,24 @@ void Mod_SpriteLoadModel( ref_model_t *mod, ref_model_t *parent, const void *buf
{
case SPR_ADDGLOW:
pal = FS_LoadImage( "#normal.pal", src, 768 );
R_ShaderSetRenderMode( kRenderGlow );
R_ShaderSetRenderMode( kRenderGlow, twoSided );
break;
case SPR_ADDITIVE:
pal = FS_LoadImage( "#normal.pal", src, 768 );
R_ShaderSetRenderMode( kRenderTransAdd );
R_ShaderSetRenderMode( kRenderTransAdd, twoSided );
break;
case SPR_INDEXALPHA:
pal = FS_LoadImage( "#decal.pal", src, 768 );
R_ShaderSetRenderMode( kRenderTransAlpha );
R_ShaderSetRenderMode( kRenderTransAlpha, twoSided );
break;
case SPR_ALPHTEST:
pal = FS_LoadImage( "#transparent.pal", src, 768 );
R_ShaderSetRenderMode( kRenderTransAlpha );
R_ShaderSetRenderMode( kRenderTransAlpha, twoSided );
break;
case SPR_NORMAL:
default:
pal = FS_LoadImage( "#normal.pal", src, 768 );
R_ShaderSetRenderMode( kRenderNormal );
R_ShaderSetRenderMode( kRenderNormal, twoSided );
break;
}
pframetype = (dframetype_t *)(src + 768);

8
render/r_studio.c
View File

@ -134,12 +134,12 @@ Studio model loader
void R_StudioSurfaceParm( dstudiotexture_t *tex )
{
if( tex->flags & STUDIO_NF_TRANSPARENT )
R_ShaderSetRenderMode( kRenderTransAlpha );
R_ShaderSetRenderMode( kRenderTransAlpha, false );
else if( tex->flags & STUDIO_NF_ADDITIVE )
R_ShaderSetRenderMode( kRenderTransAdd );
R_ShaderSetRenderMode( kRenderTransAdd, false );
else if( tex->flags & STUDIO_NF_BLENDED )
R_ShaderSetRenderMode( kRenderTransTexture );
else R_ShaderSetRenderMode( kRenderNormal );
R_ShaderSetRenderMode( kRenderTransTexture, false );
else R_ShaderSetRenderMode( kRenderNormal, false );
}
dstudiohdr_t *R_StudioLoadHeader( ref_model_t *mod, const uint *buffer )

65
render/render.plg
View File

@ -1,65 +0,0 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: render - Win32 Release--------------------
</h3>
<h3>Command Lines</h3>
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP3B23.tmp" with contents
[
/nologo /MD /W3 /GX /O2 /I "../public" /I "../common" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /Fo"..\temp\render\!release/" /Fd"..\temp\render\!release/" /FD /c
"D:\Xash3D\src_main\render\r_aliasq.c"
]
Creating command line "cl.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP3B23.tmp"
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP3B24.tmp" with contents
[
msvcrt.lib user32.lib gdi32.lib /nologo /subsystem:windows /dll /pdb:none /machine:I386 /nodefaultlib:"libc.lib" /out:"..\temp\render\!release/render.dll" /implib:"..\temp\render\!release/render.lib" /libpath:"../public/libs/"
"\Xash3D\src_main\temp\render\!release\cin.obj"
"\Xash3D\src_main\temp\render\!release\r_alias.obj"
"\Xash3D\src_main\temp\render\!release\r_backend.obj"
"\Xash3D\src_main\temp\render\!release\r_bloom.obj"
"\Xash3D\src_main\temp\render\!release\r_cin.obj"
"\Xash3D\src_main\temp\render\!release\r_cull.obj"
"\Xash3D\src_main\temp\render\!release\r_draw.obj"
"\Xash3D\src_main\temp\render\!release\r_image.obj"
"\Xash3D\src_main\temp\render\!release\r_light.obj"
"\Xash3D\src_main\temp\render\!release\r_main.obj"
"\Xash3D\src_main\temp\render\!release\r_math.obj"
"\Xash3D\src_main\temp\render\!release\r_mesh.obj"
"\Xash3D\src_main\temp\render\!release\r_model.obj"
"\Xash3D\src_main\temp\render\!release\r_opengl.obj"
"\Xash3D\src_main\temp\render\!release\r_poly.obj"
"\Xash3D\src_main\temp\render\!release\r_program.obj"
"\Xash3D\src_main\temp\render\!release\r_register.obj"
"\Xash3D\src_main\temp\render\!release\r_shader.obj"
"\Xash3D\src_main\temp\render\!release\r_shadow.obj"
"\Xash3D\src_main\temp\render\!release\r_skin.obj"
"\Xash3D\src_main\temp\render\!release\r_sky.obj"
"\Xash3D\src_main\temp\render\!release\r_sprite.obj"
"\Xash3D\src_main\temp\render\!release\r_studio.obj"
"\Xash3D\src_main\temp\render\!release\r_surf.obj"
"\Xash3D\src_main\temp\render\!release\r_aliasq.obj"
]
Creating command line "link.exe @C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP3B24.tmp"
Creating temporary file "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP3B25.bat" with contents
[
@echo off
copy \Xash3D\src_main\temp\render\!release\render.dll "D:\Xash3D\bin\render.dll"
]
Creating command line "C:\DOCUME~1\MIKE~1.MIK\LOCALS~1\Temp\RSP3B25.bat"
Compiling...
r_aliasq.c
Linking...
Creating library ..\temp\render\!release/render.lib and object ..\temp\render\!release/render.exp
<h3>Output Window</h3>
Performing Custom Build Step on \Xash3D\src_main\temp\render\!release\render.dll
‘ª®¯¨à®¢ ­® ä ©«®¢: 1.
<h3>Results</h3>
render.dll - 0 error(s), 0 warning(s)
</pre>
</body>
</html>

16
server/server.plg
View File

@ -1,16 +0,0 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: server - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
<h3>Results</h3>
server.dll - 0 error(s), 0 warning(s)
</pre>
</body>
</html>

16
vprogs/vprogs.plg
View File

@ -1,16 +0,0 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: vprogs - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
<h3>Results</h3>
vprogs.dll - 0 error(s), 0 warning(s)
</pre>
</body>
</html>

16
vsound/vsound.plg
View File

@ -1,16 +0,0 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: vsound - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
<h3>Results</h3>
vsound.dll - 0 error(s), 0 warning(s)
</pre>
</body>
</html>

16
xtools/xtools.plg
View File

@ -1,16 +0,0 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: xtools - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
<h3>Results</h3>
xtools.dll - 0 error(s), 0 warning(s)
</pre>
</body>
</html>