CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/NucleusLib/inc/plPipeline.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 plPipeline_inc
#define plPipeline_inc

#include "../pnFactory/plCreatable.h"
#include "hsGMatState.h"
#include "hsTemplates.h"
#include "hsStlUtils.h"

#define MIN_WIDTH 640
#define MIN_HEIGHT 480

#define DEFAULT_WIDTH 800
#define DEFAULT_HEIGHT 600
#define DEFAULT_WINDOWED false
#define DEFAULT_COLORDEPTH 32
#define DEFAULT_ANTIALIASAMOUNT 0
#define DEFAULT_ANISOLEVEL 0
#define DEFAULT_TEXTUREQUALITY 2
#define DEFAULT_VIDEOQUALITY 2
#define DEFAULT_SHADOWS 0
#define DEFAULT_PLANARREFLECTIONS 0


struct hsPoint3;
struct hsVector3;
struct hsMatrix44;
struct hsColorRGBA;
class hsBounds3Ext;
class hsGMaterial;
class plDrawPrim;
class plRenderTarget;
class hsG3DDevice;
class hsGView3;
class plDrawable;
class plGBufferGroup;
class plLayerInterface;
class plSpaceTree;
class plCullPoly;
class plRenderRequest;
class plShadowSlave;
class plAccessSpan;
class plTextFont;
class plVertexSpan;
class plDrawableSpans;
class plSceneObject;
class plClothingOutfit;
class hsGDeviceRef;
class plFogEnvironment;
class plLightInfo;
class plMipmap;
class plVisMgr;

class plViewTransform;


struct PipelineParams
{
	PipelineParams():
	Width(DEFAULT_WIDTH),
	Height(DEFAULT_HEIGHT),
	Windowed(DEFAULT_WINDOWED),
	ColorDepth(DEFAULT_COLORDEPTH),
	AntiAliasingAmount(DEFAULT_ANTIALIASAMOUNT),
	AnisotropicLevel(DEFAULT_ANISOLEVEL),
	TextureQuality(DEFAULT_TEXTUREQUALITY),
	VideoQuality(DEFAULT_VIDEOQUALITY),
	Shadows(DEFAULT_SHADOWS),
	PlanarReflections(DEFAULT_PLANARREFLECTIONS),
#ifndef PLASMA_EXTERNAL_RELEASE
	ForceSecondMonitor(false),
#endif // PLASMA_EXTERNAL_RELEASE
	VSync(false)
	{
	}

	int Width;
	int Height;
	hsBool Windowed;
	int ColorDepth;
	int AntiAliasingAmount;
	int AnisotropicLevel;
	int TextureQuality;
	int VideoQuality;
	int Shadows;
	int PlanarReflections;
	hsBool VSync;
#ifndef PLASMA_EXTERNAL_RELEASE
	hsBool ForceSecondMonitor;
#endif // PLASMA_EXTERNAL_RELEASE
};

class plDisplayMode
{
public:
	int Width;
	int Height;
	int ColorDepth;
};

class plPipeline : public plCreatable
{
public:

	CLASSNAME_REGISTER( plPipeline );
	GETINTERFACE_ANY( plPipeline, plCreatable );

	// Typical 3D device
	//
	// PreRender - fill out the visList with which spans from drawable will be drawn.
	// visList is write only. On output, visList is UNSORTED visible spans.
	// Called once per scene render (maybe multiple times per frame).
	// Returns true if rendering should proceed.
	virtual hsBool						PreRender(plDrawable* drawable, hsTArray<Int16>& visList, plVisMgr* visMgr=nil) = 0;
	// PrepForRender - perform any processing on the drawable data nessecary before rendering.
	// visList is read only. On input, visList is SORTED visible spans, and is ALL spans which will be drawn this render.
	// Called once per scene render. 
	// Returns true if rendering should proceed.
	virtual hsBool						PrepForRender(plDrawable* drawable, hsTArray<Int16>& visList, plVisMgr* visMgr=nil) = 0;
	// Render - draw the drawable to the current render target.
	// visList is read only. On input, visList is SORTED visible spans. May not be the complete list of visible spans
	// for this drawable.
	// Called multiple times per scene render e.g.:
	//		Render(drawable0, visList0) // visList0 contains furthest spans in drawable0
	//		Render(drawable1, visList1) // visList1 contains spans from drawable1 between drawable0's visList0 and visList2
	//		Render(drawable0, visList2) // visList2 contains closest spans in drawable0.
	virtual void						Render(plDrawable* d, const hsTArray<Int16>& visList) = 0;
	// Draw - Convenience wrapper for standalone renders. Calls PreRender, PrepForRender, Render. Currently for internal
	// use only, but may prove useful for procedurals (render to texture).
	virtual void						Draw(plDrawable* d) = 0;
	
	// Device-specific ref creation. Includes buffers and fonts
	virtual plTextFont					*MakeTextFont( char *face, UInt16 size ) = 0;

	// Create and/or Refresh geometry buffers
	virtual void			CheckVertexBufferRef(plGBufferGroup* owner, UInt32 idx) = 0;
	virtual void			CheckIndexBufferRef(plGBufferGroup* owner, UInt32 idx) = 0;

	virtual hsBool			OpenAccess(plAccessSpan& dst, plDrawableSpans* d, const plVertexSpan* span, hsBool readOnly) = 0;
	virtual hsBool			CloseAccess(plAccessSpan& acc) = 0;

	virtual void			CheckTextureRef(plLayerInterface* lay) = 0;		

	// Default fog settings
	virtual void						SetDefaultFogEnviron( plFogEnvironment *fog ) = 0;
	virtual const plFogEnvironment		&GetDefaultFogEnviron( void ) const = 0;

	virtual void						RegisterLight(plLightInfo* light) = 0;
	virtual void						UnRegisterLight(plLightInfo* light) = 0;

	enum RenderTargetFlags
	{
		kRTMainScreen		= 0x0000,
		kRTOffscreen		= 0x0001,
		kRTTexture			= 0x0002,
		kRTPerspProjected	= 0x0004,
		kRTOrthoProjected	= 0x0008,
		kRTProjected		= kRTPerspProjected | kRTOrthoProjected
	};
	enum RenderStateSettings 
	{
		kRenderNormal			= 0x0,
		kRenderProjection		= 0x1,
		kRenderShadow			= 0x2,
		kRenderBaseLayerOnly	= 0x4,
		kRenderNoPiggyBacks		= 0x8,
		kRenderClearColor		= 0x10,
		kRenderClearDepth		= 0x20,
		kRenderOrthogonal		= 0x40,
		kRenderNoProjection		= 0x80,
		kRenderNoLights			= 0x100,
		kRenderShadowErase		= 0x200
	};

	virtual void						PushRenderRequest(plRenderRequest* req) = 0;
	virtual void						PopRenderRequest(plRenderRequest* req) = 0;

	virtual void						ClearRenderTarget( plDrawable* d ) = 0; // nil d reverts to ClearRenderTarget(nil, nil).
	virtual void						ClearRenderTarget(const hsColorRGBA* col = nil, const hsScalar* depth = nil) = 0; // col/depth are overrides for current default.
	virtual void						SetClear(const hsColorRGBA* col=nil, const hsScalar* depth=nil) = 0; // sets the default clear for current render target.
	virtual hsColorRGBA					GetClearColor() const = 0;
	virtual hsScalar					GetClearDepth() const = 0;
	virtual hsGDeviceRef				*MakeRenderTargetRef( plRenderTarget *owner ) = 0;
	virtual void						PushRenderTarget( plRenderTarget *target ) = 0;
	virtual plRenderTarget				*PopRenderTarget( void ) = 0;

	virtual hsBool						BeginRender() = 0;
	virtual hsBool						EndRender() = 0;
	virtual void						RenderScreenElements( void ) = 0;

	virtual hsBool						BeginDrawable(plDrawable* d) = 0;
	virtual hsBool						EndDrawable(plDrawable* d) = 0;

	virtual void						BeginVisMgr(plVisMgr* visMgr) = 0;
	virtual void						EndVisMgr(plVisMgr* visMgr) = 0;

	virtual hsBool						IsFullScreen() const = 0;
	virtual UInt32						Width() const = 0;
	virtual UInt32						Height() const = 0;
	virtual UInt32						ColorDepth() const = 0;
	virtual void						Resize( UInt32 width, UInt32 height ) = 0;

	// Culling. Might be used in Update before bothering to do any serious computation.
	virtual hsBool						TestVisibleWorld(const hsBounds3Ext& wBnd) = 0;
	virtual hsBool						TestVisibleWorld(const plSceneObject* sObj) = 0;
	virtual hsBool						HarvestVisible(plSpaceTree* space, hsTArray<Int16>& visList) = 0;
	virtual hsBool						SubmitOccluders(const hsTArray<const plCullPoly*>& polyList) = 0;
	
	virtual void						SetDebugFlag( UInt32 flag, hsBool on ) = 0;
	virtual hsBool						IsDebugFlagSet( UInt32 flag ) const = 0;
	virtual void						SetMaxCullNodes(UInt16 n) = 0; // Debug/analysis only
	virtual UInt16						GetMaxCullNodes() const = 0; // Debug/analysis only

	// Properties
	enum Properties
	{
		kPropDontDeleteTextures		= 0x00000001			// Keeps the pipeline from deleting textures on 
															// MakeTextureRef, regardless of the kUserOwnsBitmap flag
	};

	virtual hsBool						CheckResources() = 0; // Do we need to call LoadResources?
	virtual void						LoadResources() = 0;

	virtual void						SetProperty( UInt32 prop, hsBool on ) = 0;
	virtual hsBool						GetProperty( UInt32 prop ) const = 0;
	virtual UInt32						GetMaxLayersAtOnce() const = 0;

	// Drawable type mask
	virtual void						SetDrawableTypeMask( UInt32 mask ) = 0;
	virtual UInt32						GetDrawableTypeMask( void ) const = 0;
	virtual void						SetSubDrawableTypeMask( UInt32 mask ) = 0;
	virtual UInt32						GetSubDrawableTypeMask( void ) const = 0;

	// View state
	virtual hsPoint3					GetViewPositionWorld() const = 0;
	virtual hsVector3					GetViewAcrossWorld() const = 0;
	virtual hsVector3					GetViewUpWorld() const = 0;
	virtual hsVector3					GetViewDirWorld() const = 0;
	virtual void						GetViewAxesWorld(hsVector3 axes[3] /* ac,up,at */ ) const = 0;

	virtual void						GetFOV(hsScalar& fovX, hsScalar& fovY) const = 0;
	virtual void						SetFOV(hsScalar fovX, hsScalar fovY) = 0;

	virtual void						GetSize(hsScalar& width, hsScalar& height) const = 0;
	virtual void						SetSize(hsScalar width, hsScalar height) = 0;

	virtual void						GetDepth(hsScalar& hither, hsScalar& yon) const = 0;
	virtual void						SetDepth(hsScalar hither, hsScalar yon) = 0;

	virtual void						SetZBiasScale( hsScalar scale ) = 0;
	virtual hsScalar					GetZBiasScale( void ) const = 0;

	virtual const hsMatrix44&			GetWorldToCamera() const = 0;
	virtual const hsMatrix44&			GetCameraToWorld() const = 0;
	virtual void						SetWorldToCamera(const hsMatrix44& w2c, const hsMatrix44& c2w) = 0;

	virtual const hsMatrix44&			GetWorldToLocal() const = 0;
	virtual const hsMatrix44&			GetLocalToWorld() const = 0;

	virtual const plViewTransform&		GetViewTransform() const = 0;

	virtual void						ScreenToWorldPoint( int n, UInt32 stride, Int32 *scrX, Int32 *scrY, 
													hsScalar dist, UInt32 strideOut, hsPoint3 *worldOut ) = 0;

	virtual void						RefreshMatrices( void ) = 0;
	virtual void						RefreshScreenMatrices( void ) = 0;

	// Overrides, always push returns whatever is necessary to restore on pop.
	virtual hsGMaterial*				PushOverrideMaterial(hsGMaterial* mat) = 0;
	virtual void						PopOverrideMaterial(hsGMaterial* restore) = 0;
	virtual hsGMaterial*				GetOverrideMaterial() const = 0;

	virtual plLayerInterface*			AppendLayerInterface(plLayerInterface* li, hsBool onAllLayers = false) = 0;
	virtual plLayerInterface*			RemoveLayerInterface(plLayerInterface* li, hsBool onAllLayers = false) = 0;

	virtual UInt32						GetMaterialOverrideOn(hsGMatState::StateIdx category) const = 0;
	virtual UInt32						GetMaterialOverrideOff(hsGMatState::StateIdx category) const = 0;

	virtual hsGMatState					PushMaterialOverride(const hsGMatState& state, hsBool on) = 0;
	virtual hsGMatState					PushMaterialOverride(hsGMatState::StateIdx cat, UInt32 which, hsBool on) = 0;
	virtual void						PopMaterialOverride(const hsGMatState& restore, hsBool on) = 0;
	virtual const hsGMatState&			GetMaterialOverride(hsBool on) const = 0;

	virtual hsColorOverride				PushColorOverride(const hsColorOverride& over) = 0;
	virtual void						PopColorOverride(const hsColorOverride& restore) = 0;
	virtual const hsColorOverride&		GetColorOverride() const = 0;

	virtual void						SubmitShadowSlave(plShadowSlave* slave) = 0;
	virtual void						SubmitClothingOutfit(plClothingOutfit* co) = 0;

	// These all return true if the gamma was successfully set.
	virtual hsBool						SetGamma(hsScalar eR, hsScalar eG, hsScalar eB) = 0;
	virtual hsBool						SetGamma(const UInt16* const tabR, const UInt16* const tabG, const UInt16* const tabB) = 0; // len table = 256.
	virtual hsBool						SetGamma(hsScalar e) { return SetGamma(e, e, e); }
	virtual hsBool						SetGamma(const UInt16* const table) { return SetGamma(table, table, table); } 

	// flipVertical is for the AVI writer, which wants it's frames upside down
	virtual hsBool						CaptureScreen( plMipmap *dest, bool flipVertical = false, UInt16 desiredWidth = 0, UInt16 desiredHeight = 0 ) = 0;

	// Returns an un-named (GetKey()==nil) mipmap same dimensions as targ. You are responsible for deleting said mipMap.
	virtual plMipmap*					ExtractMipMap(plRenderTarget* targ) = 0;

	/// Error handling
	virtual const char					*GetErrorString( void ) = 0;

	// info about current rendering device
	virtual void GetSupportedDisplayModes(std::vector<plDisplayMode> *res, int ColorDepth = 32 ) = 0;
	virtual int GetMaxAnisotropicSamples() = 0;
	virtual int GetMaxAntiAlias(int Width, int Height, int ColorDepth) = 0;
	int GetDesktopWidth() { return fDesktopParams.Width; }
	int GetDesktopHeight() { return fDesktopParams.Height; }
	int GetDesktopColorDepth() { return fDesktopParams.ColorDepth; }
	PipelineParams *GetDefaultParams() { return &fDefaultPipeParams; }

	virtual void ResetDisplayDevice(int Width, int Height, int ColorDepth, hsBool Windowed, int NumAASamples, int MaxAnisotropicSamples, hsBool vSync = false  ) = 0;
	static PipelineParams fDefaultPipeParams;
	static PipelineParams fInitialPipeParams;
	plDisplayMode fDesktopParams;
};

#endif // plPipeline_inc