tiberium/CnC_Remastered_Collection
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial Source Code commit

Browse source 
Initial commit of original Tiberian Dawn and Red Alert source code converted to build as DLLs, and compatible with the release version of Command & Conquer Remastered.
This commit is contained in:
PG-SteveT 2020-05-27 12:16:20 -07:00
parent ea8ecc76fa
commit 03416d24e1
1038 changed files with 629779 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

938
TIBERIANDAWN/WINSTUB.CPP Normal file
View file

@ -0,0 +1,938 @@
//
// Copyright 2020 Electronic Arts Inc.
//
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
/***********************************************************************************************
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
***********************************************************************************************
* *
* Project Name : Command & Conquer *
* *
* File Name : WINSTUB.CPP *
* *
* Programmer : Steve Tall *
* *
* Start Date : 10/04/95 *
* *
* Last Update : October 4th 1995 [ST] *
* *
*---------------------------------------------------------------------------------------------*
* Overview: *
* This file contains stubs for undefined externals when linked under Watcom for Win 95 *
* *
*---------------------------------------------------------------------------------------------*
* *
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "function.h"
#include "tcpip.h"
void output(short,short)
{}
bool InDebugger = false;
bool ReadyToQuit = false;
#if (0)
/***************************************************************************
* Extract_Shape_Count -- returns # of shapes in the given shape block *
* *
* The # of shapes in a shape block is the first WORD in the block, so *
* this is the value returned. *
* *
* INPUT: *
* buffer pointer to shape block, created with MAKESHPS.EXE *
* *
* OUTPUT: *
* # shapes in the block *
* *
* WARNINGS: *
* none *
* *
* HISTORY: *
* 06/09/1992 JLB : Created. *
* 08/19/1993 SKB : Split drawshp.asm into several modules. *
* 05/25/1994 BR : Converted to 32-bit *
*=========================================================================*/
int __cdecl Extract_Shape_Count(VOID const *buffer)
{
ShapeBlock_Type *block = (ShapeBlock_Type *)buffer;
return (block->NumShapes);
} /* end of Extract_Shape_Count */
/***************************************************************************
* Extract_Shape -- Gets pointer to shape in given shape block *
* *
* INPUT: *
* buffer pointer to shape block, created with MAKESHPS.EXE *
* shape index of shape to get *
* *
* OUTPUT: *
* pointer to shape in the shape block *
* *
* WARNINGS: *
* none *
* *
* HISTORY: *
* 06/09/1992 JLB : Created. *
* 08/19/1993 SKB : Split drawshp.asm into several modules. *
* 05/25/1994 BR : Converted to 32-bit *
*=========================================================================*/
VOID * __cdecl Extract_Shape(VOID const *buffer, int shape)
{
ShapeBlock_Type *block = (ShapeBlock_Type*) buffer;
long offset; // Offset of shape data, from start of block
char *bytebuf = (char*) buffer;
/*
----------------------- Return if invalid argument -----------------------
*/
if (!buffer || shape < 0 || shape >= block->NumShapes)
return(NULL);
offset = block->Offsets[shape];
return(bytebuf + 2 + offset);
} /* end of Extract_Shape */
#endif //(0)
unsigned long CCFocusMessage = WM_USER+50; //Private message for receiving application focus
extern void VQA_PauseAudio(void);
extern void VQA_ResumeAudio(void);
ThemeType OldTheme = THEME_NONE;
/***********************************************************************************************
* Focus_Loss -- this function is called when a library function detects focus loss *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 2/1/96 2:10PM ST : Created *
*=============================================================================================*/
void Focus_Loss(void)
{
if (SoundOn){
if (OldTheme == THEME_NONE){
OldTheme = Theme.What_Is_Playing();
}
}
Theme.Stop();
Stop_Primary_Sound_Buffer();
if (WWMouse) WWMouse->Clear_Cursor_Clip();
}
void Focus_Restore(void)
{
Restore_Cached_Icons();
Map.Flag_To_Redraw(true);
Start_Primary_Sound_Buffer(TRUE);
if (WWMouse) WWMouse->Set_Cursor_Clip();
VisiblePage.Clear();
HiddenPage.Clear();
}
/***********************************************************************************************
* Check_For_Focus_Loss -- check for the end of the focus loss *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 2/2/96 10:49AM ST : Created *
*=============================================================================================*/
void Check_For_Focus_Loss(void)
{
// ST - 1/3/2019 10:40AM
#if (0)
static BOOL focus_last_time = 1;
MSG msg;
if ( !GameInFocus ){
Focus_Loss();
while( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE | PM_NOYIELD ) ){
if( !GetMessage( &msg, NULL, 0, 0 ) ){
return;
}
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
if (!focus_last_time && GameInFocus){
VQA_PauseAudio();
CountDownTimerClass cd;
cd.Set(60*1);
do {
while (PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE )) {
if( !GetMessage( &msg, NULL, 0, 0 ) ){
return;
}
TranslateMessage(&msg);
DispatchMessage(&msg);
}
} while(cd.Time());
VQA_ResumeAudio();
//AllSurfaces.Restore_Surfaces();
//VisiblePage.Clear();
//HiddenPage.Clear();
//Map.Flag_To_Redraw(true);
PostMessage (MainWindow, CCFocusMessage,0,0);
}
focus_last_time = GameInFocus;
#endif
}
extern BOOL InMovie;
#if (0) //PG_TO_FIX
long FAR PASCAL _export Windows_Procedure (HWND hwnd, UINT message, UINT wParam, LONG lParam)
{
int low_param = LOWORD(wParam);
if (message == CCFocusMessage){
Start_Primary_Sound_Buffer(TRUE);
if (!InMovie){
Theme.Queue_Song(OldTheme);
OldTheme = THEME_NONE;
}
return(0);
}
switch ( message ){
case WM_MOUSEMOVE:
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
case WM_KEYDOWN:
case WM_KEYUP:
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_LBUTTONDBLCLK:
case WM_MBUTTONDOWN:
case WM_MBUTTONUP:
case WM_MBUTTONDBLCLK:
case WM_RBUTTONDOWN:
case WM_RBUTTONUP:
case WM_RBUTTONDBLCLK:
Kbd.Message_Handler(hwnd, message, wParam, lParam);
return(0);
case WM_DESTROY:
CCDebugString ("C&C95 - WM_DESTROY message received.\n");
CCDebugString ("C&C95 - About to call Prog_End.\n");
Prog_End();
CCDebugString ("C&C95 - About to Invalidate_Cached_Icons.\n");
Invalidate_Cached_Icons();
CCDebugString ("C&C95 - About to release the video surfaces.\n");
VisiblePage.Un_Init();
HiddenPage.Un_Init();
AllSurfaces.Release();
if (!InDebugger){
CCDebugString ("C&C95 - About to reset the video mode.\n");
Reset_Video_Mode();
}
CCDebugString ("C&C95 - About to stop the profiler.\n");
Stop_Profiler();
CCDebugString ("C&C95 - Posting the quit message.\n");
PostQuitMessage( 0 );
/*
** If we are shutting down gracefully than flag that the message loop has finished.
** If this is a forced shutdown (ReadyToQuit == 0) then try and close down everything
** before we exit.
*/
if (ReadyToQuit){
CCDebugString ("C&C95 - We are now ready to quit.\n");
ReadyToQuit = 2;
}else{
CCDebugString ("C&C95 - Emergency shutdown.\n");
CCDebugString ("C&C95 - Shut down the network stuff.\n");
#ifndef DEMO
Shutdown_Network();
#endif
CCDebugString ("C&C95 - Kill the Winsock stuff.\n");
if (Winsock.Get_Connected()) Winsock.Close();
CCDebugString ("C&C95 - Call ExitProcess.\n");
ExitProcess(0);
}
CCDebugString ("C&C95 - Clean & ready to quit.\n");
return(0);
case WM_ACTIVATEAPP:
GameInFocus=(BOOL)wParam;
if (!GameInFocus) {
Focus_Loss();
}
AllSurfaces.Set_Surface_Focus (GameInFocus);
AllSurfaces.Restore_Surfaces();
// if (GameInFocus){
// Restore_Cached_Icons();
// Map.Flag_To_Redraw(true);
// Start_Primary_Sound_Buffer(TRUE);
// if (WWMouse) WWMouse->Set_Cursor_Clip();
// }
return(0);
#if (0)
case WM_ACTIVATE:
if (low_param == WA_INACTIVE){
GameInFocus = FALSE;
Focus_Loss();
}
return(0);
#endif //(0)
case WM_SYSCOMMAND:
switch ( wParam ) {
case SC_CLOSE:
/*
** Windows sent us a close message. Probably in response to Alt-F4. Ignore it by
** pretending to handle the message and returning 0;
*/
return (0);
case SC_SCREENSAVE:
/*
** Windoze is about to start the screen saver. If we just return without passing
** this message to DefWindowProc then the screen saver will not be allowed to start.
*/
return (0);
}
break;
#ifdef FORCE_WINSOCK
case WM_ACCEPT:
case WM_HOSTBYADDRESS:
case WM_HOSTBYNAME:
case WM_ASYNCEVENT:
case WM_UDPASYNCEVENT:
Winsock.Message_Handler(hwnd, message, wParam, lParam);
return (0);
#endif //FORCE_WINSOCK
}
return (DefWindowProc (hwnd, message, wParam, lParam));
}
#endif
/***********************************************************************************************
* Create_Main_Window -- opens the MainWindow for C&C *
* *
* *
* *
* INPUT: instance -- handle to program instance *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 10/10/95 4:08PM ST : Created *
*=============================================================================================*/
#define CC_ICON 1
int ShowCommand;
void Create_Main_Window ( HANDLE instance ,int command_show , int width , int height )
{
MainWindow = NULL;
return;
#if (0)
HWND hwnd ;
WNDCLASS wndclass ;
//
// Register the window class
//
wndclass.style = CS_HREDRAW | CS_VREDRAW ;
wndclass.lpfnWndProc = Windows_Procedure ;
wndclass.cbClsExtra = 0 ;
wndclass.cbWndExtra = 0 ;
wndclass.hInstance = instance ;
wndclass.hIcon = LoadIcon (instance, MAKEINTRESOURCE(CC_ICON)) ;
wndclass.hCursor = NULL;
wndclass.hbrBackground = NULL;
wndclass.lpszMenuName = "Command & Conquer"; //NULL
wndclass.lpszClassName = "Command & Conquer";
RegisterClass (&wndclass) ;
//
// Create our main window
//
hwnd = CreateWindowEx (
WS_EX_TOPMOST,
"Command & Conquer",
"Command & Conquer",
WS_POPUP | WS_MAXIMIZE,
0,
0,
width,
height,
NULL,
NULL,
instance,
NULL );
ShowWindow (hwnd, command_show );
ShowCommand = command_show;
UpdateWindow (hwnd);
SetFocus (hwnd);
MainWindow=hwnd; //Save the handle to our main window
hInstance = instance;
CCFocusMessage = RegisterWindowMessage ("CC_GOT_FOCUS");
Audio_Focus_Loss_Function = &Focus_Loss;
Misc_Focus_Loss_Function = &Focus_Loss;
Misc_Focus_Restore_Function = &Focus_Restore;
Gbuffer_Focus_Loss_Function = &Focus_Loss;
#endif
}
void Window_Dialog_Box(HANDLE hinst, LPCTSTR lpszTemplate, HWND hwndOwner, DLGPROC dlgprc)
{
#if (0)
MSG msg;
/*
** Get rid of the Westwood mouse cursor because we are showing a
** dialog box and we want to have the right windows cursor showing
** for it.
*/
Hide_Mouse();
ShowCursor(TRUE);
/*
** Pop up the dialog box and then run a standard message handler
** until the dialog box is closed.
*/
DialogBox(hinst, lpszTemplate, hwndOwner, dlgprc);
while (GetMessage(&msg, NULL, 0, 0) && !AllDone) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
/*
** Restore the westwood mouse cursor and get rid of the windows one
** because it is now time to restore back to the westwood way of
** doing things.
*/
ShowCursor(FALSE);
Show_Mouse();
#endif
}
typedef struct tColourList {
char Red;
char Green;
char Blue;
} ColourList;
ColourList ColourLookup[9]={
0,0,0,
63,0,0,
0,63,0,
0,0,63,
63,0,63,
63,63,0,
0,63,63,
32,32,32,
63,63,63
};
int DebugColour=1;
extern "C" void Set_Palette_Register(int number,int red ,int green ,int blue);
//#pragma off (unreferenced)
void Colour_Debug (int call_number)
{
//#if 0
//if (DebugColour==call_number || !call_number){
//if (call_number){
// Wait_Vert_Blank();
//}
// ST - 1/3/2019 10:43AM
//Set_Palette_Register (0,ColourLookup[call_number].Red ,
// ColourLookup[call_number].Green,
// ColourLookup[call_number].Blue);
//}
//#endif
}
//#pragma on (unreferenced)
BOOL Any_Locked (void)
{
if (SeenBuff.Get_LockCount() ||
HidPage.Get_LockCount()){
return (TRUE);
}else{
return(FALSE);
}
}
HANDLE DebugFile = INVALID_HANDLE_VALUE;
/***********************************************************************************************
* CCDebugString -- sends a string to the debugger and echos it to disk *
* *
* *
* *
* INPUT: string *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 10/28/96 12:48PM ST : Created *
*=============================================================================================*/
void CCDebugString (char *string)
{
#if (0)
char outstr[256];
sprintf (outstr, "%s", string);
DWORD actual;
if (DebugFile == INVALID_HANDLE_VALUE){
DebugFile = CreateFile("debug.txt", GENERIC_WRITE, 0,
NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
}else{
DebugFile = CreateFile("debug.txt", GENERIC_WRITE, 0,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
}
if (DebugFile != INVALID_HANDLE_VALUE){
SetFilePointer (DebugFile, 0, NULL, FILE_END);
WriteFile(DebugFile, outstr, strlen(outstr)+1, &actual, NULL);
CloseHandle (DebugFile);
}
OutputDebugString (string);
#else
string = string;
#endif
}
//
// Miscellaneous stubs. Mainly for multi player stuff
//
//
//
//IPXAddressClass::IPXAddressClass(void) {
// int i;
// i++;
//}
//int IPXManagerClass::Num_Connections(void){ return (0); }
//int IPXManagerClass::Connection_ID( int ) { return (0); }
//IPXAddressClass * IPXManagerClass::Connection_Address( int ) { return ((IPXAddressClass*)0); }
//char * IPXManagerClass::Connection_Name( int ) { return ((char*)0); }
//int IPXAddressClass::Is_Broadcast() { return (0); }
//int IPXManagerClass::Send_Global_Message( void *, int, int, IPXAddressClass * ) { return (0); }
//int IPXManagerClass::Service() { return (0); }
//int IPXManagerClass::Get_Global_Message( void *, int *, IPXAddressClass *, short unsigned * ) { return (0); }
//int IPXAddressClass::operator ==( IPXAddressClass & ) { return (0); }
//IPXManagerClass::IPXManagerClass( int, int, int, int, short unsigned, short unsigned ) {}
//IPXManagerClass::~IPXManagerClass() {
// int i;
// i++;
// }
//int IPXManagerClass::Delete_Connection( int ) { return (0); }
//IPXAddressClass::IPXAddressClass( char unsigned *, char unsigned * ){}
//void IPXManagerClass::Set_Socket( short unsigned ){}
//int IPXManagerClass::Is_IPX() { return (0); }
//int IPXManagerClass::Init() { return (0); }
//void IPXAddressClass::Get_Address( char unsigned *, char unsigned * ){}
//void IPXManagerClass::Set_Bridge( char unsigned * ){}
//int IPXManagerClass::Global_Num_Send() { return (0); }
//void IPXManagerClass::Set_Timing( long unsigned, long unsigned, long unsigned ){}
//unsigned long IPXManagerClass::Global_Response_Time() { return (0); }
//int IPXManagerClass::Create_Connection( int, char *, IPXAddressClass * ) { return (0); }
//int IPXAddressClass::operator !=( IPXAddressClass & ) { return (0); }
//int IPXManagerClass::Send_Private_Message( void *, int, int, int ) { return (0); }
//int IPXManagerClass::Get_Private_Message( void *, int *, int * ) { return (0); }
//int IPXManagerClass::Connection_Index( int ) { return (0); }
//void IPXManagerClass::Reset_Response_Time(){}
//long unsigned IPXManagerClass::Response_Time() { return (0); }
//int IPXManagerClass::Private_Num_Send( int ) { return (0); }
//_VQAHandle * VQA_Alloc(void){ return ((_VQAHandle *)0); }
//void VQA_Init( _VQAHandle *, long ( *)()) {}
//long VQA_Open( _VQAHandle *, char const *, _VQAConfig * ) { return (0); }
//void VQA_Free( _VQAHandle * ) {}
//void VQA_Close( _VQAHandle * ) {}
//long VQA_Play( _VQAHandle *, long ) { return (0); }
//void VQA_Init(VQAHandle *, long(*)(VQAHandle *vqa, long action, void *buffer, long nbytes)){}
//long VQA_Open(VQAHandle *, char const *, VQAConfig *)
//{
// return (0);
//}
//void VQA_Close(VQAHandle *){}
//long VQA_Play(VQAHandle *, long)
//{
// return (0);
//}
unsigned char *VQPalette;
long VQNumBytes;
unsigned long VQSlowpal;
bool VQPaletteChange = false;
extern "C"{
void __cdecl SetPalette(unsigned char *palette,long numbytes,unsigned long slowpal);
}
void Flag_To_Set_Palette(unsigned char *palette,long numbytes,unsigned long slowpal)
{
VQPalette = palette;
VQNumBytes = numbytes;
VQSlowpal = slowpal;
VQPaletteChange = true;
}
void Check_VQ_Palette_Set(void)
{
if (VQPaletteChange){
SetPalette(VQPalette, VQNumBytes, VQSlowpal);
VQPaletteChange = false;
}
}
void __cdecl SetPalette(unsigned char *palette,long,unsigned long)
{
for (int i=0 ; i<256*3 ; i++){
*(palette+i)&=63;
}
Increase_Palette_Luminance(palette , 15 , 15 , 15 ,63);
if (PalettesRead){
memcpy (&PaletteInterpolationTable[0][0] , InterpolatedPalettes[PaletteCounter++] , 65536);
}
Set_Palette(palette);
}
/***********************************************************************************************
* Memory_Error_Handler -- Handle a possibly fatal failure to allocate memory *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 5/22/96 3:57PM ST : Created *
*=============================================================================================*/
void Memory_Error_Handler(void)
{
GlyphX_Debug_Print("Error - out of memory.");
VisiblePage.Clear();
Set_Palette(GamePalette);
while (Get_Mouse_State()){Show_Mouse();};
CCMessageBox().Process("Error - out of memory.", "Abort", false);
Invalidate_Cached_Icons();
// Nope. ST - 1/10/2019 10:38AM
//PostQuitMessage( 0 );
//ExitProcess(0);
}
GraphicBufferClass* Read_PCX_File(char* name, char* Palette, void *Buff, long Size);
/***********************************************************************************************
* Load_Title_Screen -- loads the title screen into the given video buffer *
* *
* *
* *
* INPUT: screen name *
* video buffer *
* ptr to buffer for palette *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 7/5/96 11:30AM ST : Created *
*=============================================================================================*/
void Load_Title_Screen(char *name, GraphicViewPortClass *video_page, unsigned char *palette)
{
GraphicBufferClass *load_buffer;
load_buffer = Read_PCX_File (name, (char*)palette, NULL, 0);
if (load_buffer){
load_buffer->Blit(*video_page);
delete load_buffer;
}
}
#include "filepcx.h"
/***************************************************************************
* READ_PCX_FILE -- read a pcx file into a Graphic Buffer *
* *
* GraphicBufferClass* Read_PCX_File (char* name, char* palette ,void *Buff, long size ); *
* *
* *
* INPUT: name is a NULL terminated string of the fromat [xxxx.pcx] *
* palette is optional, if palette != NULL the the color palette of *
* the pcx file will be place in the memory block pointed *
* by palette. *
* Buff is optinal, if Buff == NULL a new memory Buffer *
* will be allocated, otherwise the file will be placed *
* at location pointd by Buffer; *
* Size is the size in bytes of the memory block pointed by Buff *
* is also optional;
* *
* OUTPUT: on succes a pointer to a GraphicBufferClass cointaining the *
* pcx file, NULL othewise. *
* *
* WARNINGS: *
* Appears to be a comment-free zone *
* *
* HISTORY: *
* 05/03/1995 JRJ : Created. *
* 04/30/1996 ST : Tidied up and modified to use CCFileClass *
*=========================================================================*/
#define POOL_SIZE 2048
#define READ_CHAR() *file_ptr++ ; \
if ( file_ptr >= & pool [ POOL_SIZE ] ) { \
file_handle.Read (pool , POOL_SIZE ); \
file_ptr = pool ; \
}
/*
** The old RGB was signed, so the shift right didn't work. ST - 1/4/2019 4:49PM
*/
typedef struct {
unsigned char red ;
unsigned char green ;
unsigned char blue ;
} PG_RGB ;
GraphicBufferClass* Read_PCX_File(char* name, char* palette, void *Buff, long Size)
{
int i, j;
unsigned rle;
unsigned color;
int scan_pos;
unsigned char *file_ptr;
int width;
int height;
unsigned char *buffer;
PCX_HEADER header;
PG_RGB *pal;
unsigned char pool [POOL_SIZE];
GraphicBufferClass *pic;
CCFileClass file_handle(name);
if (!file_handle.Is_Available()) return (NULL);
file_handle.Open(READ);
file_handle.Read (&header, sizeof (PCX_HEADER));
if (header.id != 10 && header.version != 5 && header.pixelsize != 8 ) return NULL ;
width = header.width - header.x + 1;
height = header.height - header.y + 1;
if (Buff) {
buffer = (unsigned char*) Buff;
i = Size / width;
height = MIN (i - 1, height);
pic = new GraphicBufferClass(width, height, buffer, Size);
if ( !(pic && pic->Get_Buffer()) ) return NULL ;
} else {
pic = new GraphicBufferClass(width, height, NULL, width*(height+4));
if ( !(pic && pic->Get_Buffer()) ) return NULL ;
}
buffer = (unsigned char *) pic->Get_Buffer();
file_ptr = pool ;
file_handle.Read (pool , POOL_SIZE);
if ( header.byte_per_line != width ){
for ( scan_pos = j = 0 ; j < height ; j ++, scan_pos += width ) {
for ( i = 0 ; i < width ; ) {
rle = READ_CHAR ();
if ( rle > 192 ) {
rle -= 192 ;
color = READ_CHAR (); ;
memset ( buffer + scan_pos + i , color , rle );
i += rle;
} else {
*(buffer+scan_pos + i++ ) = (char)rle;
}
}
}
if ( i == width ) rle = READ_CHAR ();
if ( rle > 192 ) rle = READ_CHAR ();
} else {
for ( i = 0 ; i < width * height ; ) {
rle = READ_CHAR ();
rle &= 0xff;
if ( rle > 192 ) {
rle -= 192 ;
color = READ_CHAR ();
memset ( buffer + i , color , rle );
i += rle ;
}else{
*(buffer + i++) = rle;
}
}
}
if ( palette ) {
file_handle.Seek (- (256 * (int)sizeof ( PG_RGB )) , SEEK_END );
file_handle.Read (palette , 256L * sizeof ( PG_RGB ));
pal = ( PG_RGB * ) palette;
for (i = 0 ; i < 256 ; i ++) {
pal ->red >>= 2;
pal ->green >>= 2;
pal ->blue >>= 2;
pal ++ ;
}
}
file_handle.Close();
return pic;
}