TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-04-29 08:15:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

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/gfx/D3D11/gfxD3D11CardProfiler.h
View file

@ -33,14 +33,14 @@ private:
public:
GFXD3D11CardProfiler();
~GFXD3D11CardProfiler();
void init();
void init() override;
protected:
const String &getRendererString() const { static String sRS("Direct3D11"); return sRS; }
const String &getRendererString() const override { static String sRS("Direct3D11"); return sRS; }
void setupCardCapabilities();
bool _queryCardCap(const String &query, U32 &foundResult);
bool _queryFormat(const GFXFormat fmt, const GFXTextureProfile *profile, bool &inOutAutogenMips);
void setupCardCapabilities() override;
bool _queryCardCap(const String &query, U32 &foundResult) override;
bool _queryFormat(const GFXFormat fmt, const GFXTextureProfile *profile, bool &inOutAutogenMips) override;
};
#endif

32
Engine/source/gfx/D3D11/gfxD3D11Cubemap.h
View file

@ -34,21 +34,21 @@ const U32 MaxMipMaps = 13; //todo this needs a proper static value somewhere to
class GFXD3D11Cubemap : public GFXCubemap
{
public:
virtual void initStatic( GFXTexHandle *faces );
virtual void initStatic( DDSFile *dds );
virtual void initDynamic( U32 texSize, GFXFormat faceFormat = GFXFormatR8G8B8A8, U32 mipLevels = 0);
virtual void setToTexUnit( U32 tuNum );
virtual U32 getSize() const { return mTexSize; }
virtual GFXFormat getFormat() const { return mFaceFormat; }
void initStatic( GFXTexHandle *faces ) override;
void initStatic( DDSFile *dds ) override;
void initDynamic( U32 texSize, GFXFormat faceFormat = GFXFormatR8G8B8A8, U32 mipLevels = 0) override;
void setToTexUnit( U32 tuNum ) override;
U32 getSize() const override { return mTexSize; }
GFXFormat getFormat() const override { return mFaceFormat; }
GFXD3D11Cubemap();
virtual ~GFXD3D11Cubemap();
// GFXResource interface
virtual void zombify();
virtual void resurrect();
void zombify() override;
void resurrect() override;
virtual bool isInitialized() { return mTexture ? true : false; }
bool isInitialized() override { return mTexture ? true : false; }
// Get functions
ID3D11ShaderResourceView* getSRView();
@ -83,18 +83,18 @@ class GFXD3D11CubemapArray : public GFXCubemapArray
public:
GFXD3D11CubemapArray();
virtual ~GFXD3D11CubemapArray();
virtual void init(GFXCubemapHandle *cubemaps, const U32 cubemapCount);
virtual void init(const U32 cubemapCount, const U32 cubemapFaceSize, const GFXFormat format);
virtual void updateTexture(const GFXCubemapHandle &cubemap, const U32 slot);
virtual void copyTo(GFXCubemapArray *pDstCubemap);
virtual void setToTexUnit(U32 tuNum);
void init(GFXCubemapHandle *cubemaps, const U32 cubemapCount) override;
void init(const U32 cubemapCount, const U32 cubemapFaceSize, const GFXFormat format) override;
void updateTexture(const GFXCubemapHandle &cubemap, const U32 slot) override;
void copyTo(GFXCubemapArray *pDstCubemap) override;
void setToTexUnit(U32 tuNum) override;
ID3D11ShaderResourceView* getSRView() { return mSRView; }
ID3D11Texture2D* get2DTex() { return mTexture; }
// GFXResource interface
virtual void zombify();
virtual void resurrect();
void zombify() override;
void resurrect() override;
private:
friend class GFXD3D11TextureTarget;

104
Engine/source/gfx/D3D11/gfxD3D11Device.h
View file

@ -63,17 +63,17 @@ private:
friend class OculusVRHMDDevice;
friend class D3D11OculusTexture;
virtual GFXFormat selectSupportedFormat(GFXTextureProfile *profile,
const Vector<GFXFormat> &formats, bool texture, bool mustblend, bool mustfilter);
GFXFormat selectSupportedFormat(GFXTextureProfile *profile,
const Vector<GFXFormat> &formats, bool texture, bool mustblend, bool mustfilter) override;
virtual void enumerateVideoModes();
void enumerateVideoModes() override;
virtual GFXWindowTarget *allocWindowTarget(PlatformWindow *window);
virtual GFXTextureTarget *allocRenderToTextureTarget(bool genMips = true);
GFXWindowTarget *allocWindowTarget(PlatformWindow *window) override;
GFXTextureTarget *allocRenderToTextureTarget(bool genMips = true) override;
virtual void enterDebugEvent(ColorI color, const char *name);
virtual void leaveDebugEvent();
virtual void setDebugMarker(ColorI color, const char *name);
void enterDebugEvent(ColorI color, const char *name) override;
void leaveDebugEvent() override;
void setDebugMarker(ColorI color, const char *name) override;
protected:
@ -89,7 +89,7 @@ protected:
ID3D11InputLayout *decl;
};
virtual void initStates() { };
void initStates() override { };
static GFXAdapter::CreateDeviceInstanceDelegate mCreateDeviceInstance;
@ -167,33 +167,33 @@ protected:
// {
///
virtual void setTextureInternal(U32 textureUnit, const GFXTextureObject* texture);
void setTextureInternal(U32 textureUnit, const GFXTextureObject* texture) override;
/// Called by GFXDevice to create a device specific stateblock
virtual GFXStateBlockRef createStateBlockInternal(const GFXStateBlockDesc& desc);
GFXStateBlockRef createStateBlockInternal(const GFXStateBlockDesc& desc) override;
/// Called by GFXDevice to actually set a stateblock.
virtual void setStateBlockInternal(GFXStateBlock* block, bool force);
void setStateBlockInternal(GFXStateBlock* block, bool force) override;
/// Track the last const buffer we've used. Used to notify new constant buffers that
/// they should send all of their constants up
StrongRefPtr<GFXD3D11ShaderConstBuffer> mCurrentConstBuffer;
/// Called by base GFXDevice to actually set a const buffer
virtual void setShaderConstBufferInternal(GFXShaderConstBuffer* buffer);
void setShaderConstBufferInternal(GFXShaderConstBuffer* buffer) override;
// }
// Index buffer management
// {
virtual void _setPrimitiveBuffer( GFXPrimitiveBuffer *buffer );
virtual void drawIndexedPrimitive( GFXPrimitiveType primType,
void drawIndexedPrimitive( GFXPrimitiveType primType,
U32 startVertex,
U32 minIndex,
U32 numVerts,
U32 startIndex,
U32 primitiveCount );
U32 primitiveCount ) override;
// }
virtual GFXShader* createShader();
GFXShader* createShader() override;
/// Device helper function
virtual DXGI_SWAP_CHAIN_DESC setupPresentParams( const GFXVideoMode &mode, const HWND &hwnd );
@ -220,41 +220,41 @@ public:
// Activate/deactivate
// {
virtual void init( const GFXVideoMode &mode, PlatformWindow *window = NULL );
void init( const GFXVideoMode &mode, PlatformWindow *window = NULL ) override;
virtual void preDestroy() { GFXDevice::preDestroy(); if(mTextureManager) mTextureManager->kill(); }
void preDestroy() override { GFXDevice::preDestroy(); if(mTextureManager) mTextureManager->kill(); }
GFXAdapterType getAdapterType(){ return Direct3D11; }
GFXAdapterType getAdapterType() override{ return Direct3D11; }
U32 getAdaterIndex() const { return mAdapterIndex; }
virtual GFXCubemap *createCubemap();
virtual GFXCubemapArray *createCubemapArray();
virtual GFXTextureArray* createTextureArray();
GFXCubemap *createCubemap() override;
GFXCubemapArray *createCubemapArray() override;
GFXTextureArray* createTextureArray() override;
virtual F32 getPixelShaderVersion() const { return mPixVersion; }
virtual void setPixelShaderVersion( F32 version ){ mPixVersion = version;}
F32 getPixelShaderVersion() const override { return mPixVersion; }
void setPixelShaderVersion( F32 version ) override{ mPixVersion = version;}
virtual void setShader(GFXShader *shader, bool force = false);
virtual U32 getNumSamplers() const { return 16; }
virtual U32 getNumRenderTargets() const { return 8; }
void setShader(GFXShader *shader, bool force = false) override;
U32 getNumSamplers() const override { return 16; }
U32 getNumRenderTargets() const override { return 8; }
// }
// Copy methods
// {
virtual void copyResource(GFXTextureObject *pDst, GFXCubemap *pSrc, const U32 face);
void copyResource(GFXTextureObject *pDst, GFXCubemap *pSrc, const U32 face) override;
// }
// Misc rendering control
// {
virtual void clear( U32 flags, const LinearColorF& color, F32 z, U32 stencil );
virtual void clearColorAttachment(const U32 attachment, const LinearColorF& color);
void clear( U32 flags, const LinearColorF& color, F32 z, U32 stencil ) override;
void clearColorAttachment(const U32 attachment, const LinearColorF& color) override;
virtual bool beginSceneInternal();
virtual void endSceneInternal();
bool beginSceneInternal() override;
void endSceneInternal() override;
virtual void setClipRect( const RectI &rect );
virtual const RectI& getClipRect() const { return mClipRect; }
void setClipRect( const RectI &rect ) override;
const RectI& getClipRect() const override { return mClipRect; }
// }
@ -262,37 +262,37 @@ public:
/// @name Render Targets
/// @{
virtual void _updateRenderTargets();
void _updateRenderTargets() override;
/// @}
// Vertex/Index buffer management
// {
virtual GFXVertexBuffer* allocVertexBuffer( U32 numVerts,
GFXVertexBuffer* allocVertexBuffer( U32 numVerts,
const GFXVertexFormat *vertexFormat,
U32 vertSize,
GFXBufferType bufferType,
void* data = NULL);
void* data = NULL) override;
virtual GFXPrimitiveBuffer *allocPrimitiveBuffer( U32 numIndices,
GFXPrimitiveBuffer *allocPrimitiveBuffer( U32 numIndices,
U32 numPrimitives,
GFXBufferType bufferType,
void* data = NULL);
void* data = NULL) override;
virtual GFXVertexDecl* allocVertexDecl( const GFXVertexFormat *vertexFormat );
virtual void setVertexDecl( const GFXVertexDecl *decl );
GFXVertexDecl* allocVertexDecl( const GFXVertexFormat *vertexFormat ) override;
void setVertexDecl( const GFXVertexDecl *decl ) override;
virtual void setVertexStream( U32 stream, GFXVertexBuffer *buffer );
virtual void setVertexStreamFrequency( U32 stream, U32 frequency );
void setVertexStream( U32 stream, GFXVertexBuffer *buffer ) override;
void setVertexStreamFrequency( U32 stream, U32 frequency ) override;
// }
virtual U32 getMaxDynamicVerts() { return GFX_MAX_DYNAMIC_VERTS; }
virtual U32 getMaxDynamicIndices() { return GFX_MAX_DYNAMIC_INDICES; }
U32 getMaxDynamicVerts() override { return GFX_MAX_DYNAMIC_VERTS; }
U32 getMaxDynamicIndices() override { return GFX_MAX_DYNAMIC_INDICES; }
inline U32 primCountToIndexCount(GFXPrimitiveType primType, U32 primitiveCount);
// Rendering
// {
virtual void drawPrimitive( GFXPrimitiveType primType, U32 vertexStart, U32 primitiveCount );
void drawPrimitive( GFXPrimitiveType primType, U32 vertexStart, U32 primitiveCount ) override;
// }
ID3D11DeviceContext* getDeviceContext(){ return mD3DDeviceContext; }
@ -304,14 +304,14 @@ public:
void beginReset();
void endReset(GFXD3D11WindowTarget* windowTarget);
virtual void setupGenericShaders( GenericShaderType type = GSColor );
void setupGenericShaders( GenericShaderType type = GSColor ) override;
inline virtual F32 getFillConventionOffset() const { return 0.0f; }
virtual void doParanoidStateCheck() {};
inline F32 getFillConventionOffset() const override { return 0.0f; }
void doParanoidStateCheck() override {};
GFXFence *createFence();
GFXFence *createFence() override;
GFXOcclusionQuery* createOcclusionQuery();
GFXOcclusionQuery* createOcclusionQuery() override;
// Default multisample parameters
DXGI_SAMPLE_DESC getMultisampleType() const { return mMultisampleDesc; }
@ -327,7 +327,7 @@ public:
// grab the sampler map
const SamplerMap &getSamplersMap() const { return mSamplersMap; }
SamplerMap &getSamplersMap(){ return mSamplersMap; }
const char* interpretDebugResult(long result);
const char* interpretDebugResult(long result) override;
// grab device buffer.
ID3D11Buffer* getDeviceBuffer(const GFXShaderConstDesc desc);

12
Engine/source/gfx/D3D11/gfxD3D11OcclusionQuery.h
View file

@ -45,14 +45,14 @@ public:
GFXD3D11OcclusionQuery(GFXDevice *device);
virtual ~GFXD3D11OcclusionQuery();
virtual bool begin();
virtual void end();
virtual OcclusionQueryStatus getStatus(bool block, U32 *data = NULL);
bool begin() override;
void end() override;
OcclusionQueryStatus getStatus(bool block, U32 *data = NULL) override;
// GFXResource
virtual void zombify();
virtual void resurrect();
virtual const String describeSelf() const;
void zombify() override;
void resurrect() override;
const String describeSelf() const override;
};
#endif

10
Engine/source/gfx/D3D11/gfxD3D11PrimitiveBuffer.h
View file

@ -51,14 +51,14 @@ public:
virtual ~GFXD3D11PrimitiveBuffer();
virtual void lock(U32 indexStart, U32 indexEnd, void **indexPtr);
virtual void unlock();
void lock(U32 indexStart, U32 indexEnd, void **indexPtr) override;
void unlock() override;
virtual void prepare();
void prepare() override;
// GFXResource interface
virtual void zombify();
virtual void resurrect();
void zombify() override;
void resurrect() override;
};
inline GFXD3D11PrimitiveBuffer::GFXD3D11PrimitiveBuffer( GFXDevice *device,

12
Engine/source/gfx/D3D11/gfxD3D11QueryFence.h
View file

@ -36,14 +36,14 @@ public:
GFXD3D11QueryFence( GFXDevice *device ) : GFXFence( device ), mQuery( NULL ) {};
virtual ~GFXD3D11QueryFence();
virtual void issue();
virtual FenceStatus getStatus() const;
virtual void block();
void issue() override;
FenceStatus getStatus() const override;
void block() override;
// GFXResource interface
virtual void zombify();
virtual void resurrect();
virtual const String describeSelf() const;
void zombify() override;
void resurrect() override;
const String describeSelf() const override;
};
#endif

72
Engine/source/gfx/D3D11/gfxD3D11Shader.h
View file

@ -69,15 +69,15 @@ public:
virtual ~GFXD3D11ShaderConstHandle();
void addDesc(GFXShaderStage stage, const GFXShaderConstDesc& desc);
const GFXShaderConstDesc getDesc(GFXShaderStage stage);
const String& getName() const { return mDesc.name; }
GFXShaderConstType getType() const { return mDesc.constType; }
U32 getArraySize() const { return mDesc.arraySize; }
const String& getName() const override { return mDesc.name; }
GFXShaderConstType getType() const override { return mDesc.constType; }
U32 getArraySize() const override { return mDesc.arraySize; }
U32 getSize() const { return mDesc.size; }
void setValid(bool valid) { mValid = valid; }
/// @warning This will always return the value assigned when the shader was
/// initialized. If the value is later changed this method won't reflect that.
S32 getSamplerRegister() const { return (!isSampler() || !mValid) ? -1 : mDesc.samplerReg; }
S32 getSamplerRegister() const override { return (!isSampler() || !mValid) ? -1 : mDesc.samplerReg; }
// Returns true if this is a handle to a sampler register.
bool isSampler() const
@ -124,32 +124,32 @@ public:
void onShaderReload(GFXD3D11Shader *shader);
// GFXShaderConstBuffer
virtual GFXShader* getShader();
virtual void set(GFXShaderConstHandle* handle, const F32 fv);
virtual void set(GFXShaderConstHandle* handle, const Point2F& fv);
virtual void set(GFXShaderConstHandle* handle, const Point3F& fv);
virtual void set(GFXShaderConstHandle* handle, const Point4F& fv);
virtual void set(GFXShaderConstHandle* handle, const PlaneF& fv);
virtual void set(GFXShaderConstHandle* handle, const LinearColorF& fv);
virtual void set(GFXShaderConstHandle* handle, const S32 f);
virtual void set(GFXShaderConstHandle* handle, const Point2I& fv);
virtual void set(GFXShaderConstHandle* handle, const Point3I& fv);
virtual void set(GFXShaderConstHandle* handle, const Point4I& fv);
virtual void set(GFXShaderConstHandle* handle, const AlignedArray<F32>& fv);
virtual void set(GFXShaderConstHandle* handle, const AlignedArray<Point2F>& fv);
virtual void set(GFXShaderConstHandle* handle, const AlignedArray<Point3F>& fv);
virtual void set(GFXShaderConstHandle* handle, const AlignedArray<Point4F>& fv);
virtual void set(GFXShaderConstHandle* handle, const AlignedArray<S32>& fv);
virtual void set(GFXShaderConstHandle* handle, const AlignedArray<Point2I>& fv);
virtual void set(GFXShaderConstHandle* handle, const AlignedArray<Point3I>& fv);
virtual void set(GFXShaderConstHandle* handle, const AlignedArray<Point4I>& fv);
virtual void set(GFXShaderConstHandle* handle, const MatrixF& mat, const GFXShaderConstType matType = GFXSCT_Float4x4);
virtual void set(GFXShaderConstHandle* handle, const MatrixF* mat, const U32 arraySize, const GFXShaderConstType matrixType = GFXSCT_Float4x4);
GFXShader* getShader() override;
void set(GFXShaderConstHandle* handle, const F32 fv) override;
void set(GFXShaderConstHandle* handle, const Point2F& fv) override;
void set(GFXShaderConstHandle* handle, const Point3F& fv) override;
void set(GFXShaderConstHandle* handle, const Point4F& fv) override;
void set(GFXShaderConstHandle* handle, const PlaneF& fv) override;
void set(GFXShaderConstHandle* handle, const LinearColorF& fv) override;
void set(GFXShaderConstHandle* handle, const S32 f) override;
void set(GFXShaderConstHandle* handle, const Point2I& fv) override;
void set(GFXShaderConstHandle* handle, const Point3I& fv) override;
void set(GFXShaderConstHandle* handle, const Point4I& fv) override;
void set(GFXShaderConstHandle* handle, const AlignedArray<F32>& fv) override;
void set(GFXShaderConstHandle* handle, const AlignedArray<Point2F>& fv) override;
void set(GFXShaderConstHandle* handle, const AlignedArray<Point3F>& fv) override;
void set(GFXShaderConstHandle* handle, const AlignedArray<Point4F>& fv) override;
void set(GFXShaderConstHandle* handle, const AlignedArray<S32>& fv) override;
void set(GFXShaderConstHandle* handle, const AlignedArray<Point2I>& fv) override;
void set(GFXShaderConstHandle* handle, const AlignedArray<Point3I>& fv) override;
void set(GFXShaderConstHandle* handle, const AlignedArray<Point4I>& fv) override;
void set(GFXShaderConstHandle* handle, const MatrixF& mat, const GFXShaderConstType matType = GFXSCT_Float4x4) override;
void set(GFXShaderConstHandle* handle, const MatrixF* mat, const U32 arraySize, const GFXShaderConstType matrixType = GFXSCT_Float4x4) override;
// GFXResource
virtual const String describeSelf() const;
virtual void zombify() {}
virtual void resurrect() {}
const String describeSelf() const override;
void zombify() override {}
void resurrect() override {}
protected:
friend class GFXD3D11Shader;
@ -182,19 +182,19 @@ public:
virtual ~GFXD3D11Shader();
// GFXShader
virtual GFXShaderConstBufferRef allocConstBuffer();
virtual const Vector<GFXShaderConstDesc>& getShaderConstDesc() const;
virtual GFXShaderConstHandle* getShaderConstHandle(const String& name);
virtual GFXShaderConstHandle* findShaderConstHandle(const String& name);
virtual U32 getAlignmentValue(const GFXShaderConstType constType) const;
GFXShaderConstBufferRef allocConstBuffer() override;
const Vector<GFXShaderConstDesc>& getShaderConstDesc() const override;
GFXShaderConstHandle* getShaderConstHandle(const String& name) override;
GFXShaderConstHandle* findShaderConstHandle(const String& name) override;
U32 getAlignmentValue(const GFXShaderConstType constType) const override;
// GFXResource
virtual void zombify();
virtual void resurrect();
void zombify() override;
void resurrect() override;
protected:
virtual bool _init();
bool _init() override;
ID3D11VertexShader *mVertShader;
ID3D11PixelShader *mPixShader;

8
Engine/source/gfx/D3D11/gfxD3D11StateBlock.h
View file

@ -47,17 +47,17 @@ public:
//
/// Returns the hash value of the desc that created this block
virtual U32 getHashValue() const;
U32 getHashValue() const override;
/// Returns a GFXStateBlockDesc that this block represents
virtual const GFXStateBlockDesc& getDesc() const;
const GFXStateBlockDesc& getDesc() const override;
//
// GFXResource
//
virtual void zombify() { }
void zombify() override { }
/// When called the resource should restore all device sensitive information destroyed by zombify()
virtual void resurrect() { }
void resurrect() override { }
private:
D3D11_BLEND_DESC mBlendDesc;

36
Engine/source/gfx/D3D11/gfxD3D11Target.h
View file

@ -55,20 +55,20 @@ public:
~GFXD3D11TextureTarget();
// Public interface.
virtual const Point2I getSize() { return mTargetSize; }
virtual GFXFormat getFormat() { return mTargetFormat; }
virtual void attachTexture(RenderSlot slot, GFXTextureObject *tex, U32 mipLevel=0, U32 zOffset = 0);
virtual void attachTexture(RenderSlot slot, GFXCubemap *tex, U32 face, U32 mipLevel=0);
virtual void resolve();
const Point2I getSize() override { return mTargetSize; }
GFXFormat getFormat() override { return mTargetFormat; }
void attachTexture(RenderSlot slot, GFXTextureObject *tex, U32 mipLevel=0, U32 zOffset = 0) override;
void attachTexture(RenderSlot slot, GFXCubemap *tex, U32 face, U32 mipLevel=0) override;
void resolve() override;
/// Note we always copy the Color0 RenderSlot.
virtual void resolveTo( GFXTextureObject *tex );
void resolveTo( GFXTextureObject *tex ) override;
virtual void activate();
virtual void deactivate();
void activate() override;
void deactivate() override;
void zombify();
void resurrect();
void zombify() override;
void resurrect() override;
};
class GFXD3D11WindowTarget : public GFXWindowTarget
@ -87,7 +87,7 @@ class GFXD3D11WindowTarget : public GFXWindowTarget
/// D3D presentation info.
DXGI_SWAP_CHAIN_DESC mPresentationParams;
/// Internal interface that notifies us we need to reset our video mode.
void resetMode();
void resetMode() override;
/// Is this a secondary window
bool mSecondaryWindow;
@ -97,21 +97,21 @@ public:
GFXD3D11WindowTarget();
~GFXD3D11WindowTarget();
virtual const Point2I getSize();
virtual GFXFormat getFormat();
virtual bool present();
const Point2I getSize() override;
GFXFormat getFormat() override;
bool present() override;
void initPresentationParams();
void createSwapChain();
void createBuffersAndViews();
void setBackBuffer();
virtual void activate();
void activate() override;
void zombify();
void resurrect();
void zombify() override;
void resurrect() override;
virtual void resolveTo( GFXTextureObject *tex );
void resolveTo( GFXTextureObject *tex ) override;
// These are all reference counted and must be released by whomever uses the get* function
IDXGISwapChain* getSwapChain();

2
Engine/source/gfx/D3D11/gfxD3D11TextureArray.h
View file

@ -22,7 +22,7 @@ public:
~GFXD3D11TextureArray() { Release(); };
void init();
void init() override;
void setToTexUnit(U32 tuNum) override;
void createResourceView(DXGI_FORMAT format, U32 numMipLevels, U32 usageFlags);

12
Engine/source/gfx/D3D11/gfxD3D11TextureManager.h
View file

@ -45,13 +45,13 @@ protected:
U32 numMipLevels,
bool forceMips = false,
S32 antialiasLevel = 0,
GFXTextureObject *inTex = NULL );
GFXTextureObject *inTex = NULL ) override;
bool _loadTexture(GFXTextureObject *texture, DDSFile *dds);
bool _loadTexture(GFXTextureObject *texture, GBitmap *bmp);
bool _loadTexture(GFXTextureObject *texture, void *raw);
bool _refreshTexture(GFXTextureObject *texture);
bool _freeTexture(GFXTextureObject *texture, bool zombify = false);
bool _loadTexture(GFXTextureObject *texture, DDSFile *dds) override;
bool _loadTexture(GFXTextureObject *texture, GBitmap *bmp) override;
bool _loadTexture(GFXTextureObject *texture, void *raw) override;
bool _refreshTexture(GFXTextureObject *texture) override;
bool _freeTexture(GFXTextureObject *texture, bool zombify = false) override;
private:
U32 mCurTexSet[GFX_TEXTURE_STAGE_COUNT];

12
Engine/source/gfx/D3D11/gfxD3D11TextureObject.h
View file

@ -70,19 +70,19 @@ public:
bool isManaged; //setting to true tells this texture not to be released from being zombify
virtual GFXLockedRect * lock(U32 mipLevel = 0, RectI *inRect = NULL);
virtual void unlock(U32 mipLevel = 0 );
GFXLockedRect * lock(U32 mipLevel = 0, RectI *inRect = NULL) override;
void unlock(U32 mipLevel = 0 ) override;
virtual bool copyToBmp(GBitmap* bmp);
bool copyToBmp(GBitmap* bmp) override;
ID3D11Texture2D* getSurface() {return mD3DSurface;}
ID3D11Texture2D** getSurfacePtr() {return &mD3DSurface;}
// GFXResource
void zombify();
void resurrect();
void zombify() override;
void resurrect() override;
#ifdef TORQUE_DEBUG
virtual void pureVirtualCrash() {};
void pureVirtualCrash() override {};
#endif
};

10
Engine/source/gfx/D3D11/gfxD3D11VertexBuffer.h
View file

@ -49,13 +49,13 @@ public:
GFXBufferType bufferType );
virtual ~GFXD3D11VertexBuffer();
void lock(U32 vertexStart, U32 vertexEnd, void **vertexPtr);
void unlock();
void prepare() {}
void lock(U32 vertexStart, U32 vertexEnd, void **vertexPtr) override;
void unlock() override;
void prepare() override {}
// GFXResource interface
virtual void zombify();
virtual void resurrect();
void zombify() override;
void resurrect() override;
};
//-----------------------------------------------------------------------------

2
Engine/source/gfx/D3D11/screenshotD3D11.h
View file

@ -31,7 +31,7 @@ class ScreenShotD3D11 : public ScreenShot
{
protected:
GBitmap* _captureBackBuffer();
GBitmap* _captureBackBuffer() override;
};