mirror of
https://github.com/electronicarts/CnC_Remastered_Collection
synced 2024-04-26 16:32:36 +12:00
03416d24e1
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.
326 lines
9.9 KiB
C++
326 lines
9.9 KiB
C++
//
|
|
// 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
|
|
|
|
/* $Header: /CounterStrike/SPRITE.CPP 1 3/03/97 10:25a Joe_bostic $ */
|
|
/**********************************************************************
|
|
|
|
Sprite.cpp
|
|
|
|
Dec 28,1995
|
|
|
|
GraphicBufferClass member functions for blitting, scaling,
|
|
and rotating bitmaps
|
|
|
|
**********************************************************************/
|
|
|
|
#ifndef WIN32
|
|
class BitmapClass
|
|
{
|
|
public:
|
|
BitmapClass(int w, int h, unsigned char * data) :
|
|
Width(w), Height(h), Data(data) {};
|
|
|
|
int Width;
|
|
int Height;
|
|
unsigned char * Data;
|
|
};
|
|
|
|
class TPoint2D
|
|
{
|
|
public:
|
|
TPoint2D(int xx, int yy) : x(xx), y(yy) {};
|
|
TPoint2D(void) : x(0), y(0) {};
|
|
|
|
int x;
|
|
int y;
|
|
};
|
|
#endif
|
|
|
|
|
|
//#include "function.h"
|
|
#define FILE_H
|
|
#define RAWFILE_H
|
|
#define WWMEM_H
|
|
#define WWFILE_Hx
|
|
#include <wwlib32.h>
|
|
#include <stdio.h>
|
|
//#include "gbuffer.h"
|
|
//#include "math.h"
|
|
|
|
|
|
long _SineTab[256] = {
|
|
0 ,6 ,12 , 18 , 25 , 31 , 37 , 43 , 49 , 56 , 62 , 68 , 74 , 80 , 86 ,
|
|
92 , 97 , 103 , 109 , 115 , 120 , 126 , 131 , 136 , 142 , 147 , 152 ,
|
|
157 , 162 , 167 , 171 , 176 , 180 , 185 , 189 , 193 , 197 , 201 , 205 ,
|
|
209 , 212 , 216 , 219 , 222 , 225 , 228 , 231 , 233 , 236 , 238 , 240 ,
|
|
243 , 244 , 246 , 248 , 249 , 251 , 252 , 253 , 254 , 254 , 255 , 255 ,
|
|
255 , 255 , 255 , 255 , 255 , 254 , 254 , 253 , 252 , 251 , 249 , 248 ,
|
|
246 , 245 , 243 , 241 , 238 , 236 , 234 , 231 , 228 , 225 , 222 , 219 ,
|
|
216 , 213 , 209 , 205 , 201 , 198 , 194 , 189 , 185 , 181 , 176 , 172 ,
|
|
167 , 162 , 157 , 152 , 147 , 142 , 137 , 131 , 126 , 120 , 115 , 109 ,
|
|
104 , 98 , 92 , 86 , 80 , 74 , 68 , 62 , 56 , 50 , 44 , 37 , 31 , 25 ,
|
|
19 , 12 , 6 , 0 , -5 , -12 , -18 , -24 , -30 , -37 , -43 , -49 , -55 ,
|
|
-61 , -67 , -73 , -79 , -85 , -91 , -97 , -103 , -109 , -114 , -120 ,
|
|
-125 , -131 , -136 , -141 , -147 , -152 , -157 , -162 , -166 , -171 ,
|
|
-176 , -180 , -185 , -189 , -193 , -197 , -201 , -205 , -208 , -212 ,
|
|
-215 , -219 , -222 , -225 , -228 , -231 , -233 , -236 , -238 , -240 ,
|
|
-242 , -244 , -246 , -248 , -249 , -250 , -252 , -253 , -254 , -254 ,
|
|
-255 , -255 , -255 , -255 , -255 , -255 , -255 , -254 , -254 , -253 ,
|
|
-252 , -251 , -249 , -248 , -246 , -245 , -243 , -241 , -239 , -236 ,
|
|
-234 , -231 , -228 , -226 , -223 , -219 , -216 , -213 , -209 , -206 ,
|
|
-202 , -198 , -194 , -190 , -185 , -181 , -177 , -172 , -167 , -162 ,
|
|
-158 , -153 , -148 , -142 , -137 , -132 , -126 , -121 , -115 , -110 ,
|
|
-104 , -98 , -92 , -86 , -81 , -75 , -69 , -62 , -56 , -50 , -44 ,
|
|
-38 , -32 , -25 , -19 , -13 , -7 ,
|
|
};
|
|
|
|
long _CosineTab[256] = {
|
|
256 , 255 , 255 , 255 , 254 , 254 , 253 , 252 , 251 , 249 , 248 , 246 ,
|
|
244 , 243 , 241 , 238 , 236 , 234 , 231 , 228 , 225 , 222 , 219 , 216 ,
|
|
212 , 209 , 205 , 201 , 197 , 193 , 189 , 185 , 181 , 176 , 171 , 167 ,
|
|
162 , 157 , 152 , 147 , 142 , 137 , 131 , 126 , 120 , 115 , 109 , 103 ,
|
|
98 , 92 , 86 , 80 , 74 , 68 , 62 , 56 , 50 , 43 , 37 , 31 , 25 , 19 ,
|
|
12 , 6 , 0 , -6 , -12 , -18 , -24 , -31 , -37 , -43 , -49 , -55 , -61 ,
|
|
-68 , -74 , -80 , -86 , -91 , -97 , -103 , -109 , -114 , -120 , -125 , -131 ,
|
|
-136 , -141 , -147 , -152 , -157 , -162 , -166 , -171 , -176 , -180 ,
|
|
-185 , -189 , -193 , -197 , -201 , -205 , -209 , -212 , -216 , -219 , -222 ,
|
|
-225 , -228 , -231 , -233 , -236 , -238 , -240 , -242 , -244 , -246 ,
|
|
-248 , -249 , -251 , -252 , -253 , -254 , -254 , -255 , -255 , -255 ,
|
|
-255 , -255 , -255 , -255 , -254 , -254 , -253 , -252 , -251 , -249 , -248 ,
|
|
-246 , -245 , -243 , -241 , -239 , -236 , -234 , -231 , -228 , -225 ,
|
|
-222 , -219 , -216 , -213 , -209 , -205 , -202 , -198 , -194 , -190 , -185 ,
|
|
-181 , -176 , -172 , -167 , -162 , -157 , -152 , -147 , -142 , -137 , -132 ,
|
|
-126 , -121 , -115 , -109 , -104 , -98 , -92 , -86 , -80 , -74 , -68 ,
|
|
-62 , -56 , -50 , -44 , -38 , -31 , -25 , -19 , -13 , -6 , 0 , 5 , 11 ,
|
|
18 , 24 , 30 , 36 , 43 , 49 , 55 , 61 , 67 , 73 , 79 , 85 , 91 , 97 , 103 ,
|
|
108 , 114 , 120 , 125 , 131 , 136 , 141 , 146 , 151 , 156 , 161 , 166 ,
|
|
171 , 176 , 180 , 184 , 189 , 193 , 197 , 201 , 205 , 208 , 212 , 215 ,
|
|
219 , 222 , 225 , 228 , 231 , 233 , 236 , 238 , 240 , 242 , 244 , 246 ,
|
|
248 , 249 , 250 , 252 , 253 , 253 , 254 , 255 , 255 , 255 ,
|
|
};
|
|
|
|
|
|
|
|
/***************************************************************
|
|
*
|
|
* Scale_Rotate
|
|
*
|
|
* FUNCTION:
|
|
*
|
|
* Using Bi-Linear Interpolation, draws a scaled and rotated
|
|
* bitmap onto the buffer. No clipping is performed so beware.
|
|
*
|
|
* INPUTS
|
|
*
|
|
* bmp - bitmap to draw
|
|
* pt - desired position of the center
|
|
* scale - 24.8 fixed point scale factor
|
|
* angle - 8bit angle (0=0deg, 255=360deg)
|
|
*
|
|
***************************************************************/
|
|
|
|
void GraphicBufferClass::Scale_Rotate(BitmapClass &bmp,TPoint2D const &pt,long scale,unsigned char angle)
|
|
{
|
|
unsigned int scrpos;
|
|
unsigned int temp;
|
|
|
|
int i,j; // counter vars
|
|
int pxerror =0; // these three vars will be used in an
|
|
int pyerror =0; // integer difference alg to keep track
|
|
int pixpos =0; // of what pixel to draw.
|
|
unsigned char pixel;
|
|
|
|
TPoint2D p0; // "upper left" corner of the rectangle
|
|
TPoint2D p1; // "upper right" corner of the rectangle
|
|
TPoint2D p2; // "lower left" corner of the rectangle
|
|
|
|
/*-------------------------------------------------
|
|
Compute three corner points of the rectangle
|
|
-------------------------------------------------*/
|
|
{
|
|
angle &= 0x0FF;
|
|
long c = _CosineTab[angle];
|
|
long s = _SineTab[angle];
|
|
long W = (scale*bmp.Width)>>1;
|
|
long L = (scale*bmp.Height)>>1;
|
|
|
|
p0.x = (pt.x + ((( (L*c) >> 8)-((W*s) >> 8)) >> 8));
|
|
p0.y = (pt.y + (((-(L*s) >> 8)-((W*c) >> 8)) >> 8));
|
|
p1.x = (pt.x + ((( (L*c) >> 8)+((W*s) >> 8)) >> 8));
|
|
p1.y = (pt.y + (((-(L*s) >> 8)+((W*c) >> 8)) >> 8));
|
|
p2.x = (pt.x + (((-(L*c) >> 8)-((W*s) >> 8)) >> 8));
|
|
p2.y = (pt.y + ((( (L*s) >> 8)-((W*c) >> 8)) >> 8));
|
|
}
|
|
|
|
/*-----------------------------------
|
|
Initialize Breshnam constants
|
|
-----------------------------------*/
|
|
|
|
// This breshnam line goes across the FRONT of the rectangle
|
|
// In the bitmap, this will step from left to right
|
|
|
|
int f_deltax =(p1.x-p0.x);
|
|
int f_deltay =(p1.y-p0.y);
|
|
int f_error =0;
|
|
int f_xstep =1;
|
|
int f_ystep =Width;
|
|
|
|
// This breshnam line goes down the SIDE of the rectangle
|
|
// In the bitmap, this line will step from top to bottom
|
|
|
|
int s_deltax =(p2.x-p0.x);
|
|
int s_deltay =(p2.y-p0.y);
|
|
int s_error =0;
|
|
int s_xstep =1;
|
|
int s_ystep =Width;
|
|
|
|
/*--------------------------------
|
|
fixup deltas and step values
|
|
--------------------------------*/
|
|
|
|
if (f_deltay<0) {
|
|
f_deltay=-f_deltay;
|
|
f_ystep=-Width;
|
|
};
|
|
|
|
if (f_deltax<0) {
|
|
f_deltax=-f_deltax;
|
|
f_xstep=-1;
|
|
};
|
|
|
|
if (s_deltay<0) {
|
|
s_deltay=-s_deltay;
|
|
s_ystep=-Width;
|
|
};
|
|
|
|
if (s_deltax<0) {
|
|
s_deltax=-s_deltax;
|
|
s_xstep=-1;
|
|
};
|
|
|
|
scrpos=p0.x+Width*p0.y; //address of initial screen pos.
|
|
temp=scrpos;
|
|
|
|
/*---------------------------------------------------------------------
|
|
Now all of the differences, errors, and steps are set up so we can
|
|
begin drawing the bitmap...
|
|
|
|
There are two cases here,
|
|
1 - the "Front" line has a slope of < 1.0 (45 degrees)
|
|
2 - the "Front" line has a slope of >= 1.0
|
|
|
|
For case 1, we step along the X direction, for case 2, step in y
|
|
---------------------------------------------------------------------*/
|
|
|
|
if (f_deltax>f_deltay) { //CASE 1, step front in X, side in Y
|
|
|
|
// outer loop steps from top to bottom of the rectangle
|
|
for (j=0;j<s_deltay;j++)
|
|
{
|
|
temp=scrpos;
|
|
|
|
// The inner loop steps across the rectangle
|
|
for (i=0;i<f_deltax;i++)
|
|
{
|
|
pixel=bmp.Data[pixpos]; //read pixel
|
|
if (pixel) ((unsigned char *)Get_Buffer())[scrpos]=pixel; //draw if not transparent
|
|
// if (pixel) Data[scrpos]=pixel; //draw if not transparent
|
|
pxerror+=bmp.Width; //update position in bitmap
|
|
while (pxerror>f_deltax)
|
|
{
|
|
pixpos++;
|
|
pxerror-=f_deltax;
|
|
};
|
|
scrpos+=f_xstep; //step to next screen pos
|
|
f_error+=f_deltay;
|
|
if (f_error>f_deltax)
|
|
{
|
|
if (pixel) ((unsigned char *)Get_Buffer())[scrpos]=pixel;
|
|
f_error-=f_deltax;
|
|
scrpos+=f_ystep;
|
|
};
|
|
};
|
|
pxerror=0;
|
|
pixpos-=bmp.Width-1;
|
|
pyerror+=bmp.Height;
|
|
|
|
while (pyerror>s_deltay)
|
|
{
|
|
pixpos+=bmp.Width;
|
|
pyerror-=s_deltay;
|
|
};
|
|
|
|
f_error=0;
|
|
scrpos=temp;
|
|
scrpos+=s_ystep;
|
|
s_error+=s_deltax;
|
|
|
|
if (s_error>s_deltay)
|
|
{
|
|
s_error-=s_deltay;
|
|
scrpos+=s_xstep;
|
|
};
|
|
}
|
|
|
|
} else { // CASE 2, Step front line in X, side line in Y
|
|
|
|
// outer loop steps from top to bottom of the rectangle
|
|
for (j=0;j<s_deltax;j++)
|
|
{
|
|
temp=scrpos;
|
|
|
|
// The inner loop steps across the rectangle
|
|
for (i=0;i<f_deltay;i++)
|
|
{
|
|
pixel=bmp.Data[pixpos]; //read pixel
|
|
if (pixel) ((unsigned char *)Get_Buffer())[scrpos]=pixel; //draw if not transparent
|
|
pxerror+=bmp.Width; //update position in bitmap
|
|
while (pxerror>f_deltay)
|
|
{
|
|
pixpos++;
|
|
pxerror-=f_deltay;
|
|
};
|
|
|
|
scrpos+=f_ystep; //step to next screen pos
|
|
f_error+=f_deltax;
|
|
if (f_error>f_deltay)
|
|
{
|
|
if (pixel) ((unsigned char *)Get_Buffer())[scrpos]=pixel;
|
|
f_error-=f_deltay;
|
|
scrpos+=f_xstep;
|
|
};
|
|
};
|
|
|
|
pxerror=0;
|
|
pixpos-=bmp.Width-1;
|
|
pyerror+=bmp.Height;
|
|
while (pyerror>s_deltax)
|
|
{
|
|
pixpos+=bmp.Width;
|
|
pyerror-=s_deltax;
|
|
};
|
|
|
|
scrpos=temp;
|
|
scrpos+=s_xstep;
|
|
s_error+=s_deltay;
|
|
f_error=0;
|
|
if (s_error>s_deltax)
|
|
{
|
|
s_error-=s_deltax;
|
|
scrpos+=s_ystep;
|
|
};
|
|
}
|
|
}
|
|
} |