RedAlert/WIN32LIB/MISC/LIB.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: g:/library/source/rcs/./lib.c 1.16 1994/05/20 15:34:33 joe_bostic Exp $ */
/***************************************************************************
 **   C O N F I D E N T I A L --- W E S T W O O D   A S S O C I A T E S   **
 ***************************************************************************
 *                                                                         *
 *                 Project Name : Library Routines                         *
 *                                                                         *
 *                    File Name : LIB.C                                    *
 *                                                                         *
 *                   Programmer : Scott Bowen                              *
 *                                                                         *
 *                   Start Date : January 14, 1993                         *
 *                                                                         *
 *                  Last Update : May 20, 1993   [PWG]                     *
 *                                                                         *
 *-------------------------------------------------------------------------*
 * Functions:                                                              *
 *   Add_Long_To_Pointer -- Pointer arithmatic when pointer could be XMS.  *
 *   Find_Argv -- Checks to see if string is in arguement              		*
 *   Mono_Mem_Dump -- Dumps memory to mono monitor with hex and char.      *
 *   Convert_HSV_To_RGB -- Converts HSV cordinates to RGB values           *
 *   Convert_RGB_To_HSV -- Converts RGB to RSV coordinates.                *
 *   Set_Search_Drives -- Sets up the CDRom and HardDrive paths.           *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */


#include <dos.h>
#include <stdio.h>
#include <string.h>
#include "misc.h"

//PRIVATE unsigned Divide_With_Round(unsigned num, unsigned den);


/***************************************************************************
 * Divide_With_Round -- Divides integers and round to nearest integer.     *
 *                                                                         *
 * INPUT:         int numberator.                                         *
 *                int denominator.                                        *
 *                                                                         *
 * OUTPUT:        Returns value rounded.                                   *
 *                                                                         *
 * WARNINGS:                                                               *
 *                                                                         *
 * HISTORY:                                                                *
 *   02/13/1992  SB : Created.                                             *
 *=========================================================================*/
static unsigned Divide_With_Round(unsigned num, unsigned den)
{
	// return num/den + (0 ro 1).  1 if the remainder is more than half the denominator.
	return( (num / den) + (unsigned)((num % den) >= ((den + 1) >> 1)) );
}

#define HSV_BASE 255 // This is used to get a little better persion on HSV conversion.
#define RGB_BASE 63  // Not 64, this is really the max value.


/***************************************************************************
 * Convert_RGB_To_HSV -- Converts RGB to RSV coordinates.                  *
 *                                                                         *
 * INPUT:      int r,g, and b values.                                     *
 *             int *h, *s, and *v pointers.                              	*
 *                                                                         *
 * OUTPUT:     Assigns values to *h, *s, and *v.                           *
 *                                                                         *
 * WARNINGS:   The reason we use a different base for HSV then RGB is      *
 *             because we loose alot of persision by not using floating    *
 *             point.  Using the same base value (63) made it so that      *
 *             about 50% of the time one RGB value would be one different  *
 *             then the original if you went from RGB to HSV to RGB.       *
 *             Using 255 drop it down to about 9% of the time we get an    *
 *             off value.  To get it perfect, we would have to make the    *
 *             HSV base larger - but then you need to do all calculations  *
 *             in long instead of unsigned int.                                   *
 * HISTORY:                                                                *
 *   02/11/1992  SB : Created.                                             *
 *=========================================================================*/
void Convert_RGB_To_HSV(unsigned int r, unsigned int g, unsigned int b, unsigned int *h, unsigned int *s, unsigned int *v)
{
 	unsigned int m, r1, g1, b1, tmp;

	// Convert RGB base to HSV base.
	r = Divide_With_Round((r * HSV_BASE), RGB_BASE);
	g = Divide_With_Round((g * HSV_BASE), RGB_BASE);
	b = Divide_With_Round((b * HSV_BASE), RGB_BASE);

	// Set hue to default.
	*h = 0;

	// Set v = Max(r,g,b) to find dominant primary color.
	*v = (r > g) ? r : g;
	if (b > *v) *v = b;

	// Set m = min(r,g,b) to find amount of white.
	m = (r < g) ? r : g;
	if (b < m) m = b;

	// Determine the normalized saturation.
	if (*v != 0) {
		*s = Divide_With_Round( (*v - m) * HSV_BASE ,*v);
	} else {
		*s = 0;
	}

	if (*s != 0) {
		tmp = *v - m;
	 	r1 = Divide_With_Round( (*v - r) * HSV_BASE, tmp);
	 	g1 = Divide_With_Round( (*v - g) * HSV_BASE, tmp);
	 	b1 = Divide_With_Round( (*v - b) * HSV_BASE, tmp);

		// Find effect of second most predominant color.
		// In which section of the hexagon of colors does the color lie?
		if ((*v) == r) {
		 	if (m == g) {
				*h = 5 * HSV_BASE + b1;
			} else {
				*h = 1 * HSV_BASE - g1;
			}
		} else {
			if ((*v) == g) {
			 	if (m == b) {
					*h = 1 * HSV_BASE + r1;
				} else {
					*h = 3 * HSV_BASE - b1;
				}
			} else {
				// *v == b
			 	if (m == r) {
					*h = 3 * HSV_BASE + g1;
				} else {
					
					*h = 5 * HSV_BASE - r1;
				}
			}
		}

		// Divide by six and round.
		*h = Divide_With_Round(*h, 6);
	}
}

/***************************************************************************
 * Convert_HSV_To_RGB -- Converts HSV cordinates to RGB values             *
 *                                                                         *
 * INPUT:      int h,s, and v coordinates                                 *
 *             int *r, *g, and *b pointers.                              	*
 *                                                                         *
 * OUTPUT:     Assigns values to *r, *g, and *b.                           *
 *                                                                         *
 * WARNINGS:                                                               *
 *                                                                         *
 * HISTORY:                                                                *
 *   02/11/1992  SB : Created.                                             *
 *=========================================================================*/
void Convert_HSV_To_RGB(unsigned int h, unsigned int s, unsigned int v, unsigned int *r, unsigned int *g, unsigned int *b)
{
	unsigned int i;				// Integer part.
	unsigned int f;				// Fractional or remainder part.  f/HSV_BASE gives fraction.
	unsigned int tmp;			// Tempary variable to help with calculations.
	unsigned int values[7];	// Possible rgb values.  Don't use zero.


	h *= 6;
	f = h % HSV_BASE;

	// Set up possible red, green and blue values.
	values[1] =	
	values[2] = v;

	//
	// The following lines of code change 
	//	values[3] = (v * (HSV_BASE - ( (s * f) / HSV_BASE) )) / HSV_BASE;
	//	values[4] = values[5] = (v * (HSV_BASE - s)) / HSV_BASE;
	// values[6] = (v * (HSV_BASE - (s * (HSV_BASE - f)) / HSV_BASE)) / HSV_BASE;
	// so that the are rounded divides.
	//

	tmp = Divide_With_Round(s * f, HSV_BASE);
	values[3] = Divide_With_Round(v * (HSV_BASE - tmp), HSV_BASE);

	values[4] = 
	values[5] = Divide_With_Round(v * (HSV_BASE - s), HSV_BASE);

	tmp = HSV_BASE - Divide_With_Round(s * (HSV_BASE - f),  HSV_BASE);
	values[6] = Divide_With_Round(v * tmp, HSV_BASE);


	// This should not be rounded.
	i = h / HSV_BASE;

	i += (i > 4) ? -4 : 2;
	*r = Divide_With_Round(values[i] * RGB_BASE, HSV_BASE);

	i += (i > 4) ? -4 : 2;
	*b = Divide_With_Round(values[i] * RGB_BASE, HSV_BASE);

	i += (i > 4) ? -4 : 2;
	*g = Divide_With_Round(values[i] * RGB_BASE, HSV_BASE);
}