mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-20 04:34:48 +00:00
326 lines
11 KiB
C++
326 lines
11 KiB
C++
//-----------------------------------------------------------------------------
|
|
// Copyright (c) 2012 GarageGames, LLC
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to
|
|
// deal in the Software without restriction, including without limitation the
|
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
// sell copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
// IN THE SOFTWARE.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifndef _MATERIALS_PROCESSEDMATERIAL_H_
|
|
#define _MATERIALS_PROCESSEDMATERIAL_H_
|
|
|
|
#ifndef _MATERIALDEFINITION_H_
|
|
#include "materials/materialDefinition.h"
|
|
#endif
|
|
#ifndef _MATERIALFEATUREDATA_H_
|
|
#include "materials/materialFeatureData.h"
|
|
#endif
|
|
#ifndef _GFXSTATEBLOCK_H_
|
|
#include "gfx/gfxStateBlock.h"
|
|
#endif
|
|
#ifndef _MATTEXTURETARGET_H_
|
|
#include "materials/matTextureTarget.h"
|
|
#endif
|
|
#ifndef _MATSTATEHINT_H_
|
|
#include "materials/matStateHint.h"
|
|
#endif
|
|
|
|
#ifndef CUSTOMSHADERBINDINGDATA_H
|
|
#include "materials/customShaderBindingData.h"
|
|
#endif
|
|
|
|
class ShaderFeature;
|
|
class MaterialParameters;
|
|
class MaterialParameterHandle;
|
|
class SceneRenderState;
|
|
class GFXVertexBufferHandleBase;
|
|
class GFXPrimitiveBufferHandle;
|
|
class MatrixSet;
|
|
class GuiTreeViewCtrl;
|
|
|
|
/// This contains the common data needed to render a pass.
|
|
struct RenderPassData
|
|
{
|
|
public:
|
|
|
|
struct TexSlotT
|
|
{
|
|
/// This is the default type of texture which
|
|
/// is valid with most texture types.
|
|
/// @see mTexType
|
|
GFXTexHandle texObject;
|
|
|
|
/// Only valid when the texture type is set
|
|
/// to Material::TexTarget.
|
|
/// @see mTexType
|
|
NamedTexTargetRef texTarget;
|
|
|
|
} mTexSlot[Material::MAX_TEX_PER_PASS];
|
|
|
|
U32 mTexType[Material::MAX_TEX_PER_PASS];
|
|
String mSamplerNames[Material::MAX_TEX_PER_PASS];
|
|
|
|
/// The cubemap to use when the texture type is
|
|
/// set to Material::Cube.
|
|
/// @see mTexType
|
|
GFXCubemapHandle mCubeMap;
|
|
|
|
U32 mNumTex;
|
|
|
|
U32 mNumTexReg;
|
|
|
|
MaterialFeatureData mFeatureData;
|
|
|
|
bool mGlow;
|
|
|
|
Material::BlendOp mBlendOp;
|
|
|
|
U32 mStageNum;
|
|
|
|
/// State permutations, used to index into
|
|
/// the render states array.
|
|
/// @see mRenderStates
|
|
enum
|
|
{
|
|
STATE_REFLECT = 1,
|
|
STATE_TRANSLUCENT = 2,
|
|
STATE_WIREFRAME = 4,
|
|
STATE_MAX = 8
|
|
};
|
|
|
|
///
|
|
GFXStateBlockRef mRenderStates[STATE_MAX];
|
|
|
|
RenderPassData();
|
|
|
|
virtual ~RenderPassData() { reset(); }
|
|
|
|
virtual void reset();
|
|
|
|
/// Creates and returns a unique description string.
|
|
virtual String describeSelf() const;
|
|
};
|
|
|
|
/// This is an abstract base class which provides the external
|
|
/// interface all subclasses must implement. This interface
|
|
/// primarily consists of setting state. Pass creation
|
|
/// is implementation specific, and internal, thus it is
|
|
/// not in this base class.
|
|
class ProcessedMaterial
|
|
{
|
|
public:
|
|
ProcessedMaterial();
|
|
virtual ~ProcessedMaterial();
|
|
|
|
/// @name State setting functions
|
|
///
|
|
/// @{
|
|
|
|
///
|
|
virtual void addStateBlockDesc(const GFXStateBlockDesc& sb);
|
|
|
|
///
|
|
virtual void updateStateBlocks() { _initRenderPassDataStateBlocks(); }
|
|
|
|
/// Set the user defined shader macros.
|
|
virtual void setShaderMacros( const Vector<GFXShaderMacro> ¯os ) { mUserMacros = macros; }
|
|
|
|
/// Sets the textures needed for rendering the current pass
|
|
virtual void setTextureStages(SceneRenderState *, const SceneData &sgData, U32 pass ) = 0;
|
|
|
|
/// Sets the transformation matrix, i.e. Model * View * Projection
|
|
virtual void setTransforms(const MatrixSet &matrixSet, SceneRenderState *state, const U32 pass) = 0;
|
|
|
|
/// Sets the node transforms for HW Skinning
|
|
virtual void setNodeTransforms(const MatrixF *address, const U32 numTransforms, const U32 pass) = 0;
|
|
|
|
/// Sets any custom shader data
|
|
virtual void setCustomShaderData(Vector<CustomShaderBindingData> &shaderData, const U32 pass) = 0;
|
|
|
|
/// Sets the scene info like lights for the given pass.
|
|
virtual void setSceneInfo(SceneRenderState *, const SceneData& sgData, U32 pass) = 0;
|
|
|
|
/// Sets the given vertex and primitive buffers so we can render geometry
|
|
virtual void setBuffers(GFXVertexBufferHandleBase* vertBuffer, GFXPrimitiveBufferHandle* primBuffer);
|
|
|
|
/// @see BaseMatInstance::setUserObject
|
|
virtual void setUserObject( SimObject *userObject ) { mUserObject = userObject; }
|
|
|
|
///
|
|
virtual bool stepInstance();
|
|
|
|
/// @}
|
|
|
|
/// Initializes us (eg. loads textures, creates passes, generates shaders)
|
|
virtual bool init( const FeatureSet& features,
|
|
const GFXVertexFormat *vertexFormat,
|
|
const MatFeaturesDelegate &featuresDelegate ) = 0;
|
|
|
|
/// Returns the state hint which can be used for
|
|
/// sorting and fast comparisions of the equality
|
|
/// of a material instance.
|
|
virtual const MatStateHint& getStateHint() const { return mStateHint; }
|
|
|
|
/// Sets up the given pass. Returns true if the pass was set up, false if there was an error or if
|
|
/// the specified pass is out of bounds.
|
|
virtual bool setupPass(SceneRenderState *, const SceneData& sgData, U32 pass) = 0;
|
|
|
|
// Material parameter methods
|
|
virtual MaterialParameters* allocMaterialParameters() = 0;
|
|
virtual MaterialParameters* getDefaultMaterialParameters() = 0;
|
|
virtual void setMaterialParameters(MaterialParameters* param, S32 pass) { mCurrentParams = param; };
|
|
virtual MaterialParameters* getMaterialParameters() { return mCurrentParams; }
|
|
virtual MaterialParameterHandle* getMaterialParameterHandle(const String& name) = 0;
|
|
|
|
/// Returns the pass data for the given pass.
|
|
RenderPassData* getPass(U32 pass)
|
|
{
|
|
if(pass >= mPasses.size())
|
|
return NULL;
|
|
return mPasses[pass];
|
|
}
|
|
|
|
/// Returns the pass data for the given pass.
|
|
const RenderPassData* getPass( U32 pass ) const { return mPasses[pass]; }
|
|
|
|
/// Returns the number of stages we're rendering (not to be confused with the number of passes).
|
|
virtual U32 getNumStages() = 0;
|
|
|
|
/// Returns the number of passes we are rendering (not to be confused with the number of stages).
|
|
U32 getNumPasses() const { return mPasses.size(); }
|
|
|
|
/// Returns true if any pass glows
|
|
bool hasGlow() const { return mHasGlow; }
|
|
|
|
/// Returns true if any pass accumulates
|
|
bool hasAccumulation() const { return mHasAccumulation; }
|
|
|
|
/// Gets the stage number for a pass
|
|
U32 getStageFromPass(U32 pass) const
|
|
{
|
|
if(pass >= mPasses.size())
|
|
return 0;
|
|
return mPasses[pass]->mStageNum;
|
|
}
|
|
|
|
/// Returns the active features in use by this material.
|
|
/// @see BaseMatInstance::getFeatures
|
|
const FeatureSet& getFeatures() const { return mFeatures; }
|
|
|
|
/// Dump shader info, or FF texture info?
|
|
virtual void dumpMaterialInfo() { }
|
|
|
|
virtual void getMaterialInfo(GuiTreeViewCtrl* tree, U32 item) {}
|
|
|
|
/// Returns the source material.
|
|
Material* getMaterial() const { return mMaterial; }
|
|
|
|
/// Returns the texture used by a stage
|
|
GFXTexHandle getStageTexture(U32 stage, const FeatureType &type)
|
|
{
|
|
return (stage < Material::MAX_STAGES) ? mStages[stage].getTex(type) : NULL;
|
|
}
|
|
|
|
protected:
|
|
|
|
/// Our passes.
|
|
Vector<RenderPassData*> mPasses;
|
|
|
|
/// The active features in use by this material.
|
|
FeatureSet mFeatures;
|
|
|
|
/// The material which we are processing.
|
|
Material* mMaterial;
|
|
|
|
MaterialParameters* mCurrentParams;
|
|
|
|
/// Material::StageData is used here because the shader
|
|
/// generator throws a fit if it's passed anything else.
|
|
Material::StageData mStages[Material::MAX_STAGES];
|
|
|
|
/// If we've already loaded the stage data
|
|
bool mHasSetStageData;
|
|
|
|
/// If we glow
|
|
bool mHasGlow;
|
|
|
|
/// If we have accumulation.
|
|
bool mHasAccumulation;
|
|
|
|
/// Number of stages (not to be confused with number of passes)
|
|
U32 mMaxStages;
|
|
|
|
/// The vertex format on which this material will render.
|
|
const GFXVertexFormat *mVertexFormat;
|
|
|
|
/// Set by addStateBlockDesc, should be considered
|
|
/// when initPassStateBlock is called.
|
|
GFXStateBlockDesc mUserDefined;
|
|
|
|
/// The user defined macros to pass to the
|
|
/// shader initialization.
|
|
Vector<GFXShaderMacro> mUserMacros;
|
|
|
|
/// The user defined object to pass to ShaderFeature::createConstHandles.
|
|
SimObject *mUserObject;
|
|
|
|
/// The state hint used for material sorting
|
|
/// and quick equality comparision.
|
|
MatStateHint mStateHint;
|
|
|
|
/// Loads all the textures for all of the stages in the Material
|
|
virtual void _setStageData();
|
|
|
|
/// Sets the blend state for rendering
|
|
void _setBlendState(Material::BlendOp blendOp, GFXStateBlockDesc& desc );
|
|
|
|
/// Returns the path the material will attempt to load for a given texture filename.
|
|
String _getTexturePath(const String& filename);
|
|
|
|
/// Loads the texture located at _getTexturePath(filename) and gives it the specified profile
|
|
GFXTexHandle _createTexture( const char *filename, GFXTextureProfile *profile );
|
|
GFXTexHandle _createCompositeTexture(const char *filenameR, const char *filenameG, const char *filenameB, const char *filenameA, U32 inputKey[4], GFXTextureProfile *profile);
|
|
|
|
/// @name State blocks
|
|
///
|
|
/// @{
|
|
|
|
/// Creates the default state block templates, used by initStateBlocks.
|
|
virtual void _initStateBlockTemplates(GFXStateBlockDesc& stateTranslucent, GFXStateBlockDesc& stateReflect);
|
|
|
|
/// Does the base render state block setting, normally per pass.
|
|
virtual void _initPassStateBlock( RenderPassData *rpd, GFXStateBlockDesc& result);
|
|
|
|
/// Creates the default state blocks for a list of render states.
|
|
virtual void _initRenderStateStateBlocks( RenderPassData *rpd );
|
|
|
|
/// Creates the default state blocks for each RenderPassData item.
|
|
virtual void _initRenderPassDataStateBlocks();
|
|
|
|
/// This returns the index into the renderState array based on the sgData passed in.
|
|
virtual U32 _getRenderStateIndex( const SceneRenderState *state,
|
|
const SceneData &sgData );
|
|
|
|
/// Activates the correct mPasses[currPass].renderState based on scene graph info
|
|
virtual void _setRenderState( const SceneRenderState *state,
|
|
const SceneData &sgData,
|
|
U32 pass );
|
|
/// @
|
|
};
|
|
|
|
#endif // _MATERIALS_PROCESSEDMATERIAL_H_
|