/*
** 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 .
*/
/***********************************************************************************************
*** 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
#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);
}
}