CWE-ou-minkata/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/>.

Additional permissions under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.

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