TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-07-11 06:34:36 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

rest of virtuals removed

Browse source 
virtuals removed and replaced with override where necessary on the rest of the code base, clang-tidy to the rescue.
This commit is contained in:
marauder2k7 2024-03-18 18:40:22 +00:00
parent efbe5e90f5
commit 2b295fb7f0
454 changed files with 4162 additions and 4156 deletions
Download patch file Download diff file Expand all files Collapse all files

10
Engine/source/lighting/advanced/advancedLightBufferConditioner.h
View file

@ -48,7 +48,7 @@ public:
virtual ~AdvancedLightBufferConditioner();
virtual String getName()
String getName() override
{
return String("Light Buffer Conditioner ") + String( mColorFormat == RGB ? "[RGB]" : "[LUV]" );
}
@ -56,10 +56,10 @@ public:
protected:
ColorFormat mColorFormat;
virtual Var *_conditionOutput( Var *unconditionedOutput, MultiLine *meta );
virtual Var *_unconditionInput( Var *conditionedInput, MultiLine *meta );
virtual Var *printMethodHeader( MethodType methodType, const String &methodName, Stream &stream, MultiLine *meta );
virtual void printMethodFooter( MethodType methodType, Var *retVar, Stream &stream, MultiLine *meta );
Var *_conditionOutput( Var *unconditionedOutput, MultiLine *meta ) override;
Var *_unconditionInput( Var *conditionedInput, MultiLine *meta ) override;
Var *printMethodHeader( MethodType methodType, const String &methodName, Stream &stream, MultiLine *meta ) override;
void printMethodFooter( MethodType methodType, Var *retVar, Stream &stream, MultiLine *meta ) override;
};
#endif // _ADVANCED_LIGHTBUFFER_CONDITIONER_H_

66
Engine/source/lighting/advanced/glsl/advancedLightingFeaturesGLSL.h
View file

@ -48,25 +48,25 @@ protected:
public:
virtual void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
virtual void processPixMacros( Vector<GFXShaderMacro> &macros,
const MaterialFeatureData &fd );
void processPixMacros( Vector<GFXShaderMacro> &macros,
const MaterialFeatureData &fd ) override;
virtual Material::BlendOp getBlendOp(){ return Material::None; }
Material::BlendOp getBlendOp() override{ return Material::None; }
virtual Resources getResources( const MaterialFeatureData &fd );
Resources getResources( const MaterialFeatureData &fd ) override;
virtual void setTexData( Material::StageData &stageDat,
void setTexData( Material::StageData &stageDat,
const MaterialFeatureData &fd,
RenderPassData &passData,
U32 &texIndex );
U32 &texIndex ) override;
virtual String getName()
String getName() override
{
return "Deferred RT Lighting";
}
@ -79,22 +79,22 @@ class DeferredBumpFeatGLSL : public BumpFeatGLSL
typedef BumpFeatGLSL Parent;
public:
virtual void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
virtual Material::BlendOp getBlendOp() { return Material::LerpAlpha; }
Material::BlendOp getBlendOp() override { return Material::LerpAlpha; }
virtual Resources getResources( const MaterialFeatureData &fd );
Resources getResources( const MaterialFeatureData &fd ) override;
virtual void setTexData( Material::StageData &stageDat,
void setTexData( Material::StageData &stageDat,
const MaterialFeatureData &fd,
RenderPassData &passData,
U32 &texIndex );
U32 &texIndex ) override;
virtual String getName()
String getName() override
{
return "Bumpmap [Deferred]";
}
@ -106,22 +106,22 @@ class DeferredMinnaertGLSL : public ShaderFeatureGLSL
typedef ShaderFeatureGLSL Parent;
public:
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
virtual void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
virtual void processPixMacros( Vector<GFXShaderMacro> &macros,
const MaterialFeatureData &fd );
void processPixMacros( Vector<GFXShaderMacro> &macros,
const MaterialFeatureData &fd ) override;
virtual Resources getResources( const MaterialFeatureData &fd );
Resources getResources( const MaterialFeatureData &fd ) override;
virtual void setTexData( Material::StageData &stageDat,
void setTexData( Material::StageData &stageDat,
const MaterialFeatureData &fd,
RenderPassData &passData,
U32 &texIndex );
U32 &texIndex ) override;
virtual String getName()
String getName() override
{
return "Minnaert Shading [Deferred]";
}
@ -134,10 +134,10 @@ class DeferredSubSurfaceGLSL : public ShaderFeatureGLSL
typedef ShaderFeatureGLSL Parent;
public:
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
virtual String getName()
String getName() override
{
return "Sub-Surface Approximation [Deferred]";
}

48
Engine/source/lighting/advanced/glsl/deferredShadingFeaturesGLSL.h
View file

@ -30,63 +30,63 @@
class DeferredOrmMapGLSL : public ShaderFeatureGLSL
{
public:
virtual String getName() { return "Deferred Shading: PBR Config Map"; }
String getName() override { return "Deferred Shading: PBR Config Map"; }
virtual U32 getOutputTargets(const MaterialFeatureData& fd) const;
U32 getOutputTargets(const MaterialFeatureData& fd) const override;
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
virtual Resources getResources( const MaterialFeatureData &fd );
Resources getResources( const MaterialFeatureData &fd ) override;
// Sets textures and texture flags for current pass
virtual void setTexData( Material::StageData &stageDat,
void setTexData( Material::StageData &stageDat,
const MaterialFeatureData &fd,
RenderPassData &passData,
U32 &texIndex );
U32 &texIndex ) override;
virtual void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
};
class MatInfoFlagsGLSL : public ShaderFeatureGLSL
{
public:
virtual String getName() { return "Deferred Shading: Mat Info Flags"; }
String getName() override { return "Deferred Shading: Mat Info Flags"; }
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
virtual U32 getOutputTargets(const MaterialFeatureData& fd) const;
U32 getOutputTargets(const MaterialFeatureData& fd) const override;
};
class ORMConfigVarsGLSL : public ShaderFeatureGLSL
{
public:
virtual String getName() { return "Deferred Shading: PBR Config Explicit Numbers"; }
String getName() override { return "Deferred Shading: PBR Config Explicit Numbers"; }
virtual U32 getOutputTargets(const MaterialFeatureData& fd) const;
U32 getOutputTargets(const MaterialFeatureData& fd) const override;
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
};
class GlowMapGLSL : public ShaderFeatureGLSL
{
public:
virtual String getName() { return "Glow Map"; }
String getName() override { return "Glow Map"; }
virtual void processPix(Vector<ShaderComponent*>& componentList,
const MaterialFeatureData& fd);
void processPix(Vector<ShaderComponent*>& componentList,
const MaterialFeatureData& fd) override;
virtual U32 getOutputTargets(const MaterialFeatureData& fd) const;
U32 getOutputTargets(const MaterialFeatureData& fd) const override;
virtual Resources getResources(const MaterialFeatureData& fd);
Resources getResources(const MaterialFeatureData& fd) override;
// Sets textures and texture flags for current pass
virtual void setTexData(Material::StageData& stageDat,
void setTexData(Material::StageData& stageDat,
const MaterialFeatureData& fd,
RenderPassData& passData,
U32& texIndex);
U32& texIndex) override;
};
#endif

14
Engine/source/lighting/advanced/glsl/gBufferConditionerGLSL.h
View file

@ -63,19 +63,19 @@ public:
virtual ~GBufferConditionerGLSL();
virtual void processVert( Vector<ShaderComponent*> &componentList, const MaterialFeatureData &fd );
virtual void processPix( Vector<ShaderComponent*> &componentList, const MaterialFeatureData &fd );
virtual Resources getResources( const MaterialFeatureData &fd );
virtual String getName() { return "GBuffer Conditioner"; }
void processVert( Vector<ShaderComponent*> &componentList, const MaterialFeatureData &fd ) override;
void processPix( Vector<ShaderComponent*> &componentList, const MaterialFeatureData &fd ) override;
Resources getResources( const MaterialFeatureData &fd ) override;
String getName() override { return "GBuffer Conditioner"; }
protected:
virtual Var *printMethodHeader( MethodType methodType, const String &methodName, Stream &stream, MultiLine *meta );
Var *printMethodHeader( MethodType methodType, const String &methodName, Stream &stream, MultiLine *meta ) override;
virtual GenOp* _posnegEncode( GenOp *val );
virtual GenOp* _posnegDecode( GenOp *val );
virtual Var* _conditionOutput( Var *unconditionedOutput, MultiLine *meta );
virtual Var* _unconditionInput( Var *conditionedInput, MultiLine *meta );
Var* _conditionOutput( Var *unconditionedOutput, MultiLine *meta ) override;
Var* _unconditionInput( Var *conditionedInput, MultiLine *meta ) override;
};
#endif // _GBUFFER_CONDITIONER_GLSL_H_

66
Engine/source/lighting/advanced/hlsl/advancedLightingFeaturesHLSL.h
View file

@ -48,25 +48,25 @@ protected:
public:
virtual void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
virtual void processPixMacros( Vector<GFXShaderMacro> &macros,
const MaterialFeatureData &fd );
void processPixMacros( Vector<GFXShaderMacro> &macros,
const MaterialFeatureData &fd ) override;
virtual Material::BlendOp getBlendOp(){ return Material::None; }
Material::BlendOp getBlendOp() override{ return Material::None; }
virtual Resources getResources( const MaterialFeatureData &fd );
Resources getResources( const MaterialFeatureData &fd ) override;
virtual void setTexData( Material::StageData &stageDat,
void setTexData( Material::StageData &stageDat,
const MaterialFeatureData &fd,
RenderPassData &passData,
U32 &texIndex );
U32 &texIndex ) override;
virtual String getName()
String getName() override
{
return "Deferred RT Lighting";
}
@ -79,22 +79,22 @@ class DeferredBumpFeatHLSL : public BumpFeatHLSL
typedef BumpFeatHLSL Parent;
public:
virtual void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
virtual Material::BlendOp getBlendOp() { return Material::LerpAlpha; }
Material::BlendOp getBlendOp() override { return Material::LerpAlpha; }
virtual Resources getResources( const MaterialFeatureData &fd );
Resources getResources( const MaterialFeatureData &fd ) override;
virtual void setTexData( Material::StageData &stageDat,
void setTexData( Material::StageData &stageDat,
const MaterialFeatureData &fd,
RenderPassData &passData,
U32 &texIndex );
U32 &texIndex ) override;
virtual String getName()
String getName() override
{
return "Bumpmap [Deferred]";
}
@ -107,22 +107,22 @@ class DeferredMinnaertHLSL : public ShaderFeatureHLSL
typedef ShaderFeatureHLSL Parent;
public:
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
virtual void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
virtual void processPixMacros( Vector<GFXShaderMacro> &macros,
const MaterialFeatureData &fd );
void processPixMacros( Vector<GFXShaderMacro> &macros,
const MaterialFeatureData &fd ) override;
virtual Resources getResources( const MaterialFeatureData &fd );
Resources getResources( const MaterialFeatureData &fd ) override;
virtual void setTexData( Material::StageData &stageDat,
void setTexData( Material::StageData &stageDat,
const MaterialFeatureData &fd,
RenderPassData &passData,
U32 &texIndex );
U32 &texIndex ) override;
virtual String getName()
String getName() override
{
return "Minnaert Shading [Deferred]";
}
@ -135,10 +135,10 @@ class DeferredSubSurfaceHLSL : public ShaderFeatureHLSL
typedef ShaderFeatureHLSL Parent;
public:
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
virtual String getName()
String getName() override
{
return "Sub-Surface Approximation [Deferred]";
}

48
Engine/source/lighting/advanced/hlsl/deferredShadingFeaturesHLSL.h
View file

@ -29,64 +29,64 @@
class DeferredOrmMapHLSL : public ShaderFeatureHLSL
{
public:
virtual String getName() { return "Deferred Shading: PBR Config Map"; }
String getName() override { return "Deferred Shading: PBR Config Map"; }
virtual U32 getOutputTargets(const MaterialFeatureData& fd) const;
U32 getOutputTargets(const MaterialFeatureData& fd) const override;
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
virtual Resources getResources( const MaterialFeatureData &fd );
Resources getResources( const MaterialFeatureData &fd ) override;
// Sets textures and texture flags for current pass
virtual void setTexData( Material::StageData &stageDat,
void setTexData( Material::StageData &stageDat,
const MaterialFeatureData &fd,
RenderPassData &passData,
U32 &texIndex );
U32 &texIndex ) override;
virtual void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processVert( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
};
class MatInfoFlagsHLSL : public ShaderFeatureHLSL
{
public:
virtual String getName() { return "Deferred Shading: Mat Info Flags"; }
String getName() override { return "Deferred Shading: Mat Info Flags"; }
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
virtual U32 getOutputTargets(const MaterialFeatureData& fd) const;
U32 getOutputTargets(const MaterialFeatureData& fd) const override;
};
class ORMConfigVarsHLSL : public ShaderFeatureHLSL
{
public:
virtual String getName() { return "Deferred Shading: PBR Config Explicit Numbers"; }
String getName() override { return "Deferred Shading: PBR Config Explicit Numbers"; }
virtual U32 getOutputTargets(const MaterialFeatureData& fd) const;
U32 getOutputTargets(const MaterialFeatureData& fd) const override;
virtual void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd );
void processPix( Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd ) override;
};
class GlowMapHLSL : public ShaderFeatureHLSL
{
public:
virtual String getName() { return "Glow Map"; }
String getName() override { return "Glow Map"; }
virtual void processPix(Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd);
void processPix(Vector<ShaderComponent*> &componentList,
const MaterialFeatureData &fd) override;
virtual U32 getOutputTargets(const MaterialFeatureData& fd) const;
U32 getOutputTargets(const MaterialFeatureData& fd) const override;
virtual Resources getResources(const MaterialFeatureData& fd);
Resources getResources(const MaterialFeatureData& fd) override;
// Sets textures and texture flags for current pass
virtual void setTexData(Material::StageData& stageDat,
void setTexData(Material::StageData& stageDat,
const MaterialFeatureData& fd,
RenderPassData& passData,
U32& texIndex);
U32& texIndex) override;
};
#endif

14
Engine/source/lighting/advanced/hlsl/gBufferConditionerHLSL.h
View file

@ -63,19 +63,19 @@ public:
virtual ~GBufferConditionerHLSL();
virtual void processVert( Vector<ShaderComponent*> &componentList, const MaterialFeatureData &fd );
virtual void processPix( Vector<ShaderComponent*> &componentList, const MaterialFeatureData &fd );
virtual Resources getResources( const MaterialFeatureData &fd );
virtual String getName() { return "GBuffer Conditioner"; }
void processVert( Vector<ShaderComponent*> &componentList, const MaterialFeatureData &fd ) override;
void processPix( Vector<ShaderComponent*> &componentList, const MaterialFeatureData &fd ) override;
Resources getResources( const MaterialFeatureData &fd ) override;
String getName() override { return "GBuffer Conditioner"; }
protected:
virtual Var *printMethodHeader( MethodType methodType, const String &methodName, Stream &stream, MultiLine *meta );
Var *printMethodHeader( MethodType methodType, const String &methodName, Stream &stream, MultiLine *meta ) override;
virtual GenOp* _posnegEncode( GenOp *val );
virtual GenOp* _posnegDecode( GenOp *val );
virtual Var* _conditionOutput( Var *unconditionedOutput, MultiLine *meta );
virtual Var* _unconditionInput( Var *conditionedInput, MultiLine *meta );
Var* _conditionOutput( Var *unconditionedOutput, MultiLine *meta ) override;
Var* _unconditionInput( Var *conditionedInput, MultiLine *meta ) override;
};
#endif // _GBUFFER_CONDITIONER_HLSL_H_

14
Engine/source/lighting/basic/basicLightManager.h
View file

@ -56,19 +56,19 @@ class BasicLightManager : public LightManager
public:
// LightManager
virtual bool isCompatible() const;
virtual void activate( SceneManager *sceneManager );
virtual void deactivate();
virtual void setLightInfo(ProcessedMaterial* pmat, const Material* mat, const SceneData& sgData, const SceneRenderState *state, U32 pass, GFXShaderConstBuffer* shaderConsts);
virtual bool setTextureStage(const SceneData& sgData, const U32 currTexFlag, const U32 textureSlot, GFXShaderConstBuffer* shaderConsts, ShaderConstHandles* handles) { return false; }
bool isCompatible() const override;
void activate( SceneManager *sceneManager ) override;
void deactivate() override;
void setLightInfo(ProcessedMaterial* pmat, const Material* mat, const SceneData& sgData, const SceneRenderState *state, U32 pass, GFXShaderConstBuffer* shaderConsts) override;
bool setTextureStage(const SceneData& sgData, const U32 currTexFlag, const U32 textureSlot, GFXShaderConstBuffer* shaderConsts, ShaderConstHandles* handles) override { return false; }
static F32 getShadowFilterDistance() { return smProjectedShadowFilterDistance; }
protected:
// LightManager
virtual void _addLightInfoEx( LightInfo *lightInfo ) { }
virtual void _initLightFields() { }
void _addLightInfoEx( LightInfo *lightInfo ) override { }
void _initLightFields() override { }
void _onPreRender( SceneManager *sceneManger, const SceneRenderState *state );

6
Engine/source/lighting/basic/basicSceneObjectLightingPlugin.h
View file

@ -63,10 +63,10 @@ public:
virtual void renderShadow( SceneRenderState *state );
// Called by statics
virtual U32 packUpdate(SceneObject* obj, U32 checkMask, NetConnection *conn, U32 mask, BitStream *stream) { return 0; }
virtual void unpackUpdate(SceneObject* obj, NetConnection *conn, BitStream *stream) { }
U32 packUpdate(SceneObject* obj, U32 checkMask, NetConnection *conn, U32 mask, BitStream *stream) override { return 0; }
void unpackUpdate(SceneObject* obj, NetConnection *conn, BitStream *stream) override { }
virtual void reset();
void reset() override;
};
class BasicSceneObjectPluginFactory : public ManagedSingleton< BasicSceneObjectPluginFactory >

22
Engine/source/lighting/basic/blTerrainSystem.cpp
View file

@ -44,8 +44,8 @@ struct blTerrainChunk : public PersistInfo::PersistChunk
GBitmap *mLightmap;
bool read(Stream &);
bool write(Stream &);
bool read(Stream &) override;
bool write(Stream &) override;
};
//------------------------------------------------------------------------------
@ -134,18 +134,18 @@ public:
bool getShadowedSquares(const Vector<PlaneF> &, Vector<U16> &);
// lighting
void init();
bool preLight(LightInfo *);
void light(LightInfo *);
void init() override;
bool preLight(LightInfo *) override;
void light(LightInfo *) override;
// persist
U32 getResourceCRC();
bool setPersistInfo(PersistInfo::PersistChunk *);
bool getPersistInfo(PersistInfo::PersistChunk *);
U32 getResourceCRC() override;
bool setPersistInfo(PersistInfo::PersistChunk *) override;
bool getPersistInfo(PersistInfo::PersistChunk *) override;
virtual bool supportsShadowVolume();
virtual void getClipPlanes(Vector<PlaneF>& planes);
virtual void addToShadowVolume(ShadowVolumeBSP * shadowVolume, LightInfo * light, S32 level);
bool supportsShadowVolume() override;
void getClipPlanes(Vector<PlaneF>& planes) override;
void addToShadowVolume(ShadowVolumeBSP * shadowVolume, LightInfo * light, S32 level) override;
// events
//virtual void processTGELightProcessEvent(U32 curr, U32 max, LightInfo* currlight);

12
Engine/source/lighting/basic/blTerrainSystem.h
View file

@ -36,14 +36,14 @@
class blTerrainSystem : public SceneLightingInterface
{
public:
virtual void init();
virtual U32 addObjectType();
virtual SceneLighting::ObjectProxy* createObjectProxy(SceneObject* obj, SceneLighting::ObjectProxyList* sceneObjects);
virtual PersistInfo::PersistChunk* createPersistChunk(const U32 chunkType);
virtual bool createPersistChunkFromProxy(SceneLighting::ObjectProxy* objproxy, PersistInfo::PersistChunk **ret);
void init() override;
U32 addObjectType() override;
SceneLighting::ObjectProxy* createObjectProxy(SceneObject* obj, SceneLighting::ObjectProxyList* sceneObjects) override;
PersistInfo::PersistChunk* createPersistChunk(const U32 chunkType) override;
bool createPersistChunkFromProxy(SceneLighting::ObjectProxy* objproxy, PersistInfo::PersistChunk **ret) override;
// Given a ray, this will return the color from the lightmap of this object, return true if handled
virtual bool getColorFromRayInfo(const RayInfo & collision, LinearColorF& result) const;
bool getColorFromRayInfo(const RayInfo & collision, LinearColorF& result) const override;
};
#endif // !_BLTERRAINSYSTEM_H_

6
Engine/source/lighting/common/blobShadow.h
View file

@ -76,9 +76,9 @@ public:
bool shouldRender(F32 camDist);
void update( const SceneRenderState *state ) {}
void render( F32 camDist, const TSRenderState &rdata );
U32 getLastRenderTime() const { return mLastRenderTime; }
void update( const SceneRenderState *state ) override {}
void render( F32 camDist, const TSRenderState &rdata ) override;
U32 getLastRenderTime() const override { return mLastRenderTime; }
static void generateGenericShadowBitmap(S32 dim);
static void deleteGenericShadowBitmap();

8
Engine/source/lighting/common/lightMapParams.h
View file

@ -37,10 +37,10 @@ public:
static LightInfoExType Type;
// LightInfoEx
virtual void set( const LightInfoEx *ex );
virtual const LightInfoExType& getType() const { return Type; }
virtual void packUpdate( BitStream *stream ) const;
virtual void unpackUpdate( BitStream *stream );
void set( const LightInfoEx *ex ) override;
const LightInfoExType& getType() const override { return Type; }
void packUpdate( BitStream *stream ) const override;
void unpackUpdate( BitStream *stream ) override;
public:
// We're leaving these public for easy access

10
Engine/source/lighting/common/projectedShadow.h
View file

@ -115,12 +115,12 @@ public:
ProjectedShadow( SceneObject *object );
virtual ~ProjectedShadow();
bool shouldRender( const SceneRenderState *state );
bool shouldRender( const SceneRenderState *state ) override;
void update( const SceneRenderState *state );
void render( F32 camDist, const TSRenderState &rdata );
U32 getLastRenderTime() const { return mLastRenderTime; }
const F32 getScore() const { return mScore; }
void update( const SceneRenderState *state ) override;
void render( F32 camDist, const TSRenderState &rdata ) override;
U32 getLastRenderTime() const override { return mLastRenderTime; }
const F32 getScore() const override { return mScore; }
};

2
Engine/source/lighting/common/sceneLighting.h
View file

@ -201,7 +201,7 @@ public:
sgObjectIndex = objectIndex;
sgEvent = event;
}
void process(SimObject * object)
void process(SimObject * object) override
{
AssertFatal(object, "SceneLightingProcessEvent:: null event object!");
if(!object)

12
Engine/source/lighting/shadowMap/cubeLightShadowMap.h
View file

@ -40,12 +40,12 @@ public:
CubeLightShadowMap( LightInfo *light );
// LightShadowMap
virtual bool hasShadowTex() const { return mCubemap.isValid(); }
virtual ShadowType getShadowType() const { return ShadowType_CubeMap; }
virtual void _render( RenderPassManager* renderPass, const SceneRenderState *diffuseState );
virtual void setShaderParameters( GFXShaderConstBuffer* params, LightingShaderConstants* lsc );
virtual void releaseTextures();
virtual bool setTextureStage( U32 currTexFlag, LightingShaderConstants* lsc );
bool hasShadowTex() const override { return mCubemap.isValid(); }
ShadowType getShadowType() const override { return ShadowType_CubeMap; }
void _render( RenderPassManager* renderPass, const SceneRenderState *diffuseState ) override;
void setShaderParameters( GFXShaderConstBuffer* params, LightingShaderConstants* lsc ) override;
void releaseTextures() override;
bool setTextureStage( U32 currTexFlag, LightingShaderConstants* lsc ) override;
protected:

2
Engine/source/lighting/shadowMap/dualParaboloidLightShadowMap.h
View file

@ -34,7 +34,7 @@ class DualParaboloidLightShadowMap : public ParaboloidLightShadowMap
public:
DualParaboloidLightShadowMap( LightInfo *light );
virtual void _render( RenderPassManager* renderPass, const SceneRenderState *diffuseState );
void _render( RenderPassManager* renderPass, const SceneRenderState *diffuseState ) override;
};
#endif // _DUALPARABOLOIDLIGHTSHADOWMAP_H_

6
Engine/source/lighting/shadowMap/paraboloidLightShadowMap.h
View file

@ -36,9 +36,9 @@ public:
~ParaboloidLightShadowMap();
// LightShadowMap
virtual ShadowType getShadowType() const;
virtual void _render( RenderPassManager* renderPass, const SceneRenderState *diffuseState );
virtual void setShaderParameters(GFXShaderConstBuffer* params, LightingShaderConstants* lsc);
ShadowType getShadowType() const override;
void _render( RenderPassManager* renderPass, const SceneRenderState *diffuseState ) override;
void setShaderParameters(GFXShaderConstBuffer* params, LightingShaderConstants* lsc) override;
protected:
Point2F mShadowMapScale;

6
Engine/source/lighting/shadowMap/pssmLightShadowMap.h
View file

@ -37,9 +37,9 @@ public:
PSSMLightShadowMap( LightInfo *light );
// LightShadowMap
virtual ShadowType getShadowType() const { return ShadowType_PSSM; }
virtual void _render( RenderPassManager* renderPass, const SceneRenderState *diffuseState );
virtual void setShaderParameters(GFXShaderConstBuffer* params, LightingShaderConstants* lsc);
ShadowType getShadowType() const override { return ShadowType_PSSM; }
void _render( RenderPassManager* renderPass, const SceneRenderState *diffuseState ) override;
void setShaderParameters(GFXShaderConstBuffer* params, LightingShaderConstants* lsc) override;
/// Used to scale TSShapeInstance::smDetailAdjust to have
/// objects lod quicker when in the PSSM shadow.

4
Engine/source/lighting/shadowMap/shadowMapManager.h
View file

@ -70,8 +70,8 @@ public:
ShadowMapPass* getShadowMapPass() const { return mShadowMapPass; }
// Shadow manager
virtual void activate();
virtual void deactivate();
void activate() override;
void deactivate() override;
GFXTextureObject* getTapRotationTex();

2
Engine/source/lighting/shadowMap/shadowMapPass.h
View file

@ -122,7 +122,7 @@ public:
ShadowRenderPassManager() : Parent() {}
/// Add a RenderInstance to the list
virtual void addInst( RenderInst *inst );
void addInst( RenderInst *inst ) override;
};
#endif // _SHADOWMAPPASS_H_

4
Engine/source/lighting/shadowMap/shadowMatHook.h
View file

@ -45,7 +45,7 @@ public:
ShadowMatInstance( Material *mat );
virtual ~ShadowMatInstance() {}
virtual bool setupPass( SceneRenderState *state, const SceneData &sgData );
bool setupPass( SceneRenderState *state, const SceneData &sgData ) override;
};
class ShadowMaterialHook : public MatInstanceHook
@ -56,7 +56,7 @@ public:
// MatInstanceHook
virtual ~ShadowMaterialHook();
virtual const MatInstanceHookType& getType() const { return Type; }
const MatInstanceHookType& getType() const override { return Type; }
/// The material hook type.
static const MatInstanceHookType Type;

6
Engine/source/lighting/shadowMap/singleLightShadowMap.h
View file

@ -37,9 +37,9 @@ public:
~SingleLightShadowMap();
// LightShadowMap
virtual ShadowType getShadowType() const { return ShadowType_Spot; }
virtual void _render( RenderPassManager* renderPass, const SceneRenderState *diffuseState );
virtual void setShaderParameters(GFXShaderConstBuffer* params, LightingShaderConstants* lsc);
ShadowType getShadowType() const override { return ShadowType_Spot; }
void _render( RenderPassManager* renderPass, const SceneRenderState *diffuseState ) override;
void setShaderParameters(GFXShaderConstBuffer* params, LightingShaderConstants* lsc) override;
};