mlrstate.hpp

机甲指挥官2源代码

//===========================================================================//
// Copyright (C) Microsoft Corporation. All rights reserved.                 //
//===========================================================================//

#pragma once
#define MLR_MLRSTATE_HPP

#if !defined(MLR_MLR_HPP)
	#include <MLR\MLR.hpp>
#endif

namespace MidLevelRenderer {class MLRState;}

namespace GetHashFunctions {
	Stuff::IteratorPosition
		GetHashValue(const MidLevelRenderer::MLRState &value);
}

namespace MidLevelRenderer {

	class MLRSorter;
	class MLRTexturePool;

	//##########################################################################
	//########################    MLRState    ###############################
	//##########################################################################

	class MLRState
		#if defined(_ARMOR)
			: public Stuff::Signature
		#endif
	{
		friend class MLRSorter;

	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	// Constructors/Destructors
	//
	protected:
		MLRState(
			Stuff::MemoryStream *stream,
			int version
		);

	public:
		MLRState();
		MLRState(const MLRState&);
		~MLRState() {};

		static MLRState*
			Make(
				Stuff::MemoryStream *stream,
				int version
			);

		void
			Save(Stuff::MemoryStream *stream);
		void
			Load(
				Stuff::MemoryStream *stream,
				int version
			);

	//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	// Render state
	//
	public:
		enum {
			TextureNumberBit = 0,
			TextureNumberBits = Limits::Max_Number_Of_Texture_Bits,
			TextureMask =
				(0xFFFFFFFF >> (Stuff::INT_BITS - TextureNumberBits)) << TextureNumberBit,

			AlphaBit = TextureNumberBit + TextureNumberBits,
			AlphaBits = 3,
			AlphaMask =  (0xFFFFFFFF >> (Stuff::INT_BITS - AlphaBits)) << AlphaBit,

			FilterBit = AlphaBit + AlphaBits,
			FilterBits = 2,
			FilterMask = (0xFFFFFFFF >> (Stuff::INT_BITS - FilterBits)) << FilterBit,

			FogBit = FilterBit + FilterBits,
			FogBits = 2,
			FogMask = (0xFFFFFFFF >> (Stuff::INT_BITS - FogBits)) << FogBit,

			TextureWrapBit = FogBit + FogBits,
			TextureWrapMask = 1 << TextureWrapBit,

			DitherBit = TextureWrapBit+1,
			DitherMask = 1<<DitherBit,

			TextureCorrectionBit = DitherBit+1,
			TextureCorrectionMask = 1<<TextureCorrectionBit,

			WireFrameBit = TextureCorrectionBit + 1,
			WireFrameBits = 2,
			WireFrameMask =
				(0xFFFFFFFF >> (Stuff::INT_BITS - WireFrameBits)) << WireFrameBit,

			ZBufferWriteBit = WireFrameBit + WireFrameBits,
			ZBufferWriteMask = 1<<ZBufferWriteBit,

			ZBufferCompareBit = ZBufferWriteBit + 1,
			ZBufferCompareMask = 1<<ZBufferCompareBit,

			SpecularBit = ZBufferCompareBit + 1,
			SpecularMask = 1 << SpecularBit,

			FlatColoringBit = SpecularBit + 1,
			FlatColoringMask = 1 << FlatColoringBit,

			UsedRenderBits = FlatColoringBit + 1,
			UsedRenderMask = 0xFFFFFFFF >> (Stuff::INT_BITS - UsedRenderBits)
		};

		enum AlphaMode {
			OneZeroMode = 0,
			OneOneMode = 1 << AlphaBit,
			AlphaOneMode = 2 << AlphaBit,
			OneAlphaMode = 3 << AlphaBit,
			AlphaInvAlphaMode = 4 << AlphaBit,
			OneInvAlphaMode = 5 << AlphaBit,

			FirstAlphaAlphaMode = OneOneMode
		};

		enum FilterMode {
			NoFilterMode = 0,
			BiLinearFilterMode = 1 << FilterBit,
			TriLinearFilterMode = 2 << FilterBit
		};

		enum SpecularMode {
			SpecularOffMode = 0,
			SpecularOnMode = 1 << SpecularBit
		};

		enum TextureWrapMode {
			TextureWrap = 0,
			TextureClamp = 1 << TextureWrapBit
		};

		enum DitherMode {
			DitherOffMode = 0,
			DitherOnMode = 1 << DitherBit
		};

		enum TextureCorrectionMode {
			TextureCorrectionOffMode = 0,
			TextureCorrectionOnMode = 1 << TextureCorrectionBit
		};

		enum WireFrameMode {
			WireFrameOffMode = 0,
			WireFrameOnlyMode = 1 << WireFrameBit,
			WireFrameAddMode = 2 << WireFrameBit
		};

		enum ZBufferWriteMode {
			ZBufferWriteOffMode = 0,
			ZBufferWriteOnMode = 1 << ZBufferWriteBit
		};

		enum ZBufferCompareMode {
			ZBufferCompareOffMode = 0,
			ZBufferCompareOnMode = 1 << ZBufferCompareBit
		};

		enum FlatColoringMode {
			FlatColoringOffMode = 0,
			FlatColoringOnMode = 1 << FlatColoringBit
		};

// manipulate render state
		void
			SetTextureHandle(unsigned texture)
				{
					Check_Object(this); renderState &= ~TextureMask;
					renderDeltaMask |= TextureMask;
					Verify(texture <= TextureMask); renderState |= texture;
				}
		unsigned
			GetTextureHandle() const
				{Check_Object(this); return renderState & TextureMask;}

		void
			SetAlphaMode(AlphaMode alpha)
				{Check_Object(this); renderState &= ~AlphaMask; renderState |= alpha; renderDeltaMask |= AlphaMask;}
		AlphaMode
			GetAlphaMode() const
				{
					Check_Object(this);
					return static_cast<AlphaMode>(renderState & AlphaMask);
				}

		void
			SetFilterMode(FilterMode filter)
				{Check_Object(this); renderState &= ~FilterMask; renderState |= filter; renderDeltaMask |= FilterMask;}
		FilterMode
			GetFilterMode() const
				{
					Check_Object(this);
					return static_cast<FilterMode>(renderState & FilterMask);
				}

		void
			SetFogMode(int fog)
				{Check_Object(this); renderState &= ~FogMask; renderState |= (fog<<FogBit); renderDeltaMask |= FogMask;}
		int
			GetFogMode() const
				{Check_Object(this); return (renderState & FogMask)>>FogBit;}

		void
			SetSpecularOn()
				{Check_Object(this); renderState |= SpecularOnMode; renderDeltaMask |= SpecularMask;}
		void
			SetSpecularOff()
				{Check_Object(this); renderState &= ~SpecularOnMode; renderDeltaMask |= SpecularMask;}
		SpecularMode
			GetSpecularMode() const
				{Check_Object(this); return static_cast<SpecularMode>(renderState & SpecularMask);}

		void
			SetTextureWrapMode(TextureWrapMode TextureWrap)
				{Check_Object(this); renderState &= ~TextureWrapMask; renderState |= TextureWrap; renderDeltaMask |= TextureWrapMask;}
		TextureWrapMode
			GetTextureWrapMode() const
				{
					Check_Object(this);
					return static_cast<TextureWrapMode>(renderState & TextureWrapMask);
				}

		void
			SetDitherOn()
				{Check_Object(this); renderState |= DitherOnMode; renderDeltaMask |= DitherMask;}
		void
			SetDitherOff()
				{Check_Object(this); renderState &= ~DitherOnMode; renderDeltaMask |= DitherMask;}
		DitherMode
			GetDitherMode() const
				{Check_Object(this); return static_cast<DitherMode>(renderState & DitherMask);}

		void
			SetTextureCorrectionOn()
				{Check_Object(this); renderState |= TextureCorrectionOnMode; renderDeltaMask |= TextureCorrectionMask;}
		void
			SetTextureCorrectionOff()
				{Check_Object(this); renderState &= ~TextureCorrectionOnMode; renderDeltaMask |= TextureCorrectionMask;}
		TextureCorrectionMode
			GetTextureCorrectionMode() const
				{Check_Object(this); return static_cast<TextureCorrectionMode>(renderState & TextureCorrectionMask);}

		void
			SetWireFrameMode(WireFrameMode wire)
				{Check_Object(this); renderState &= ~WireFrameMask; renderState |= wire; renderDeltaMask |= WireFrameMask;}
		WireFrameMode
			GetWireFrameMode() const
				{
					Check_Object(this);
					return static_cast<WireFrameMode>(renderState & WireFrameMask);
				}

		void
			SetZBufferWriteOn()
				{Check_Object(this); renderState |= ZBufferWriteOnMode; renderDeltaMask |= ZBufferWriteMask;}
		void
			SetZBufferWriteOff()
				{Check_Object(this); renderState &= ~ZBufferWriteOnMode; renderDeltaMask |= ZBufferWriteMask;}
		ZBufferWriteMode
			GetZBufferWriteMode() const
				{Check_Object(this); return static_cast<ZBufferWriteMode>(renderState & ZBufferWriteMask);}

		void
			SetZBufferCompareOn()
				{Check_Object(this); renderState |= ZBufferCompareOnMode; renderDeltaMask |= ZBufferCompareMask;}
		void
			SetZBufferCompareOff()
				{Check_Object(this); renderState &= ~ZBufferCompareOnMode; renderDeltaMask |= ZBufferCompareMask;}
		ZBufferCompareMode
			GetZBufferCompareMode() const
				{Check_Object(this); return static_cast<ZBufferCompareMode>(renderState & ZBufferCompareMask);}

		void
			SetFlatColoringOn()
				{Check_Object(this); renderState |= FlatColoringOnMode; renderDeltaMask |= FlatColoringMask;}
		void
			SetFlatColoringOff()
				{Check_Object(this); renderState &= ~FlatColoringOnMode; renderDeltaMask |= FlatColoringMask;}
		FlatColoringMode
			GetFlatColoringMode() const
				{Check_Object(this); return static_cast<FlatColoringMode>(renderState & FlatColoringMask);}

		void