326 lines
14 KiB
C++
326 lines
14 KiB
C++
/*
|
|
** Command & Conquer Renegade(tm)
|
|
** Copyright 2025 Electronic Arts Inc.
|
|
**
|
|
** 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/>.
|
|
*/
|
|
|
|
/***********************************************************************************************
|
|
*** 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 *
|
|
* *
|
|
* $Archive:: /G/wwlib/data.cpp $*
|
|
* *
|
|
* $Author:: Neal_k $*
|
|
* *
|
|
* $Modtime:: 9/24/99 4:52p $*
|
|
* *
|
|
* $Revision:: 2 $*
|
|
* *
|
|
*---------------------------------------------------------------------------------------------*
|
|
* Functions: *
|
|
* Load_Alloc_Data -- Allocates a buffer and loads the file into it. *
|
|
* Load_Uncompress -- Loads and uncompresses data to a buffer. *
|
|
* Hires_Load -- Allocates memory for, and loads, a resolution dependant file. *
|
|
* Fetch_String -- Fetches a string resource. *
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
#include "always.h"
|
|
#include <new.h>
|
|
#include "data.h"
|
|
|
|
|
|
/***********************************************************************************************
|
|
* Load_Alloc_Data -- Allocates a buffer and loads the file into it. *
|
|
* *
|
|
* This is the C++ replacement for the Load_Alloc_Data function. It will allocate the *
|
|
* memory big enough to hold the file and then read the file into it. *
|
|
* *
|
|
* INPUT: file -- The file to read. *
|
|
* *
|
|
* mem -- The memory system to use for allocation. *
|
|
* *
|
|
* OUTPUT: Returns with a pointer to the allocated and filled memory block. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 10/17/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
void * Load_Alloc_Data(FileClass & file)
|
|
{
|
|
void * ptr = NULL;
|
|
if (file.Is_Available()) {
|
|
long size = file.Size();
|
|
|
|
ptr = new char[size];
|
|
if (ptr != NULL) {
|
|
file.Read(ptr, size);
|
|
}
|
|
}
|
|
return(ptr);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* Load_Uncompress -- Loads and uncompresses data to a buffer. *
|
|
* *
|
|
* This is the C++ counterpart to the Load_Uncompress function. It will load the file *
|
|
* specified into the graphic buffer indicated and uncompress it. *
|
|
* *
|
|
* INPUT: file -- The file to load and uncompress. *
|
|
* *
|
|
* uncomp_buff -- The graphic buffer that initial loading will use. *
|
|
* *
|
|
* dest_buff -- The buffer that will hold the uncompressed data. *
|
|
* *
|
|
* reserved_data -- This is an optional pointer to a buffer that will hold any *
|
|
* reserved data the compressed file may contain. This is *
|
|
* typically a palette. *
|
|
* *
|
|
* OUTPUT: Returns with the size of the uncompressed data in the destination buffer. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 10/17/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
long Load_Uncompress(FileClass & file, Buffer & uncomp_buff, Buffer & dest_buff, void * reserved_data)
|
|
{
|
|
unsigned short size;
|
|
void * sptr = uncomp_buff.Get_Buffer();
|
|
void * dptr = dest_buff.Get_Buffer();
|
|
int opened = false;
|
|
CompHeaderType header;
|
|
|
|
/*
|
|
** The file must be opened in order to be read from. If the file
|
|
** isn't opened, then open it. Record this fact so that it can be
|
|
** restored to its closed state at the end.
|
|
*/
|
|
if (!file.Is_Open()) {
|
|
if (!file.Open()) {
|
|
return(0);
|
|
}
|
|
opened = true;
|
|
}
|
|
|
|
/*
|
|
** Read in the size of the file (supposedly).
|
|
*/
|
|
file.Read(&size, sizeof(size));
|
|
|
|
/*
|
|
** Read in the header block. This block contains the compression type
|
|
** and skip data (among other things).
|
|
*/
|
|
file.Read(&header, sizeof(header));
|
|
size -= (unsigned short)sizeof(header);
|
|
|
|
/*
|
|
** If there are skip bytes then they must be processed. Either read
|
|
** them into the buffer provided or skip past them. No check is made
|
|
** to ensure that the reserved data buffer is big enough (watch out!).
|
|
*/
|
|
if (header.Skip) {
|
|
size -= header.Skip;
|
|
if (reserved_data) {
|
|
file.Read(reserved_data, header.Skip);
|
|
} else {
|
|
file.Seek(header.Skip, SEEK_CUR);
|
|
}
|
|
header.Skip = 0;
|
|
}
|
|
|
|
/*
|
|
** Determine where is the proper place to load the data. If both buffers
|
|
** specified are identical, then the data should be loaded at the end of
|
|
** the buffer and decompressed at the beginning.
|
|
*/
|
|
if (uncomp_buff.Get_Buffer() == dest_buff.Get_Buffer()) {
|
|
sptr = (char *)sptr + uncomp_buff.Get_Size()-(size+sizeof(header));
|
|
}
|
|
|
|
/*
|
|
** Read in the bulk of the data.
|
|
*/
|
|
memmove(sptr, &header, sizeof(header));
|
|
// Mem_Copy(&header, sptr, sizeof(header));
|
|
file.Read((char *)sptr + sizeof(header), size);
|
|
|
|
/*
|
|
** Decompress the data.
|
|
*/
|
|
size = (unsigned short) Uncompress_Data(sptr, dptr);
|
|
|
|
/*
|
|
** Close the file if necessary.
|
|
*/
|
|
if (opened) {
|
|
file.Close();
|
|
}
|
|
return((long)size);
|
|
}
|
|
|
|
|
|
typedef struct SRecord {
|
|
int ID; // ID number of the string resource.
|
|
int TimeStamp; // 'Time' that this string was last requested.
|
|
char String[2048]; // Copy of string resource.
|
|
|
|
SRecord(void) : ID(-1), TimeStamp(-1) {}
|
|
} SRecord;
|
|
|
|
|
|
/***********************************************************************************************
|
|
* Fetch_String -- Fetches a string resource. *
|
|
* *
|
|
* Fetches a string resource and returns a pointer to its text. *
|
|
* *
|
|
* INPUT: id -- The ID number of the string resource to fetch. *
|
|
* *
|
|
* OUTPUT: Returns with a pointer to the actual text of the string resource. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 12/25/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
char const * Fetch_String(int id)
|
|
{
|
|
#ifdef _UNIX
|
|
return("");
|
|
#else
|
|
static SRecord _buffers[64];
|
|
static int _time = 0;
|
|
|
|
/*
|
|
** Determine if the string ID requested is valid. If not then return an empty string pointer.
|
|
*/
|
|
if (id == -1 || id == TXT_NONE) return("");
|
|
|
|
/*
|
|
** Adjust the 'time stamp' tracking value. This is an artificial value used merely to track
|
|
** the relative age of the strings requested.
|
|
*/
|
|
_time = _time+1;
|
|
|
|
/*
|
|
** Check to see if the requested string has already been fetched into a buffer. If so, then
|
|
** return a pointer to that string (update the time stamp as well).
|
|
*/
|
|
for (int index = 0; index < ARRAY_SIZE(_buffers); index++) {
|
|
if (_buffers[index].ID == id) {
|
|
_buffers[index].TimeStamp = _time;
|
|
return(_buffers[index].String);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Find a suitable buffer to hold the string to be fetched. The buffer should either be
|
|
** empty or have the oldest fetched string.
|
|
*/
|
|
int oldest = -1;
|
|
int oldtime = -1;
|
|
for (int text = 0; text < ARRAY_SIZE(_buffers); text++) {
|
|
if (oldest == -1 || oldtime > _buffers[text].TimeStamp) {
|
|
oldest = text;
|
|
oldtime = _buffers[text].TimeStamp;
|
|
if (oldtime == -1 || _buffers[text].ID == -1) break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** A suitable buffer has been found so fetch the string resource and then return a pointer
|
|
** to the string.
|
|
*/
|
|
char * stringptr = _buffers[oldest].String;
|
|
_buffers[oldest].ID = id;
|
|
_buffers[oldest].TimeStamp = _time;
|
|
if (LoadString(ProgramInstance, id, stringptr, sizeof(_buffers[oldest].String)) == 0) {
|
|
return("");
|
|
}
|
|
stringptr[sizeof(_buffers[oldest].String)-1] = '\0';
|
|
return(stringptr);
|
|
#endif
|
|
}
|
|
|
|
|
|
void const * Fetch_Resource(LPCSTR resname, LPCSTR restype)
|
|
{
|
|
#ifdef _UNIX
|
|
return(NULL);
|
|
#else
|
|
/*
|
|
** Fetch the program instance if it hasn't already been recorded.
|
|
*/
|
|
// if (ProgramInstance == 0) {
|
|
// ProgramInstance = GetModuleHandle("LANGUAGE");
|
|
// }
|
|
|
|
HRSRC handle = FindResource(ProgramInstance, resname, restype);
|
|
if (handle == NULL) {
|
|
return(NULL);
|
|
}
|
|
|
|
HGLOBAL rhandle = LoadResource(ProgramInstance, handle);
|
|
if (rhandle == NULL) {
|
|
return(NULL);
|
|
}
|
|
|
|
return(LockResource(rhandle));
|
|
#endif
|
|
}
|
|
|
|
|
|
int Load_Picture(FileClass & file, Buffer & scratchbuf, Buffer & destbuf, unsigned char * palette, PicturePlaneType )
|
|
{
|
|
return(Load_Uncompress(file, scratchbuf, destbuf, palette ) / 8000);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* Hires_Load -- Allocates memory for, and loads, a resolution dependant file. *
|
|
* *
|
|
* *
|
|
* *
|
|
* INPUT: Name of file to load *
|
|
* *
|
|
* OUTPUT: Ptr to loaded file *
|
|
* *
|
|
* WARNINGS: Caller is responsible for releasing the memory allocated *
|
|
* *
|
|
* *
|
|
* HISTORY: *
|
|
* 5/13/96 3:20PM ST : Created *
|
|
*=============================================================================================*/
|
|
void * Hires_Load(FileClass & file)
|
|
{
|
|
int length;
|
|
void * return_ptr;
|
|
|
|
if (file.Is_Available()) {
|
|
|
|
length = file.Size();
|
|
return_ptr = new char[length];
|
|
file.Read(return_ptr, length);
|
|
return (return_ptr);
|
|
|
|
} else {
|
|
return (NULL);
|
|
}
|
|
}
|
|
|
|
|