tiberium/CnC_Remastered_Collection
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial Source Code commit

Browse source 
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.
This commit is contained in:
PG-SteveT 2020-05-27 12:16:20 -07:00
parent ea8ecc76fa
commit 03416d24e1
1038 changed files with 629779 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

246
REDALERT/RGB.CPP Normal file
View file

@ -0,0 +1,246 @@
//
// 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/RGB.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 : RGB.CPP *
* *
* Programmer : Joe L. Bostic *
* *
* Start Date : 12/02/95 *
* *
* Last Update : February 20, 1996 [JLB] *
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* RGBClass::Adjust -- Adjust one RGB value toward another. *
* RGBClass::Difference -- Determines the "distance" between two colors. *
* RGBClass::Set -- Set the color index to the RGB object specified. *
* RGBClass::operator HSVClass -- Conversion operator for RGB to HSV object. *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "watcom.h"
#include "rgb.h"
#include "hsv.h"
#include "palettec.h"
RGBClass const BlackColor(0, 0, 0);
/***********************************************************************************************
* RGBClass::Adjust -- Adjust one RGB value toward another. *
* *
* This routine is used to modify an RGB value to proportionately match another RGB value *
* according to the ratio parameter specified. Typical use of this routine is in palette *
* fading from one palette to another or to black. *
* *
* INPUT: ratio -- The ration of transformation. This value is in the form of 0 to 255, *
* with 0 being no change, and 255 being 100% transformed into the *
* destination color. *
* *
* rgb -- Reference to the destination RGB color to transform this color into. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/02/1995 JLB : Created. *
*=============================================================================================*/
void RGBClass::Adjust(int ratio, RGBClass const & rgb)
{
/*
** Ratio conversion is limited to 0 through 100%. This is
** the range of 0 to 255.
*/
ratio &= 0x00FF;
/*
** Adjust the color guns by the ratio specified toward the
** destination color.
*/
int value = (int)rgb.Red - (int)Red;
Red = (int)Red + (value * ratio) / 256;
value = (int)rgb.Green - (int)Green;
Green = (int)Green + (value * ratio) / 256;
value = (int)rgb.Blue - (int)Blue;
Blue = (int)Blue + (value * ratio) / 256;
}
/***********************************************************************************************
* RGBClass::Difference -- Determines the "distance" between two colors. *
* *
* This routine is used to calculate a relative distance between two colors. The value is *
* relative only to itself and thus is useful only for determining the magnitude of *
* color difference rather than the nature of the color difference. Palette remapping *
* code uses this routine to find closest matches for colors. *
* *
* INPUT: rgb -- Reference to the color to be compared to this color. *
* *
* OUTPUT: Returns the difference between the two colors. The value returned is zero if the *
* colors exactly match. The greater the positive value the greater the difference *
* between the colors. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/02/1995 JLB : Created. *
*=============================================================================================*/
int RGBClass::Difference(RGBClass const & rgb) const
{
int r = (int)Red - (int)rgb.Red;
if (r < 0) r = -r;
int g = (int)Green - (int)rgb.Green;
if (g < 0) g = -g;
int b = (int)Blue - (int)rgb.Blue;
if (b < 0) b = -b;
return(r*r + g*g + b*b);
}
/***********************************************************************************************
* RGBClass::operator HSVClass -- Conversion operator for RGB to HSV object. *
* *
* This conversion operator will convert an RGBClass object into an HSVClass object. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with a reference (implicit) to the HSVClass object that most closely *
* represents the RGBClass object. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 02/20/1996 JLB : Created. *
*=============================================================================================*/
RGBClass::operator HSVClass (void) const
{
int hue;
int saturation;
int value;
/*
** Fetch working component values for the color guns.
*/
int red = Red_Component();
int green = Green_Component();
int blue = Blue_Component();
/*
** The hue defaults to none. Only if there is a saturation value will the
** hue be calculated.
*/
hue = 0;
/*
** Set the value (brightness) to match the brightest color gun.
*/
value = (red > green) ? red : green;
if (blue > value) value = blue;
/*
** Determine the amount of true white present in the color. This is the
** minimum color gun value. The white component is used to determine
** color saturation.
*/
int white = (red < green) ? red : green;
if (blue < white) white = blue;
/*
** Determine the saturation (intensity) of the color by comparing the
** ratio of true white as a component of the overall color. The more
** white component, the less saturation.
*/
saturation = 0;
if (value) {
saturation = ((value - white) * 255) / value;
}
/*
** If there is any saturation at all, then the hue must be calculated. The
** hue is based on a six sided color wheel.
*/
if (saturation != 0) {
unsigned int tmp = value - white;
unsigned int r1 = ((value - red) * 255) / tmp;
unsigned int g1 = ((value - green) * 255) / tmp;
unsigned int b1 = ((value - blue) * 255) / tmp;
// Find effect of second most predominant color.
// In which section of the hexagon of colors does the color lie?
if (value == red) {
if (white == green) {
tmp = 5 * 256 + b1;
} else {
tmp = 1 * 256 - g1;
}
} else {
if (value == green) {
if (white == blue) {
tmp = 1 * 256 + r1;
} else {
tmp = 3 * 256 - b1;
}
} else {
if (white == red) {
tmp = 3 * 256 + g1;
} else {
tmp = 5 * 256 - r1;
}
}
}
// Divide by six and round.
hue = tmp / 6;
}
return(HSVClass(hue, saturation, value));
}
/***********************************************************************************************
* RGBClass::Set -- Set the color index to the RGB object specified. *
* *
* This routine will set the specified color index with this RGBClass object. Use this *
* routine to set one color. *
* *
* INPUT: color -- The color index to set with this RGBClass object. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 02/20/1996 JLB : Created. *
*=============================================================================================*/
void RGBClass::Set(int color) const
{
Raw_Color_Prep(color);
Raw_Set();
((RGBClass &)PaletteClass::CurrentPalette[color]) = *this;
}