CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plSurface/plLayerInterface.h

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, 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/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/

#ifndef plLayerInterface_inc
#define plLayerInterface_inc

#include "pnNetCommon/plSynchedValue.h"
#include "pnNetCommon/plSynchedObject.h"
#include "hsGMatState.h"

struct hsMatrix44;
struct hsColorRGBA;
class plBitmap;
class plMessage;
class hsGMatState;
class plShader;

class plLayerInterface : public plSynchedObject
{
	friend class plLayerSDLModifier;
public:
	enum plLayerDirtyBits {
		kTransform			= 0x1,
		kPreshadeColor		= 0x2,
		kAmbientColor		= 0x4,
		kOpacity			= 0x8,
		kTexture			= 0x10,
		kState				= 0x20,
		kUVWSrc				= 0x40,
		kLODBias			= 0x80,
		kSpecularColor		= 0x100,
		kSpecularPower		= 0x200,
		kRuntimeColor		= 0x400,
		kVertexShader		= 0x800,
		kPixelShader		= 0x1000,
		kBumpEnvXfm			= 0x2000,

		kAllDirty			= 0xffffffff
	};
	enum plUVWSrcModifiers {
		kUVWPassThru								= 0x00000000,
		kUVWIdxMask									= 0x0000ffff,
		kUVWNormal									= 0x00010000,
		kUVWPosition								= 0x00020000,
		kUVWReflect									= 0x00030000
	};

protected:
	plLayerInterface*		fUnderLay;
	plLayerInterface*		fOverLay;

	// NEVER MODIFY A FIELD THAT ISN'T
	// YOUR OWN PERSONAL COPY.
	// These are accessible so that if you're interface doesn't touch a field,
	// it can set it's pointer to the previous interfaces pointer to that field
	// and never even do a copy. For any fields this interface will alter, you
	// need to alloc your own copy, and in your eval get the previous interface's
	// value, modify it, and write it to your copy. 
	// So, if you don't touch a field, copy the pointer from prev into your channel pointer,
	// else alloc your own and set the value to whatever you like.
	// Then you only need to update your value when the source value changes (you'll know
	// from dirty bits), or when you want to (you'll know from secs/frame).
	
	// fOwnedChannels specifies which channels you have allocated and own (and will delete)
	UInt32					fOwnedChannels;
	// fPassThruChannels are channels which we need to pass through our underlay's values,
	// even if we have a differing opinion on what the value should be. This let's us arbitrate
	// between different layers that control the same channels. A layer can claim control of
	// a channel by telling all other layers to pass through that channel via the 
	// ClaimChannels(UInt32 chans) member function. See .cpp for arbitration rules.
	UInt32					fPassThruChannels;

	hsMatrix44*				fTransform;
	hsColorRGBA*			fPreshadeColor;
	hsColorRGBA*			fRuntimeColor;		// Diffuse color to be used with runtime lights vs. static preshading
	hsColorRGBA*			fAmbientColor;
	hsColorRGBA*			fSpecularColor;
	hsScalar*				fOpacity;
	
	// Would like to abstract out the mipmap, but we'll bring it
	// along for now.
	plBitmap**				fTexture;

	// (Currently) unanimatables.
	hsGMatState*			fState;
	UInt32*					fUVWSrc;
	hsScalar*				fLODBias;
	hsScalar*				fSpecularPower;

	plShader**				fVertexShader;
	plShader**				fPixelShader;

	hsMatrix44*				fBumpEnvXfm;

	void					IUnthread();
	void					ISetPassThru(UInt32 chans);

public:
	plLayerInterface();
	virtual ~plLayerInterface();

	CLASSNAME_REGISTER( plLayerInterface );
	GETINTERFACE_ANY( plLayerInterface, plSynchedObject );

	plLayerInterface*		BottomOfStack() { return fUnderLay ? fUnderLay->BottomOfStack() : this; }
	plLayerInterface*		TopOfStack() { return fOverLay ? fOverLay->TopOfStack() : this; }

	// Used by debug code.
	plLayerInterface*		GetUnderLay() { return fUnderLay; }
	plLayerInterface*		GetOverLay() { return fOverLay; }

	const hsMatrix44&		GetTransform() const { return *fTransform; }
	const hsColorRGBA&		GetPreshadeColor() const { return *fPreshadeColor; }
	const hsColorRGBA&		GetRuntimeColor() const { return *fRuntimeColor; }
	const hsColorRGBA&		GetAmbientColor() const { return *fAmbientColor; }
	const hsColorRGBA&		GetSpecularColor() const { return *fSpecularColor; }
	hsScalar				GetOpacity() const { return *fOpacity; }

	plBitmap*				GetTexture() const { return *fTexture; }

	// (Currently) unanimatables
	UInt32					GetUVWSrc() const { return *fUVWSrc; }
	hsScalar				GetLODBias() const { return *fLODBias; }
	hsScalar				GetSpecularPower() const { return *fSpecularPower; }

	const hsGMatState&		GetState() const { return *fState; }
	UInt32					GetBlendFlags() const { return fState->fBlendFlags; }
	UInt32					GetClampFlags() const { return fState->fClampFlags; }
	UInt32					GetShadeFlags() const { return fState->fShadeFlags; }
	UInt32					GetZFlags() const { return fState->fZFlags; }
	UInt32					GetMiscFlags() const { return fState->fMiscFlags; }

	plShader*				GetVertexShader() const { return *fVertexShader; }
	plShader*				GetPixelShader() const { return *fPixelShader; }

	const hsMatrix44&		GetBumpEnvMatrix() const { return *fBumpEnvXfm; }

	// ClaimChannels will tell every other layer on this stack (besides this) to
	// pass through the value, giving this layer the final say on it's value
	void					ClaimChannels(UInt32 chans);

	// Eval may be called multiple times per frame, or even multiple times per render (for multiple
	// renders per frame). The burden of deciding whether any update is necessary falls to the 
	// derived interface, but here's some info to go on.
	// secs - world time. Time dependent effects (like time of day) look mostly at this.
	// frame - incremented each time the camera moves. View dependent effects look at this.
	// ignore - fields marked ignore will be overwritten (not modified) by an downstream layer, so don't bother computing.
	// return value of fUnderLay->Eval() - bits are true for fields that an interface earlier in the chain dirtied. A field
	//		flagged dirty that you modify (as opposed to overwrite) should be updated regardless of secs and frame.
	//
	virtual UInt32			Eval(double secs, UInt32 frame, UInt32 ignore);

	// Attach gives you a chance to decide whether you want to pass through fields from prev (by copying 
	// the pointers which you then sooner put long pins through your own eyes than modify). Alloc
	// your own fields before Attach, and you can play with them at will. Base class will pass through
	// (via pointer copy) all nil fields. Detach nils out any fields that are just pass through, and
	// unthreads the requested layer from the stack, returning new top-of-stack.
	//
	// Given two stacks A->B and C->D, A->Attach(C) makes A->B->C->D
	virtual plLayerInterface*	Attach(plLayerInterface* prev);
	// Given stack A->B->C->D, A->Detach(C) gives two stacks, A->B and C->D (returned value is A)
	// If A == C (A->B->C && A->Remove(A)), it returns nil, since the it's removed A from the stack, 
	// so the two stacks are now nil and A->B->C
	virtual plLayerInterface*	Detach(plLayerInterface* nuke);
	// Given stack A->B->C->D, A->Remove(C) gives two stacks, A->B->D and C. It returns the stack with C removed.
	// If A==C (A->B->C && A->Remove(A)), it returns B->C.
	virtual plLayerInterface*	Remove(plLayerInterface* nuke);

	plLayerInterface*			GetAttached();
	void						AttachViaNotify(plLayerInterface *prev); // Export only

	hsBool					OwnChannel(UInt32 which) const { return 0 != (fOwnedChannels & which); }

	virtual void			Read(hsStream* s, hsResMgr* mgr);
	virtual void			Write(hsStream* s, hsResMgr* mgr);

	virtual hsBool			MsgReceive(plMessage* msg);

};

#endif // plLayerInterface_inc