ben/CnC_Red_Alert
1
0
Fork 0
mirror of https://github.com/electronicarts/CnC_Red_Alert.git synced 2025-12-16 07:31:39 -05:00
Code Issues Packages Projects Releases Wiki Activity

Initial commit of Command & Conquer Red Alert source code.

Browse Source
This commit is contained in:
LFeenanEA
2025-02-27 16:15:05 +00:00
parent b685cea758
commit 5e733d5dcc
2082 changed files with 797727 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

162
CODE/SURFACE.CPP Normal file
View File

@@ -0,0 +1,162 @@
/*
** Command & Conquer Red Alert(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/>.
*/
/* $Header: /CounterStrike/SURFACE.CPP 1 3/03/97 10:25a Joe_bostic $ */
/***********************************************************************************************
*** 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 *
* *
* File Name : SURFACE.CPP *
* *
* Programmer : Joe L. Bostic *
* *
* Start Date : 09/08/96 *
* *
* Last Update : September 8, 1996 [JLB] *
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "surface.h"
Surface::Surface(int w, int h, Buffer const * buffer, int pitch) :
Width(w),
Height(h),
Pitch(pitch)
{
/*
** If a buffer was specified, then this means that the surface will use the buffer memory
** and thus not allocate and manage its own memory.
*/
if (buffer != NULL) {
SurfaceData = *buffer;
/*
** Reduce the dimensions if the buffer is not big enough. This size bounding is only
** possible if the buffer size is known. Otherwise, presume that it is big enough.
*/
if (buffer->Get_Size() > 0 && Get_Size() > buffer->Get_Size()) {
Height = buffer->Get_Size() / (Width+Pitch);
if (Height == 0) {
Height = 1;
Width = buffer->Get_Size();
}
}
} else {
/*
** A new buffer without existing memory specified, will allocate and manage its
** own memory for the surface.
*/
new(&SurfaceData) Buffer(Logical_Size());
}
}
Surface::Surface(Surface const & surface, int x, int y, int w, int h) :
Width(w),
Height(h),
Pitch(surface.Bytes_Per_Line() % w)
{
new(&SurfaceData) Buffer((char*)surface.Get_Buffer() + y*surface.Bytes_Per_Line() + x);
}
void Surface::Copy_To(Buffer & buffer, int x, int y, int w, int h) const
{
assert(buffer.Is_Valid());
/*
** Determine the width of the region to copy from this surface.
*/
int width = w;
if (width == -1) {
width = Width;
}
/*
** Determine the height of the region to copy from this surface.
*/
int height = h;
if (height == -1) {
height = Height;
}
Copy_To(Rect(x, y, width, height), buffer);
}
void Surface::Copy_To(Rect const & fromrect, Buffer & tobuffer) const
{
assert(fromrect.Is_Valid());
assert(tobuffer.Is_Valid());
/*
** Determine the copy-from rectangle. The size is bounded to the source
** size of the surface, regardless of what was specified as the source
** rectangle.
*/
Rect rect = fromrect.Intersect(Rect(0, 0, Width, Height));
/*
** Determine the number of bytes to copy. If this number would be
** larger than the size of the destination buffer (presuming the size
** of the destination buffer is known), then limit the copy size
** to the buffer size.
*/
int tocopy = rect.Size();
if (tobuffer.Get_Size() > 0 && tobuffer.Get_Size() > tocopy) {
tocopy = tobuffer.Get_Size();
}
/*
** Determine the source starting byte pointer.
*/
char * source = Get_Buffer() + rect.Y*Bytes_Per_Line() + rect.X;
/*
** Determine the destination buffer pointer. This will always be the
** start of the destination buffer object specified.
*/
char * dest = tobuffer;
/*
** Determine the working pitch value to use. For full width surface
** copies on surfaces that have no inherent pitch, then a very fast
** copy-in-one-fast-step operation can be performed.
*/
int pitch = Bytes_Per_Line() % rect.Width;
if (pitch == 0) {
memmove(dest, source, tocopy);
} else {
/*
** Copy the source to the destination in line segments.
*/
for (int y = 0; y < rect.Height; y++) {
memmove(dest, source, width);
dest += rect.Width;
source += rect.Width + pitch;
}
}
}