354 lines
8.9 KiB
C++
354 lines
8.9 KiB
C++
/*
|
|
* UNPUBLISHED -- Rights reserved under the copyright laws of the
|
|
* United States. Use of a copyright notice is precautionary only and
|
|
* does not imply publication or disclosure.
|
|
*
|
|
* THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION
|
|
* OF BLIZZARD ENTERTAINMENT. ANY DUPLICATION, MODIFICATION,
|
|
* DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR
|
|
* EXPRESS WRITTEN PERMISSION OF BLIZZARD ENTERTAINMENT.
|
|
*/
|
|
|
|
#include "../types.h"
|
|
|
|
PALETTEENTRY logical_palette[256];
|
|
int palette_cpp_init_value; // weak
|
|
PALETTEENTRY system_palette[256];
|
|
PALETTEENTRY orig_palette[256];
|
|
UINT gdwPalEntries;
|
|
|
|
int palette_inf = 0x7F800000; // weak
|
|
|
|
/* rdata */
|
|
|
|
int gamma_correction = 100; // idb
|
|
int color_cycling_enabled = 1; // idb
|
|
bool sgbFadedIn = 1;
|
|
|
|
//----- (00448DFA) --------------------------------------------------------
|
|
struct palette_cpp_init
|
|
{
|
|
palette_cpp_init()
|
|
{
|
|
palette_cpp_init_value = palette_inf;
|
|
}
|
|
} _palette_cpp_init;
|
|
// 47F16C: using guessed type int palette_inf;
|
|
// 67DBCC: using guessed type int palette_cpp_init_value;
|
|
|
|
//----- (00448E05) --------------------------------------------------------
|
|
void __cdecl palette_save_gamme()
|
|
{
|
|
SRegSaveValue("Diablo", "Gamma Correction", 0, gamma_correction);
|
|
SRegSaveValue("Diablo", "Color Cycling", 0, color_cycling_enabled);
|
|
}
|
|
|
|
//----- (00448E33) --------------------------------------------------------
|
|
void __cdecl palette_init()
|
|
{
|
|
int v0; // eax
|
|
int v1; // eax
|
|
|
|
palette_load_gamma();
|
|
memcpy(system_palette, orig_palette, 0x400u);
|
|
LoadSysPal();
|
|
v0 = lpDDInterface->CreatePalette(DDPCAPS_ALLOW256|DDPCAPS_8BIT, system_palette, &lpDDPalette, NULL);
|
|
if ( v0 )
|
|
TermDlg(111, v0, "C:\\Src\\Diablo\\Source\\PALETTE.CPP", 143);
|
|
v1 = lpDDSPrimary->SetPalette(lpDDPalette);
|
|
if ( v1 )
|
|
TermDlg(111, v1, "C:\\Src\\Diablo\\Source\\PALETTE.CPP", 146);
|
|
}
|
|
|
|
//----- (00448EAB) --------------------------------------------------------
|
|
void __cdecl palette_load_gamma()
|
|
{
|
|
int v3; // eax
|
|
int value; // [esp+8h] [ebp-4h]
|
|
|
|
value = gamma_correction;
|
|
if ( !SRegLoadValue("Diablo", "Gamma Correction", 0, &value) )
|
|
value = 100;
|
|
if ( value >= 30 )
|
|
{
|
|
if ( value > 100 )
|
|
value = 100;
|
|
}
|
|
else
|
|
{
|
|
value = 30;
|
|
}
|
|
gamma_correction = value - value % 5;
|
|
if ( SRegLoadValue("Diablo", "Color Cycling", 0, &value) )
|
|
v3 = value;
|
|
else
|
|
v3 = 1;
|
|
color_cycling_enabled = v3;
|
|
}
|
|
|
|
//----- (00448F20) --------------------------------------------------------
|
|
void __cdecl LoadSysPal()
|
|
{
|
|
HDC hDC; // ebx
|
|
int i; // ecx
|
|
int iStartIndex; // edi
|
|
|
|
for(i = 0; i < 256; i++)
|
|
system_palette[i].peFlags = PC_NOCOLLAPSE|PC_RESERVED;
|
|
|
|
if ( !fullscreen )
|
|
{
|
|
hDC = GetDC(NULL);
|
|
gdwPalEntries = GetDeviceCaps(hDC, NUMRESERVED) / 2;
|
|
GetSystemPaletteEntries(hDC, 0, gdwPalEntries, system_palette);
|
|
for ( i = 0; i < gdwPalEntries; i++ )
|
|
system_palette[i].peFlags = 0;
|
|
iStartIndex = 256 - gdwPalEntries;
|
|
GetSystemPaletteEntries(hDC, iStartIndex, gdwPalEntries, &system_palette[iStartIndex]);
|
|
if ( iStartIndex < 256 )
|
|
{
|
|
for(i = iStartIndex; i < 256; i++)
|
|
system_palette[i].peFlags = 0;
|
|
}
|
|
ReleaseDC(NULL, hDC);
|
|
}
|
|
}
|
|
// 484364: using guessed type int fullscreen;
|
|
|
|
//----- (00448FC9) --------------------------------------------------------
|
|
void __fastcall LoadPalette(char *pszFileName)
|
|
{
|
|
int i; // eax
|
|
char PalData[256][3]; // [esp+0h] [ebp-304h]
|
|
void *pBuf; // [esp+300h] [ebp-4h]
|
|
|
|
WOpenFile(pszFileName, &pBuf, 0);
|
|
WReadFile(pBuf, (char *)PalData, 768);
|
|
WCloseFile(pBuf);
|
|
|
|
for(i = 0; i < 256; i++)
|
|
{
|
|
orig_palette[i].peFlags = 0;
|
|
orig_palette[i].peRed = PalData[i][0];
|
|
orig_palette[i].peGreen = PalData[i][1];
|
|
orig_palette[i].peBlue = PalData[i][2];
|
|
}
|
|
}
|
|
|
|
//----- (00449025) --------------------------------------------------------
|
|
void __fastcall LoadRndLvlPal(int l)
|
|
{
|
|
char *pszPal; // ecx
|
|
char szTemp[260]; // [esp+4h] [ebp-104h]
|
|
|
|
if ( l )
|
|
{
|
|
sprintf(szTemp, "Levels\\L%iData\\L%i_%i.PAL", l, l, random(0, 4) + 1);
|
|
pszPal = szTemp;
|
|
}
|
|
else
|
|
{
|
|
pszPal = "Levels\\TownData\\Town.pal";
|
|
}
|
|
LoadPalette(pszPal);
|
|
}
|
|
|
|
//----- (0044906C) --------------------------------------------------------
|
|
void __cdecl ResetPal()
|
|
{
|
|
if ( !lpDDSPrimary
|
|
|| lpDDSPrimary->IsLost() != DDERR_SURFACELOST
|
|
|| !lpDDSPrimary->Restore() )
|
|
{
|
|
SDrawRealizePalette();
|
|
}
|
|
}
|
|
|
|
//----- (00449097) --------------------------------------------------------
|
|
void __cdecl palette_inc_gamma()
|
|
{
|
|
if ( gamma_correction < 100 )
|
|
{
|
|
gamma_correction += 5;
|
|
if ( gamma_correction > 100 )
|
|
gamma_correction = 100;
|
|
palette_apply_gamma_correction(system_palette, logical_palette, 256);
|
|
palette_update();
|
|
}
|
|
}
|
|
|
|
//----- (004490D0) --------------------------------------------------------
|
|
void __cdecl palette_update()
|
|
{
|
|
int v0; // ecx
|
|
int v1; // eax
|
|
|
|
if ( lpDDPalette )
|
|
{
|
|
v0 = 0;
|
|
v1 = 256;
|
|
if ( !fullscreen )
|
|
{
|
|
v0 = gdwPalEntries;
|
|
v1 = 2 * (128 - gdwPalEntries);
|
|
}
|
|
SDrawUpdatePalette(v0, v1, &system_palette[v0], 0);
|
|
}
|
|
}
|
|
// 484364: using guessed type int fullscreen;
|
|
|
|
//----- (00449107) --------------------------------------------------------
|
|
void __fastcall palette_apply_gamma_correction(PALETTEENTRY *dst, PALETTEENTRY *src, int n)
|
|
{
|
|
PALETTEENTRY *v3; // edi
|
|
PALETTEENTRY *v4; // esi
|
|
double v5; // [esp+18h] [ebp-Ch]
|
|
|
|
v3 = src;
|
|
v4 = dst;
|
|
v5 = (double)gamma_correction * 0.01;
|
|
if ( n > 0 )
|
|
{
|
|
do
|
|
{
|
|
v4->peRed = pow(v3->peRed * 0.00390625, v5) * 256.0;
|
|
v4->peGreen = pow(v3->peGreen * 0.00390625, v5) * 256.0;
|
|
v4->peBlue = pow(v3->peBlue * 0.00390625, v5) * 256.0;
|
|
++v4;
|
|
++v3;
|
|
--n;
|
|
}
|
|
while ( n );
|
|
}
|
|
}
|
|
|
|
//----- (004491D0) --------------------------------------------------------
|
|
void __cdecl palette_dec_gamma()
|
|
{
|
|
if ( gamma_correction > 30 )
|
|
{
|
|
gamma_correction -= 5;
|
|
if ( gamma_correction < 30 )
|
|
gamma_correction = 30;
|
|
palette_apply_gamma_correction(system_palette, logical_palette, 256);
|
|
palette_update();
|
|
}
|
|
}
|
|
|
|
//----- (00449209) --------------------------------------------------------
|
|
int __fastcall palette_update_gamma(int gamma)
|
|
{
|
|
if ( gamma )
|
|
{
|
|
gamma_correction = 130 - gamma;
|
|
palette_apply_gamma_correction(system_palette, logical_palette, 256);
|
|
palette_update();
|
|
}
|
|
return 130 - gamma_correction;
|
|
}
|
|
|
|
//----- (0044923E) --------------------------------------------------------
|
|
void __cdecl BlackPalette()
|
|
{
|
|
SetFadeLevel(0);
|
|
}
|
|
|
|
//----- (00449245) --------------------------------------------------------
|
|
void __fastcall SetFadeLevel(int fadeval)
|
|
{
|
|
int i; // eax
|
|
|
|
if ( lpDDInterface )
|
|
{
|
|
for(i = 0; i < 255; i++)
|
|
{
|
|
system_palette[i].peRed = (fadeval * logical_palette[i].peRed) >> 8;
|
|
system_palette[i].peGreen = (fadeval * logical_palette[i].peGreen) >> 8;
|
|
system_palette[i].peBlue = (fadeval * logical_palette[i].peBlue) >> 8;
|
|
}
|
|
Sleep(3);
|
|
lpDDInterface->WaitForVerticalBlank(DDWAITVB_BLOCKBEGIN, NULL);
|
|
palette_update();
|
|
}
|
|
}
|
|
|
|
//----- (004492B0) --------------------------------------------------------
|
|
void __fastcall PaletteFadeIn(int fr)
|
|
{
|
|
int i; // ebp
|
|
|
|
palette_apply_gamma_correction(logical_palette, orig_palette, 256);
|
|
|
|
for(i = 0; i < 256; i += fr)
|
|
SetFadeLevel(i);
|
|
|
|
SetFadeLevel(256);
|
|
memcpy(logical_palette, orig_palette, 0x400u);
|
|
sgbFadedIn = 1;
|
|
}
|
|
|
|
//----- (00449306) --------------------------------------------------------
|
|
void __fastcall PaletteFadeOut(int fr)
|
|
{
|
|
int i; // esi
|
|
|
|
if ( sgbFadedIn )
|
|
{
|
|
for(i = 256; i > 0; i -= fr)
|
|
SetFadeLevel(i);
|
|
|
|
SetFadeLevel(0);
|
|
sgbFadedIn = 0;
|
|
}
|
|
}
|
|
|
|
//----- (00449336) --------------------------------------------------------
|
|
void __cdecl palette_update_caves()
|
|
{
|
|
BYTE v0; // cx
|
|
signed int v1; // esi
|
|
signed int v2; // eax
|
|
BYTE v4; // [esp+6h] [ebp-2h]
|
|
BYTE v5;
|
|
|
|
v0 = system_palette[1].peRed;
|
|
v5 = system_palette[1].peGreen;
|
|
v4 = system_palette[1].peBlue;
|
|
v1 = 1;
|
|
do
|
|
{
|
|
v2 = v1++;
|
|
system_palette[v2].peRed = system_palette[v2 + 1].peRed;
|
|
system_palette[v2].peGreen = system_palette[v2 + 1].peGreen;
|
|
system_palette[v2].peBlue = system_palette[v2 + 1].peBlue;
|
|
}
|
|
while ( v1 < 31 );
|
|
system_palette[v1].peRed = v0;
|
|
system_palette[v1].peGreen = v5;
|
|
system_palette[v1].peBlue = v4;
|
|
palette_update();
|
|
}
|
|
|
|
//----- (00449398) --------------------------------------------------------
|
|
void __fastcall palette_update_quest_palette(int n)
|
|
{
|
|
int i; // eax
|
|
|
|
for ( i = 32 - n; i >= 0; --i )
|
|
logical_palette[i] = orig_palette[i];
|
|
palette_apply_gamma_correction(system_palette, logical_palette, 32);
|
|
palette_update();
|
|
}
|
|
|
|
//----- (004493C6) --------------------------------------------------------
|
|
bool __cdecl palette_get_colour_cycling()
|
|
{
|
|
return color_cycling_enabled;
|
|
}
|
|
|
|
//----- (004493CC) --------------------------------------------------------
|
|
void __fastcall palette_set_color_cycling(bool enabled)
|
|
{
|
|
color_cycling_enabled = enabled;
|
|
}
|