TeslaRel410/CODE/BT/MUNGA/COLOR.HPP

//===========================================================================//
// File:     color.hh                                                        //
// Title:    Declaration of Color classes.                                   //
// Project:  Tool Architecture II                                            //
// Author:   Jerry Edsall & Ken Olsen (based on work by J.M. Albertson)      //
// Purpose:  Stores color information.                                       //
//---------------------------------------------------------------------------//
//   Date    Who  Modification                                               //
// --------  ---  ---------------------------------------------------------- //
// 12/15/94  KEO  Added RGBAColor class.                                     //
// 11/12/95	 GDU  Added MUNGA signatures and stream IO, moved to MUNGA       //
//---------------------------------------------------------------------------//
// Copyright (c) 1994 Virtual World Entertainment, Inc.                      //
//   All rights reserved worldwide.                                          //
// This unpublished source code is PROPRIETARY and CONFIDENTIAL.             //
//===========================================================================//

#if !defined(COLOR_HPP)
	#define COLOR_HPP

	#if !defined(MEMSTRM_HPP)
		#include <memstrm.hpp>
	#endif

	#if !defined(SCALAR_HPP)
		#include <scalar.hpp>
	#endif

	//##########################################################################
	//##############    RGBColor    ############################################
	//##########################################################################

	class RGBColor
	{
		friend class RGBAColor;

	public:
		Scalar
			Red,
			Green,
			Blue;

		#if defined(USE_SIGNATURE)
			friend int
				Is_Signature_Bad(const volatile RGBColor *p);
		#endif


		RGBColor()
		{
			Red = Green = Blue = -1.0f;
		}

		RGBColor(
			Scalar r,
			Scalar g,
			Scalar b
			)
		{
			Red = r;
			Green = g;
			Blue = b;
		}

		Logical
			operator==(const RGBColor &a_RGBColor) const
				{ return !memcmp(this, &a_RGBColor, sizeof(RGBColor)); }
		Logical
			operator!=(const RGBColor &a_RGBColor) const
				{ return memcmp(this, &a_RGBColor, sizeof(RGBColor)); }

		Logical
			TestInstance() const;

		RGBColor
			operator+(const RGBColor &a_RGBColor) const
				{
					return RGBColor (
						min(this->Red + a_RGBColor.Red, 1.0),
						min(this->Green + a_RGBColor.Green, 1.0),
						min(this->Blue + a_RGBColor.Blue, 1.0));
				}
		Scalar
			Infrared() const
				{ return 0.3 * this->Red + 0.5 * this->Green + 0.2 * this->Blue; }

	//
	// Support functions
	//
		friend ostream&
			operator<<(
				ostream& stream,
				const RGBColor& C
			);


	private:
		Scalar
			min(Scalar x, Scalar y) const
				{ return x < y ? x : y; }


	};

	//~~~~~~~~~~~~~~~~~~~~~~~~~~ RGBColor functions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~

   void
   	Convert_From_Ascii(
			const char *str,
			RGBColor *color
      );

	inline MemoryStream&
		MemoryStream_Read(
			MemoryStream* stream,
			RGBColor *output
		)
			{return stream->ReadBytes(output, sizeof(*output));}
	inline MemoryStream&
		MemoryStream_Write(
			MemoryStream* stream,
			const RGBColor *input
		)
			{return stream->WriteBytes(input, sizeof(*input));}

	//##########################################################################
	//##############    RGBAColor    ###########################################
	//##########################################################################

	class RGBAColor:
		public RGBColor
	{
	public:
		Scalar
			Alpha;
		
		RGBAColor():
			RGBColor()
			{ Alpha = -1.0f; }

		RGBAColor(
			Scalar r,
			Scalar g,
			Scalar b,
			Scalar a
			):
			RGBColor(r, g, b)
			{ Alpha = a; }

		Logical
			operator==(const RGBAColor &a_RGBAColor) const
				{ return !memcmp(this, &a_RGBAColor, sizeof(RGBAColor)); }
		Logical
			operator!=(const RGBAColor &a_RGBAColor) const
				{ return memcmp(this, &a_RGBAColor, sizeof(RGBAColor)); }

	//
	// Support functions
	//
		friend ostream&
			operator<<(
				ostream& stream,
				const RGBAColor& c
			);
	};

	//~~~~~~~~~~~~~~~~~~~~~~~~~~ RGBAColor functions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~

	void
		Convert_From_Ascii(
			const char *str,
		  RGBAColor *color
		);

	inline MemoryStream&
		MemoryStream_Read(
			MemoryStream* stream,
			RGBAColor *output
		)
			{return stream->ReadBytes(output, sizeof(*output));}
	inline MemoryStream&
		MemoryStream_Write(
			MemoryStream* stream,
			const RGBAColor *input
		)
			{return stream->WriteBytes(input, sizeof(*input));}

#endif

//=============================================================================