You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

363 lines
16 KiB

/*==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