mirror of
https://github.com/jmarshall23/CnC_Remastered_Collection.git
synced 2026-08-12 08:00:55 +02:00
Justin Marshall
377 lines
11 KiB
C++
377 lines
11 KiB
C++
/**
|
|
* @file
|
|
*
|
|
* @author CCHyper
|
|
* @author OmniBlade
|
|
*
|
|
* @brief Low level functions for loading and rendering C&C terrain tilesets.
|
|
*
|
|
* @copyright Chronoshift 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
|
|
* 2 of the License, or (at your option) any later version.
|
|
* A full copy of the GNU General Public License can be found in
|
|
* LICENSE
|
|
*/
|
|
/*
|
|
============================
|
|
|
|
This file has been heavily modified by IceColdDuke(Justin Marshall) to render with OpenGL.
|
|
|
|
============================
|
|
*/
|
|
|
|
#include "FUNCTION.H"
|
|
#include "gbuffer.h"
|
|
#include "Image.h"
|
|
#include <cstring>
|
|
|
|
using std::memcpy;
|
|
|
|
class GraphicViewPortClass;
|
|
|
|
struct IsoTileHeader_t {
|
|
int TileWidth;
|
|
int TileHeight;
|
|
int TileImageWidth;
|
|
int TileImageHeight;
|
|
};
|
|
|
|
byte TempTSStampData[48 * 24 * 4];
|
|
|
|
struct IsoTileImageHeader
|
|
{
|
|
int TileX;
|
|
int TileY;
|
|
uint8_t* GetExtraData(IsoTile *tile)
|
|
{
|
|
return reinterpret_cast<uint8_t*>(tile) + ExtraOffset;
|
|
}
|
|
|
|
uint8_t* GetZData(IsoTile* tile)
|
|
{
|
|
return reinterpret_cast<uint8_t*>(tile) + ZDataoffset;
|
|
}
|
|
|
|
uint8_t* GetExtraZData(IsoTile* tile)
|
|
{
|
|
return reinterpret_cast<uint8_t*>(tile) + ExtraZOffset;
|
|
}
|
|
|
|
uint8_t* GetData() {
|
|
return reinterpret_cast<uint8_t*>(this) + sizeof(IsoTileImageHeader);
|
|
}
|
|
|
|
// https://xhp.xwis.net/documents/TMP_TS_Format.html
|
|
uint8_t* GetRasterizedData() {
|
|
memset(TempTSStampData, 0, sizeof(TempTSStampData));
|
|
uint8_t* tileData = GetData();
|
|
byte* w_line = TempTSStampData;
|
|
int x = 24;
|
|
int global_cx = 48;
|
|
int cx = 0;
|
|
for (int y = 0; y < 12; y++)
|
|
{
|
|
cx += 4;
|
|
x -= 2;
|
|
memcpy(w_line + x, tileData, cx);
|
|
tileData += cx;
|
|
w_line += global_cx;
|
|
}
|
|
for (; y < 23; y++)
|
|
{
|
|
cx -= 4;
|
|
x += 2;
|
|
memcpy(w_line + x, tileData, cx);
|
|
tileData += cx;
|
|
w_line += global_cx;
|
|
}
|
|
|
|
return TempTSStampData;
|
|
}
|
|
|
|
int32_t ExtraOffset;
|
|
int32_t ZDataoffset;
|
|
int32_t ExtraZOffset;
|
|
signed int ExtraX;
|
|
signed int ExtraY;
|
|
int ExtraWidth;
|
|
int ExtraHeight;
|
|
struct Flags
|
|
{
|
|
unsigned int HasExtraData : 1; //1
|
|
unsigned int HasZData : 1; //2
|
|
unsigned int HasDamagedData : 1; //4
|
|
// invalid cause memory wasn'y cleared so all bitfields are at 0xCD by default
|
|
//unsigned int Bit8 : 1; //8
|
|
//unsigned int Bit16 : 1; //16
|
|
//unsigned int Bit32 : 1; //32
|
|
//unsigned int Bit64 : 1; //64
|
|
//unsigned int Bit128 : 1; //128
|
|
|
|
};
|
|
unsigned char Height;
|
|
unsigned char TileType;
|
|
unsigned char RampType;
|
|
RGBClass LowRGB;
|
|
RGBClass HighRGB;
|
|
unsigned char Padding[3];
|
|
};
|
|
|
|
class IsoTile {
|
|
public:
|
|
int TileImageWidth() { return header.TileImageWidth; }
|
|
int TileImageHeight() { return header.TileImageHeight; }
|
|
|
|
IsoTileImageHeader *GetTileInfo(int idx) {
|
|
uint8_t* ptr = reinterpret_cast<uint8_t*>(this);
|
|
ptr += sizeof(IsoTileHeader_t);
|
|
uint32_t* offsets = (uint32_t*)ptr;
|
|
IsoTileImageHeader* tileImageHeaders = (IsoTileImageHeader * )(((uint8_t*)this) + offsets[idx]);
|
|
return tileImageHeaders;
|
|
}
|
|
int NumTiles(void) { return header.TileWidth * header.TileHeight; }
|
|
private:
|
|
IsoTileHeader_t header;
|
|
};
|
|
|
|
Image_t* Load_StampHD(int theater, const char* iconName, const void* icondata) {
|
|
char filename[2048];
|
|
Image_t* image = NULL;
|
|
|
|
IsoTile* isoTile = (IsoTile*)icondata;
|
|
if (!isoTile) {
|
|
return NULL;
|
|
}
|
|
|
|
|
|
// This is because were trying to avoid parsing the XML's and the filenames aren't consistant.
|
|
const char* theaterName = Theaters[theater].Name;
|
|
for (int i = 0; i < isoTile->NumTiles(); i++)
|
|
{
|
|
char filename[512];
|
|
char fixedIconName[512];
|
|
strcpy(fixedIconName, iconName);
|
|
COM_SetExtension(fixedIconName, strlen(fixedIconName), "");
|
|
|
|
int numFrames = Tileset_GetNumFramesForTile(theater, fixedIconName, i);
|
|
|
|
for (int d = 0; d < numFrames; d++)
|
|
{
|
|
const char* tileEntryName = Tileset_FindHDTexture(theater, fixedIconName, i, d);
|
|
sprintf(filename, "DATA/ART/TEXTURES/SRGB/RED_ALERT/TERRAIN/%s/%s", Theaters[theater].Name, tileEntryName);
|
|
//COM_SetExtension(filename, sizeof(filename), ".dds");
|
|
|
|
if (image == NULL) {
|
|
// If the image is already loaded, then we are done.
|
|
image = Find_Image(filename);
|
|
if (image) {
|
|
return image;
|
|
}
|
|
|
|
// Load the initial terrain image.
|
|
image = Image_LoadImage(filename);
|
|
|
|
if (image != NULL && i != 0) {
|
|
image->HouseImages[0].image[i][d] = image->HouseImages[0].image[0][d];
|
|
image->HouseImages[0].image[0][d] = 0;
|
|
}
|
|
|
|
if (image != NULL) {
|
|
image->numFrames = numFrames;
|
|
}
|
|
}
|
|
else {
|
|
if (!Image_Add32BitImage(filename, image, -1, i, d)) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//if (image) {
|
|
// image->IconMapPtr = MapPtr;
|
|
//}
|
|
|
|
return image;
|
|
}
|
|
|
|
void Get_Stamp_Size(const void* icondata, int* width, int* height) {
|
|
IsoTile* isoTile = (IsoTile*)icondata;
|
|
|
|
if (!isoTile) {
|
|
for (int i = 0; i < MAX_IMAGE_SHAPES; i++) {
|
|
*width = -1;
|
|
*height = -1;
|
|
}
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < MAX_IMAGE_SHAPES; i++) {
|
|
width[i] = isoTile->TileImageWidth();
|
|
height[i] = isoTile->TileImageHeight();
|
|
}
|
|
}
|
|
|
|
Image_t * Load_Stamp(const char *name, const void* icondata, void* terrainPalette)
|
|
{
|
|
IsoTile* isoTile = (IsoTile*)icondata;
|
|
if (!isoTile) {
|
|
return NULL;
|
|
}
|
|
|
|
// Check to see if the image is already loaded.
|
|
{
|
|
Image_t* image = Find_Image(name);
|
|
if (image) {
|
|
return image;
|
|
}
|
|
}
|
|
|
|
uint8_t* src = isoTile->GetTileInfo(0)->GetRasterizedData();
|
|
Image_t *image = Image_CreateImageFrom8Bit(name, isoTile->TileImageWidth(), isoTile->TileImageHeight(), (unsigned char*)src, NULL, (unsigned char *)terrainPalette);
|
|
if (image == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
image->isoTileInfo = isoTile;
|
|
|
|
for (int i = 1; i < isoTile->NumTiles(); i++) {
|
|
src = isoTile->GetTileInfo(i)->GetRasterizedData();
|
|
Image_Add8BitImage(image, 0, i, isoTile->TileImageWidth(), isoTile->TileImageHeight(), src, NULL, (unsigned char*)terrainPalette);
|
|
}
|
|
|
|
return image;
|
|
}
|
|
|
|
int Stamp_GetIconIndex(Image_t* iconImage, int icon) {
|
|
return icon;
|
|
}
|
|
|
|
void __cdecl Buffer_Draw_Stamp_Clip2(GraphicViewPortClass& viewport, const void *icondata, int icon, int x, int y, const void* remapper, int left, int top, int right, int bottom)
|
|
{
|
|
Image_t* iconImage = (Image_t*)icondata;
|
|
IsoTile* isoTile = iconImage->isoTileInfo;
|
|
|
|
if (icon > isoTile->NumTiles())
|
|
icon = isoTile->NumTiles() - 1;
|
|
IsoTileImageHeader* isoStampImage = isoTile->GetTileInfo(icon);
|
|
int icon_index = icon;
|
|
{
|
|
int blit_height = CELL_PIXEL_H;
|
|
int blit_width = CELL_PIXEL_W;
|
|
|
|
int width = left + right;
|
|
int xstart = left + x;
|
|
int height = top + bottom;
|
|
int ystart = top + y;
|
|
|
|
|
|
if (xstart < width && ystart < height && iconImage->isoTileInfo->TileImageHeight() + ystart > top && iconImage->isoTileInfo->TileImageWidth() + xstart > left) {
|
|
if (xstart < left) {
|
|
// src += left - xstart;
|
|
blit_width -= left - xstart;
|
|
xstart = left;
|
|
}
|
|
|
|
int src_pitch = iconImage->isoTileInfo->TileImageWidth() - blit_width;
|
|
|
|
if (blit_width + xstart > width) {
|
|
src_pitch += blit_width - (width - xstart);
|
|
blit_width = width - xstart;
|
|
}
|
|
|
|
if (top > ystart) {
|
|
blit_height = iconImage->isoTileInfo->TileImageHeight() - (top - ystart);
|
|
// src += IconWidth * (top - ystart);
|
|
ystart = top;
|
|
}
|
|
|
|
if (blit_height + ystart > height) {
|
|
blit_height = height - ystart;
|
|
}
|
|
|
|
int full_pitch = viewport.Get_Full_Pitch(); //(viewport.Get_Pitch() + viewport.Get_XAdd() + viewport.Get_Width());
|
|
uint8_t* dst = (xstart * 4) + (ystart * 4) * full_pitch + (uint8_t*)(viewport.Get_Offset());
|
|
int dst_pitch = full_pitch - blit_width;
|
|
|
|
//if (remapper) {
|
|
// const uint8_t* remap = static_cast<const uint8_t*>(remapper);
|
|
// for (int i = 0; i < blit_height; ++i) {
|
|
// for (int j = 0; j < blit_width; ++j) {
|
|
// uint8_t cur_byte = remap[*src++];
|
|
// if (cur_byte) {
|
|
// dst[0] = backbuffer_data_raw[(cur_byte * 3) + 0];
|
|
// dst[1] = backbuffer_data_raw[(cur_byte * 3) + 1];
|
|
// dst[2] = backbuffer_data_raw[(cur_byte * 3) + 2];
|
|
// dst[3] = 255;
|
|
// }
|
|
//
|
|
// dst += 4;
|
|
// }
|
|
// dst += dst_pitch * 4;
|
|
// }
|
|
//
|
|
//}
|
|
//else if (TransFlagPtr[icon_index]) {
|
|
// for (int i = 0; i < blit_height; ++i) {
|
|
// for (int j = 0; j < blit_width; ++j) {
|
|
// uint8_t cur_byte = *src++;
|
|
// if (cur_byte) {
|
|
// dst[0] = backbuffer_data_raw[(cur_byte * 3) + 0];
|
|
// dst[1] = backbuffer_data_raw[(cur_byte * 3) + 1];
|
|
// dst[2] = backbuffer_data_raw[(cur_byte * 3) + 2];
|
|
// dst[3] = 255;
|
|
// }
|
|
//
|
|
// dst += 4;
|
|
// }
|
|
// src += src_pitch;
|
|
// dst += dst_pitch * 4;
|
|
// }
|
|
//
|
|
//}
|
|
//else {
|
|
{
|
|
//for (int i = 0; i < blit_height; ++i) {
|
|
// FastScanlinePaletteBlit(dst, src, blit_width);
|
|
// dst += full_pitch * 4;
|
|
// src += IconWidth;
|
|
//}
|
|
|
|
if (iconImage->HouseImages[0].image[icon_index] == 0)
|
|
return;
|
|
|
|
GL_SetClipRect(xstart, ystart, blit_width, blit_height);
|
|
GL_RenderImage(iconImage, xstart, ystart, blit_width, blit_height, 0, icon_index);
|
|
GL_ResetClipRect();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
extern "C" void __cdecl Buffer_Draw_Stamp_Clip(void const* this_object, void const* icondata, int icon, int x_pixel, int y_pixel, void const* remap, int min_x, int min_y, int max_x, int max_y) {
|
|
if (icondata == NULL)
|
|
return;
|
|
|
|
Buffer_Draw_Stamp_Clip2(*((GraphicViewPortClass*)this_object), icondata, icon, x_pixel, y_pixel, remap, min_x, min_y, max_x, max_y);
|
|
}
|
|
|
|
extern "C" void __cdecl Buffer_Draw_Stamp(void const* thisptr, void const* icondata, int icon, int x_pixel, int y_pixel, void const* remap) {
|
|
// NOT USED
|
|
}
|
|
|
|
uint8_t* Get_Icon_Set_Map(void* temp)
|
|
{
|
|
//if (temp != nullptr) {
|
|
// if ((static_cast<IconControlType*>(temp)->td.icons) == TD_TILESET_CHECK) {
|
|
// return static_cast<uint8_t*>(temp) + (static_cast<IconControlType*>(temp)->td.icons);
|
|
// }
|
|
// else {
|
|
// return static_cast<uint8_t*>(temp) + (static_cast<IconControlType*>(temp)->ra.icons);
|
|
// }
|
|
//}
|
|
|
|
return nullptr;
|
|
}
|