305 lines
11 KiB
C
305 lines
11 KiB
C
// Interface to the crytek pack files management
|
|
|
|
#ifndef _ICRY_PAK_HDR_
|
|
#define _ICRY_PAK_HDR_
|
|
|
|
#include <smartptr.h>
|
|
#ifdef LINUX
|
|
#include <winbase.h>
|
|
#include <stdint.h>
|
|
#endif
|
|
|
|
// this represents one particular archive filcare
|
|
struct ICryArchive: public _reference_target_t
|
|
{
|
|
// Compression methods
|
|
enum ECompressionMethods
|
|
{
|
|
METHOD_STORE = 0,
|
|
METHOD_COMPRESS = 8,
|
|
METHOD_DEFLATE = 8
|
|
};
|
|
|
|
// Compression levels
|
|
enum ECompressionLevels
|
|
{
|
|
LEVEL_FASTEST = 0,
|
|
LEVEL_FASTER = 2,
|
|
LEVEL_NORMAL = 8,
|
|
LEVEL_BETTER = 8,
|
|
LEVEL_BEST = 9,
|
|
LEVEL_DEFAULT = -1
|
|
};
|
|
|
|
enum EPakFlags
|
|
{
|
|
// support for absolute and other complex path specifications -
|
|
// all paths will be treated relatively to the current directory (normally MasterCD)
|
|
FLAGS_ABSOLUTE_PATHS = 1,
|
|
|
|
// if this is set, the object will only understand relative to the zip file paths,
|
|
// but this can give an opportunity to optimize for frequent quick accesses
|
|
// FLAGS_SIMPLE_RELATIVE_PATHS and FLAGS_ABSOLUTE_PATHS are mutually exclusive
|
|
FLAGS_RELATIVE_PATHS_ONLY = 1 << 1,
|
|
|
|
// if this flag is set, the archive update/remove operations will not work
|
|
// this is useful when you open a read-only or already opened for reading files.
|
|
// If FLAGS_OPEN_READ_ONLY | FLAGS_SIMPLE_RELATIVE_PATHS are set, ICryPak
|
|
// will try to return an object optimized for memory, with long life cycle
|
|
FLAGS_READ_ONLY = 1 << 2,
|
|
|
|
// if this flag is set, FLAGS_OPEN_READ_ONLY
|
|
// flags are also implied. The returned object will be optimized for quick access and
|
|
// memory footprint
|
|
FLAGS_OPTIMIZED_READ_ONLY = (1 << 3),
|
|
|
|
// if this is set, the existing file (if any) will be overwritten
|
|
FLAGS_CREATE_NEW = 1 << 4,
|
|
|
|
// if this flag is set, and the file is opened for writing, and some files were updated
|
|
// so that the archive is no more continuous, the archive will nevertheless NOT be compacted
|
|
// upon closing the archive file. This can be faster if you open/close the archive for writing
|
|
// multiple times
|
|
FLAGS_DONT_COMPACT = 1 << 5,
|
|
|
|
// if this is set, CryPak doesn't try to transform the path according to the MOD subdirectories
|
|
FLAGS_IGNORE_MODS = 1 << 6
|
|
};
|
|
|
|
virtual ~ICryArchive(){}
|
|
|
|
// Summary:
|
|
// Adds a new file to the zip or update an existing one.
|
|
// Description:
|
|
// Adds a new file to the zip or update an existing one
|
|
// adds a directory (creates several nested directories if needed)
|
|
// compression methods supported are METHOD_STORE == 0 (store) and
|
|
// METHOD_DEFLATE == METHOD_COMPRESS == 8 (deflate) , compression
|
|
// level is LEVEL_FASTEST == 0 till LEVEL_BEST == 9 or LEVEL_DEFAULT == -1
|
|
// for default (like in zlib)
|
|
virtual int UpdateFile (const char* szRelativePath, void* pUncompressed, unsigned nSize, unsigned nCompressionMethod = 0, int nCompressionLevel = -1) = 0;
|
|
|
|
// Summary:
|
|
// Deletes the file from the archive.
|
|
virtual int RemoveFile (const char* szRelativePath) = 0;
|
|
|
|
// Summary:
|
|
// Deletes the directory, with all its descendants (files and subdirs).
|
|
virtual int RemoveDir (const char* szRelativePath) = 0;
|
|
|
|
// Summary:
|
|
// Deletes all files and directories in the archive.
|
|
virtual int RemoveAll() = 0;
|
|
|
|
typedef void* Handle;
|
|
|
|
// Summary:
|
|
// Finds the file; you don't have to close the returned handle.
|
|
// Returns:
|
|
// NULL if the file doesn't exist
|
|
virtual Handle FindFile (const char* szPath) = 0;
|
|
// Summary:
|
|
// Get the file size (uncompressed).
|
|
// Returns:
|
|
// The size of the file (unpacked) by the handle
|
|
virtual unsigned GetFileSize (Handle) = 0;
|
|
// Summary:
|
|
// Reads the file into the preallocated buffer
|
|
// Note:
|
|
// Must be at least the size returned by GetFileSize.
|
|
virtual int ReadFile (Handle, void* pBuffer) = 0;
|
|
|
|
// Summary:
|
|
// Get the full path to the archive file.
|
|
virtual const char* GetFullPath() const = 0;
|
|
|
|
// Summary:
|
|
// Get the flags of this object.
|
|
// Description:
|
|
// The possibles flags are defined in EPakFlags.
|
|
// See Also:
|
|
// SetFlags, ResetFlags
|
|
virtual unsigned GetFlags() const = 0;
|
|
|
|
// Summary:
|
|
// Sets the flags of this object.
|
|
// Description:
|
|
// The possibles flags are defined in EPakFlags.
|
|
// See Also:
|
|
// GetFlags, ResetFlags
|
|
virtual bool SetFlags(unsigned nFlagsToSet) = 0;
|
|
|
|
// Summary:
|
|
// Resets the flags of this object.
|
|
// See Also:
|
|
// SetFlags, GetFlags
|
|
virtual bool ResetFlags(unsigned nFlagsToSet) = 0;
|
|
|
|
// Summary:
|
|
// Determines if the archive is read only.
|
|
// Returns:
|
|
// true if this archive is read-only
|
|
inline bool IsReadOnly()const {return (GetFlags() & FLAGS_READ_ONLY) != 0;}
|
|
|
|
// Summary:
|
|
// Get the class id.
|
|
virtual unsigned GetClassId()const = 0;
|
|
|
|
};
|
|
|
|
TYPEDEF_AUTOPTR(ICryArchive);
|
|
|
|
// this special flag is used for findfirst/findnext routines
|
|
// to mark the files that were actually found in Archive
|
|
enum {_A_IN_CRYPAK = 0x80000000};
|
|
|
|
struct ICryPak
|
|
{
|
|
// Flags used in file path resolution rules
|
|
enum EPathResolutionRules
|
|
{
|
|
// If used, the source path will be treated as the destination path
|
|
// and no transformations will be done. Pass this flag when the path is to be the actual
|
|
// path on the disk/in the packs and doesn't need adjustment (or after it has come through adjustments already)
|
|
FLAGS_PATH_REAL = 1 << 16,
|
|
|
|
// AdjustFileName will always copy the file path to the destination path:
|
|
// regardless of the returned value, szDestpath can be used
|
|
FLAGS_COPY_DEST_ALWAYS = 1 << 17,
|
|
|
|
// Adds trailing slash to the path
|
|
FLAGS_ADD_TRAILING_SLASH = 1 << 18,
|
|
|
|
// Doesn't take mods into account
|
|
FLAGS_IGNORE_MOD_DIRS = 1 << 19,
|
|
|
|
// Search only in MODs; if not found, return NULL; may not be used with FLAGS_IGNORE_MOD_DIRS
|
|
FLAGS_ONLY_MOD_DIRS = 1 << 20
|
|
};
|
|
|
|
// Used for widening FOpen functionality. They're ignored for the regular File System files.
|
|
enum EFOpenFlags
|
|
{
|
|
// If possible, will prevent the file from being read from memory.
|
|
FOPEN_HINT_DIRECT_OPERATION = 1,
|
|
// Will prevent a "missing file" warnings to be created.
|
|
FOPEN_HINT_QUIET = 1 << 1
|
|
};
|
|
|
|
|
|
//! the size of the buffer that receives the full path to the file
|
|
enum {g_nMaxPath = 0x800};
|
|
|
|
// given the source relative path, constructs the full path to the file according to the flags
|
|
// returns the pointer to the constructed path (can be either szSourcePath, or szDestPath, or NULL in case of error
|
|
const char* AdjustFileName(const char *szSourcePath, char szDestPath[g_nMaxPath], unsigned nFlags = 0);
|
|
|
|
virtual bool Init (const char *szBasePath)=0;
|
|
virtual void Release()=0;
|
|
//! after this call, the pak file will be searched for files when they aren't on the OS file system
|
|
virtual bool OpenPack(const char *pName, unsigned nFlags = FLAGS_PATH_REAL)=0;
|
|
//! after this call, the pak file will be searched for files when they aren't on the OS file system
|
|
virtual bool OpenPack(const char* pBindingRoot, const char *pName, unsigned nFlags = FLAGS_PATH_REAL)=0;
|
|
//! after this call, the file will be unlocked and closed, and its contents won't be used to search for files
|
|
virtual bool ClosePack(const char* pName, unsigned nFlags = FLAGS_PATH_REAL) = 0;
|
|
//! opens pack files by the path and wildcard
|
|
virtual bool OpenPacks(const char *pWildcard, unsigned nFlags = FLAGS_PATH_REAL)=0;
|
|
//! opens pack files by the path and wildcard
|
|
virtual bool OpenPacks(const char* pBindingRoot, const char *pWildcard, unsigned nFlags = FLAGS_PATH_REAL)=0;
|
|
//! closes pack files by the path and wildcard
|
|
virtual bool ClosePacks(const char* pWildcard, unsigned nFlags = FLAGS_PATH_REAL) = 0;
|
|
//! adds a mod to the list
|
|
virtual void AddMod(const char* szMod)=0;
|
|
//! removes a mod from the list
|
|
virtual void RemoveMod(const char* szMod)=0;
|
|
|
|
struct PakInfo
|
|
{
|
|
struct Pak
|
|
{
|
|
const char* szFilePath;
|
|
const char* szBindRoot;
|
|
size_t nUsedMem;
|
|
};
|
|
// the number of packs in the arrPacks array
|
|
unsigned numOpenPaks;
|
|
// the packs
|
|
Pak arrPaks[1];
|
|
};
|
|
// returns an array of PackInfo structures inside OpenPacks structure
|
|
// you MUST call FreeOpenPackInfo
|
|
virtual PakInfo* GetPakInfo() = 0;
|
|
virtual void FreePakInfo (PakInfo*) = 0;
|
|
|
|
virtual FILE *FOpen(const char *pName, const char *mode, unsigned nFlags = 0)=0;
|
|
virtual FILE *FOpen(const char *pName, const char *mode,char *szFileGamePath,int nLen)=0;
|
|
virtual size_t FRead(void *data, size_t length, size_t elems, FILE *handle)=0;
|
|
virtual size_t FWrite(void *data, size_t length, size_t elems, FILE *handle)=0;
|
|
virtual int FSeek(FILE *handle, long seek, int mode)=0;
|
|
virtual long FTell(FILE *handle)=0;
|
|
virtual int FClose(FILE *handle)=0;
|
|
virtual int FEof(FILE *handle)=0;
|
|
virtual int FFlush(FILE *handle)=0;
|
|
//virtual int FScanf(FILE *, const char *, ...)=0;
|
|
virtual int FPrintf(FILE *handle, const char *format, ...)=0;
|
|
virtual char *FGets(char *, int, FILE *)=0;
|
|
virtual int Getc(FILE *)=0;
|
|
virtual int Ungetc(int c, FILE *)=0;
|
|
|
|
virtual intptr_t
|
|
FindFirst(
|
|
const char *pDir,
|
|
struct _finddata_t *fd
|
|
)=0;
|
|
|
|
virtual int FindNext(intptr_t handle, struct _finddata_t *fd)=0;
|
|
virtual int FindClose(intptr_t handle)=0;
|
|
// virtual bool IsOutOfDate(const char * szCompiledName, const char * szMasterFile)=0;
|
|
//returns file modification time
|
|
virtual FILETIME GetModificationTime(FILE*f)=0;
|
|
|
|
// creates a directory
|
|
virtual bool MakeDir (const char* szPath) = 0;
|
|
|
|
// open the physical archive file - creates if it doesn't exist
|
|
// returns NULL if it's invalid or can't open the file
|
|
// nFlags can have the following flag set:
|
|
// FLAGS_ABSOLUTE_PATHS
|
|
virtual ICryArchive* OpenArchive (const char* szPath, unsigned nFlags = FLAGS_PATH_REAL) = 0;
|
|
|
|
// returns the current game directory, with trailing slash (or empty string if it's right in MasterCD)
|
|
// this is used to support Resource Compiler which doesn't have access to this interface:
|
|
// in case all the contents is located in a subdirectory of MasterCD, this string is the subdirectory name with slash
|
|
//virtual const char* GetGameDir() = 0;
|
|
|
|
// returns the path to the archive in which the file was opened
|
|
// returns NULL if the file is a physical file, and "" if the path to archive is unknown (shouldn't ever happen)
|
|
virtual const char* GetFileArchivePath (FILE* f) = 0;
|
|
|
|
// compresses the raw data into raw data. The buffer for compressed data itself with the heap passed. Uses method 8 (deflate)
|
|
// returns one of the Z_* errors (Z_OK upon success)
|
|
// MT-safe
|
|
virtual int RawCompress (const void* pUncompressed, unsigned long* pDestSize, void* pCompressed, unsigned long nSrcSize, int nLevel = -1) = 0;
|
|
|
|
// Uncompresses raw (without wrapping) data that is compressed with method 8 (deflated) in the Zip file
|
|
// returns one of the Z_* errors (Z_OK upon success)
|
|
// This function just mimics the standard uncompress (with modification taken from unzReadCurrentFile)
|
|
// with 2 differences: there are no 16-bit checks, and
|
|
// it initializes the inflation to start without waiting for compression method byte, as this is the
|
|
// way it's stored into zip file
|
|
virtual int RawUncompress (void* pUncompressed, unsigned long* pDestSize, const void* pCompressed, unsigned long nSrcSize) = 0;
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Files collector.
|
|
//////////////////////////////////////////////////////////////////////////
|
|
typedef void (*RecordedFilesEnumCallback)( const char *filename );
|
|
//! Turn on/off recording of filenames of opened files.
|
|
virtual void RecordFileOpen( bool bEnable ) = 0;
|
|
//! Record this file if recording is enabled.
|
|
virtual void RecordFile( const char *szFilename ) = 0;
|
|
//! Get filenames of all recorded files.
|
|
virtual void EnumerateRecordedFiles( RecordedFilesEnumCallback enumCallback ) = 0;
|
|
};
|
|
|
|
#endif
|