RedAlert/CODE/SURFACE.CPP

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