diff --git a/native/cocos/base/CCData.cpp b/native/cocos/base/CCData.cpp index 2ebeda91f6..57058bff75 100644 --- a/native/cocos/base/CCData.cpp +++ b/native/cocos/base/CCData.cpp @@ -35,14 +35,14 @@ Data::Data() : _bytes(nullptr), _size(0) { - CC_LOG_INFO("In the empty constructor of Data."); +// CC_LOG_INFO("In the empty constructor of Data."); } Data::Data(Data&& other) : _bytes(nullptr), _size(0) { - CC_LOG_INFO("In the move constructor of Data."); +// CC_LOG_INFO("In the move constructor of Data."); move(other); } @@ -50,26 +50,26 @@ Data::Data(const Data& other) : _bytes(nullptr), _size(0) { - CC_LOG_INFO("In the copy constructor of Data."); +// CC_LOG_INFO("In the copy constructor of Data."); copy(other._bytes, other._size); } Data::~Data() { - CC_LOG_INFO("deallocing Data: %p", this); +// CC_LOG_INFO("deallocing Data: %p", this); clear(); } Data& Data::operator= (const Data& other) { - CC_LOG_INFO("In the copy assignment of Data."); +// CC_LOG_INFO("In the copy assignment of Data."); copy(other._bytes, other._size); return *this; } Data& Data::operator= (Data&& other) { - CC_LOG_INFO("In the move assignment of Data."); +// CC_LOG_INFO("In the move assignment of Data."); move(other); return *this; } diff --git a/native/cocos/platform/CCImage.cpp b/native/cocos/platform/CCImage.cpp index a68c48eae9..3f18e6216c 100644 --- a/native/cocos/platform/CCImage.cpp +++ b/native/cocos/platform/CCImage.cpp @@ -181,47 +181,47 @@ namespace // v2 - typedef const std::map _pixel2_formathash; + typedef const std::map _pixel2_formathash; static const _pixel2_formathash::value_type v2_pixel_formathash_value[] = { - _pixel2_formathash::value_type(PVR2TexturePixelFormat::BGRA8888, gfx::GFXFormat::BGRA8), - _pixel2_formathash::value_type(PVR2TexturePixelFormat::RGBA8888, gfx::GFXFormat::RGBA8), - _pixel2_formathash::value_type(PVR2TexturePixelFormat::RGBA4444, gfx::GFXFormat::RGBA4), - _pixel2_formathash::value_type(PVR2TexturePixelFormat::RGBA5551, gfx::GFXFormat::RGB5A1), - _pixel2_formathash::value_type(PVR2TexturePixelFormat::RGB565, gfx::GFXFormat::R5G6B5), - _pixel2_formathash::value_type(PVR2TexturePixelFormat::RGB888, gfx::GFXFormat::RGB8), - _pixel2_formathash::value_type(PVR2TexturePixelFormat::A8, gfx::GFXFormat::A8), - _pixel2_formathash::value_type(PVR2TexturePixelFormat::I8, gfx::GFXFormat::L8), - _pixel2_formathash::value_type(PVR2TexturePixelFormat::AI88, gfx::GFXFormat::LA8), + _pixel2_formathash::value_type(PVR2TexturePixelFormat::BGRA8888, gfx::Format::BGRA8), + _pixel2_formathash::value_type(PVR2TexturePixelFormat::RGBA8888, gfx::Format::RGBA8), + _pixel2_formathash::value_type(PVR2TexturePixelFormat::RGBA4444, gfx::Format::RGBA4), + _pixel2_formathash::value_type(PVR2TexturePixelFormat::RGBA5551, gfx::Format::RGB5A1), + _pixel2_formathash::value_type(PVR2TexturePixelFormat::RGB565, gfx::Format::R5G6B5), + _pixel2_formathash::value_type(PVR2TexturePixelFormat::RGB888, gfx::Format::RGB8), + _pixel2_formathash::value_type(PVR2TexturePixelFormat::A8, gfx::Format::A8), + _pixel2_formathash::value_type(PVR2TexturePixelFormat::I8, gfx::Format::L8), + _pixel2_formathash::value_type(PVR2TexturePixelFormat::AI88, gfx::Format::LA8), - _pixel2_formathash::value_type(PVR2TexturePixelFormat::PVRTC2BPP_RGBA, gfx::GFXFormat::PVRTC_RGBA2), - _pixel2_formathash::value_type(PVR2TexturePixelFormat::PVRTC4BPP_RGBA, gfx::GFXFormat::PVRTC_RGBA4), + _pixel2_formathash::value_type(PVR2TexturePixelFormat::PVRTC2BPP_RGBA, gfx::Format::PVRTC_RGBA2), + _pixel2_formathash::value_type(PVR2TexturePixelFormat::PVRTC4BPP_RGBA, gfx::Format::PVRTC_RGBA4), }; static const int PVR2_MAX_TABLE_ELEMENTS = sizeof(v2_pixel_formathash_value) / sizeof(v2_pixel_formathash_value[0]); static const _pixel2_formathash v2_pixel_formathash(v2_pixel_formathash_value, v2_pixel_formathash_value + PVR2_MAX_TABLE_ELEMENTS); // v3 - typedef const std::map _pixel3_formathash; + typedef const std::map _pixel3_formathash; static _pixel3_formathash::value_type v3_pixel_formathash_value[] = { - _pixel3_formathash::value_type(PVR3TexturePixelFormat::BGRA8888, gfx::GFXFormat::BGRA8), - _pixel3_formathash::value_type(PVR3TexturePixelFormat::RGBA8888, gfx::GFXFormat::RGBA8), - _pixel3_formathash::value_type(PVR3TexturePixelFormat::RGBA4444, gfx::GFXFormat::RGBA4), - _pixel3_formathash::value_type(PVR3TexturePixelFormat::RGBA5551, gfx::GFXFormat::RGB5A1), - _pixel3_formathash::value_type(PVR3TexturePixelFormat::RGB565, gfx::GFXFormat::R5G6B5), - _pixel3_formathash::value_type(PVR3TexturePixelFormat::RGB888, gfx::GFXFormat::RGB8), - _pixel3_formathash::value_type(PVR3TexturePixelFormat::A8, gfx::GFXFormat::A8), - _pixel3_formathash::value_type(PVR3TexturePixelFormat::L8, gfx::GFXFormat::L8), - _pixel3_formathash::value_type(PVR3TexturePixelFormat::LA88, gfx::GFXFormat::LA8), + _pixel3_formathash::value_type(PVR3TexturePixelFormat::BGRA8888, gfx::Format::BGRA8), + _pixel3_formathash::value_type(PVR3TexturePixelFormat::RGBA8888, gfx::Format::RGBA8), + _pixel3_formathash::value_type(PVR3TexturePixelFormat::RGBA4444, gfx::Format::RGBA4), + _pixel3_formathash::value_type(PVR3TexturePixelFormat::RGBA5551, gfx::Format::RGB5A1), + _pixel3_formathash::value_type(PVR3TexturePixelFormat::RGB565, gfx::Format::R5G6B5), + _pixel3_formathash::value_type(PVR3TexturePixelFormat::RGB888, gfx::Format::RGB8), + _pixel3_formathash::value_type(PVR3TexturePixelFormat::A8, gfx::Format::A8), + _pixel3_formathash::value_type(PVR3TexturePixelFormat::L8, gfx::Format::L8), + _pixel3_formathash::value_type(PVR3TexturePixelFormat::LA88, gfx::Format::LA8), - _pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC2BPP_RGB, gfx::GFXFormat::PVRTC_RGB2), - _pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC2BPP_RGBA, gfx::GFXFormat::PVRTC_RGBA2), - _pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC4BPP_RGB, gfx::GFXFormat::PVRTC_RGB4), - _pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC4BPP_RGBA, gfx::GFXFormat::PVRTC_RGBA4), + _pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC2BPP_RGB, gfx::Format::PVRTC_RGB2), + _pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC2BPP_RGBA, gfx::Format::PVRTC_RGBA2), + _pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC4BPP_RGB, gfx::Format::PVRTC_RGB4), + _pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC4BPP_RGBA, gfx::Format::PVRTC_RGBA4), - _pixel3_formathash::value_type(PVR3TexturePixelFormat::ETC1, gfx::GFXFormat::ETC_RGB8), + _pixel3_formathash::value_type(PVR3TexturePixelFormat::ETC1, gfx::Format::ETC_RGB8), }; static const int PVR3_MAX_TABLE_ELEMENTS = sizeof(v3_pixel_formathash_value) / sizeof(v3_pixel_formathash_value[0]); @@ -303,7 +303,7 @@ namespace ////////////////////////////////////////////////////////////////////////// bool Image::PNG_PREMULTIPLIED_ALPHA_ENABLED = false; -Image::Image(): _renderFormat(gfx::GFXFormat::UNKNOWN) +Image::Image(): _renderFormat(gfx::Format::UNKNOWN) { } @@ -597,10 +597,10 @@ bool Image::initWithJpgData(const unsigned char * data, ssize_t dataLen) // we only support RGB or grayscale if (cinfo.jpeg_color_space == JCS_GRAYSCALE) - _renderFormat = gfx::GFXFormat::L8; + _renderFormat = gfx::Format::L8; else { cinfo.out_color_space = JCS_RGB; - _renderFormat = gfx::GFXFormat::RGB8; + _renderFormat = gfx::Format::RGB8; } /* Start decompression jpeg here */ @@ -723,16 +723,16 @@ bool Image::initWithPngData(const unsigned char * data, ssize_t dataLen) switch (color_type) { case PNG_COLOR_TYPE_GRAY: - _renderFormat = gfx::GFXFormat::L8; + _renderFormat = gfx::Format::L8; break; case PNG_COLOR_TYPE_GRAY_ALPHA: - _renderFormat = gfx::GFXFormat::LA8; + _renderFormat = gfx::Format::LA8; break; case PNG_COLOR_TYPE_RGB: - _renderFormat = gfx::GFXFormat::RGB8; + _renderFormat = gfx::Format::RGB8; break; case PNG_COLOR_TYPE_RGB_ALPHA: - _renderFormat = gfx::GFXFormat::RGBA8; + _renderFormat = gfx::Format::RGBA8; break; default: break; @@ -1037,7 +1037,7 @@ bool Image::initWithETCData(const unsigned char * data, ssize_t dataLen) return false; } - _renderFormat = gfx::GFXFormat::ETC_RGB8; + _renderFormat = gfx::Format::ETC_RGB8; _dataLen = dataLen - ETC_PKM_HEADER_SIZE; _data = static_cast(malloc(_dataLen * sizeof(unsigned char))); memcpy(_data, static_cast(data) + ETC_PKM_HEADER_SIZE, _dataLen); @@ -1064,9 +1064,9 @@ bool Image::initWithETC2Data(const unsigned char * data, ssize_t dataLen) etc2_uint32 format = etc2_pkm_get_format(header); if (format == ETC2_RGB_NO_MIPMAPS) - _renderFormat = gfx::GFXFormat::ETC2_RGB8; + _renderFormat = gfx::Format::ETC2_RGB8; else - _renderFormat = gfx::GFXFormat::ETC2_RGBA8; + _renderFormat = gfx::Format::ETC2_RGBA8; _dataLen = dataLen - ETC2_PKM_HEADER_SIZE; _data = static_cast(malloc(_dataLen * sizeof(unsigned char))); @@ -1093,7 +1093,7 @@ bool Image::initWithWebpData(const unsigned char * data, ssize_t dataLen) if (config.input.width == 0 || config.input.height == 0) break; config.output.colorspace = config.input.has_alpha?MODE_rgbA:MODE_RGB; - _renderFormat = config.input.has_alpha ? gfx::GFXFormat::RGBA8 : gfx::GFXFormat::RGB8; + _renderFormat = config.input.has_alpha ? gfx::Format::RGBA8 : gfx::Format::RGB8; _width = config.input.width; _height = config.input.height; @@ -1131,7 +1131,7 @@ bool Image::initWithRawData(const unsigned char * data, ssize_t dataLen, int wid _height = height; _width = width; _hasPremultipliedAlpha = preMulti; - _renderFormat = gfx::GFXFormat::RGBA8; + _renderFormat = gfx::Format::RGBA8; // only RGBA8888 supported int bytesPerComponent = 4; @@ -1151,7 +1151,7 @@ bool Image::initWithRawData(const unsigned char * data, ssize_t dataLen, int wid bool Image::saveToFile(const std::string& filename, bool isToRGB) { //only support for Image::PixelFormat::RGB888 or Image::PixelFormat::RGBA8888 uncompressed data - if (isCompressed() || (_renderFormat != gfx::GFXFormat::RGB8 && _renderFormat != gfx::GFXFormat::RGBA8)) + if (isCompressed() || (_renderFormat != gfx::Format::RGB8 && _renderFormat != gfx::Format::RGBA8)) { CC_LOG_DEBUG("saveToFile: Image: saveToFile is only support for Image::PixelFormat::RGB888 or Image::PixelFormat::RGBA8888 uncompressed data for now"); return false; @@ -1405,7 +1405,7 @@ bool Image::saveImageToJPG(const std::string& filePath) void Image::premultipliedAlpha() { - if (PNG_PREMULTIPLIED_ALPHA_ENABLED && _renderFormat == gfx::GFXFormat::RGBA8) + if (PNG_PREMULTIPLIED_ALPHA_ENABLED && _renderFormat == gfx::Format::RGBA8) { unsigned int* fourBytes = (unsigned int*)_data; for(int i = 0; i < _width * _height; i++) diff --git a/native/cocos/platform/CCImage.h b/native/cocos/platform/CCImage.h index 849f276c49..506ca72faf 100644 --- a/native/cocos/platform/CCImage.h +++ b/native/cocos/platform/CCImage.h @@ -40,7 +40,7 @@ THE SOFTWARE. namespace cc { namespace gfx { -enum class GFXFormat : unsigned int; +enum class Format : unsigned int; } // namespace gfx /** @@ -94,7 +94,7 @@ public: bool alpha; }; - typedef std::map PixelFormatInfoMap; + typedef std::map PixelFormatInfoMap; /** * Enables or disables premultiplied alpha for PNG files. @@ -135,7 +135,7 @@ public: inline unsigned char *getData() const { return _data; } inline ssize_t getDataLen() const { return _dataLen; } inline Format getFileType() const { return _fileType; } - inline gfx::GFXFormat getRenderFormat() const { return _renderFormat; } + inline gfx::Format getRenderFormat() const { return _renderFormat; } inline int getWidth() const { return _width; } inline int getHeight() const { return _height; } inline int getNumberOfMipmaps() const { return _numberOfMipmaps; } @@ -183,7 +183,7 @@ protected: int _width = 0; int _height = 0; Format _fileType = Format::UNKNOWN; - gfx::GFXFormat _renderFormat; + gfx::Format _renderFormat; MipmapInfo _mipmaps[MIPMAP_MAX]; // pointer to mipmap images int _numberOfMipmaps = 0; // false if we can't auto detect the image is premultiplied or not. diff --git a/native/cocos/renderer/core/gfx/GFXBindingLayout.cc b/native/cocos/renderer/core/gfx/GFXBindingLayout.cc index 45605741f6..df9cd9f9da 100755 --- a/native/cocos/renderer/core/gfx/GFXBindingLayout.cc +++ b/native/cocos/renderer/core/gfx/GFXBindingLayout.cc @@ -4,58 +4,58 @@ namespace cc { namespace gfx { -GFXBindingLayout::GFXBindingLayout(GFXDevice *device) -: GFXObject(GFXObjectType::BINDING_LAYOUT), _device(device) { +BindingLayout::BindingLayout(Device *device) +: GFXObject(ObjectType::BINDING_LAYOUT), _device(device) { } -GFXBindingLayout::~GFXBindingLayout() { +BindingLayout::~BindingLayout() { } -void GFXBindingLayout::bindBuffer(uint binding, GFXBuffer *buffer) { +void BindingLayout::bindBuffer(uint binding, Buffer *buffer) { for (size_t i = 0; i < _bindingUnits.size(); ++i) { - GFXBindingUnit &bindingUnit = _bindingUnits[i]; + BindingUnit &bindingUnit = _bindingUnits[i]; if (bindingUnit.binding == binding) { - if (bindingUnit.type == GFXBindingType::UNIFORM_BUFFER) { + if (bindingUnit.type == BindingType::UNIFORM_BUFFER) { if (bindingUnit.buffer != buffer) { bindingUnit.buffer = buffer; _isDirty = true; } } else { - CCASSERT(false, "Setting binding is not GFXBindingType.UNIFORM_BUFFER."); + CCASSERT(false, "Setting binding is not BindingType.UNIFORM_BUFFER."); } return; } } } -void GFXBindingLayout::bindTexture(uint binding, GFXTexture *texture) { +void BindingLayout::bindTexture(uint binding, Texture *texture) { for (size_t i = 0; i < _bindingUnits.size(); ++i) { - GFXBindingUnit &bindingUnit = _bindingUnits[i]; + BindingUnit &bindingUnit = _bindingUnits[i]; if (bindingUnit.binding == binding) { - if (bindingUnit.type == GFXBindingType::SAMPLER) { + if (bindingUnit.type == BindingType::SAMPLER) { if (bindingUnit.texture != texture) { bindingUnit.texture = texture; _isDirty = true; } } else { - CCASSERT(false, "Setting binding is not GFXBindingType.SAMPLER."); + CCASSERT(false, "Setting binding is not BindingType.SAMPLER."); } return; } } } -void GFXBindingLayout::bindSampler(uint binding, GFXSampler *sampler) { +void BindingLayout::bindSampler(uint binding, Sampler *sampler) { for (size_t i = 0; i < _bindingUnits.size(); ++i) { - GFXBindingUnit &bindingUnit = _bindingUnits[i]; + BindingUnit &bindingUnit = _bindingUnits[i]; if (bindingUnit.binding == binding) { - if (bindingUnit.type == GFXBindingType::SAMPLER) { + if (bindingUnit.type == BindingType::SAMPLER) { if (bindingUnit.sampler != sampler) { bindingUnit.sampler = sampler; _isDirty = true; } } else { - CCASSERT(false, "Setting binding is not GFXBindingType.SAMPLER."); + CCASSERT(false, "Setting binding is not BindingType.SAMPLER."); } return; } diff --git a/native/cocos/renderer/core/gfx/GFXBindingLayout.h b/native/cocos/renderer/core/gfx/GFXBindingLayout.h index e06f8a5b55..518c338626 100755 --- a/native/cocos/renderer/core/gfx/GFXBindingLayout.h +++ b/native/cocos/renderer/core/gfx/GFXBindingLayout.h @@ -6,26 +6,26 @@ namespace cc { namespace gfx { -class CC_DLL GFXBindingLayout : public GFXObject { +class CC_DLL BindingLayout : public GFXObject { public: - GFXBindingLayout(GFXDevice *device); - virtual ~GFXBindingLayout(); + BindingLayout(Device *device); + virtual ~BindingLayout(); public: - virtual bool initialize(const GFXBindingLayoutInfo &info) = 0; + virtual bool initialize(const BindingLayoutInfo &info) = 0; virtual void destroy() = 0; virtual void update() = 0; - void bindBuffer(uint binding, GFXBuffer *buffer); - void bindTexture(uint binding, GFXTexture *texView); - void bindSampler(uint binding, GFXSampler *sampler); + void bindBuffer(uint binding, Buffer *buffer); + void bindTexture(uint binding, Texture *texView); + void bindSampler(uint binding, Sampler *sampler); - CC_INLINE GFXDevice *getDevice() const { return _device; } - CC_INLINE const GFXBindingUnitList &getBindingUnits() const { return _bindingUnits; } + CC_INLINE Device *getDevice() const { return _device; } + CC_INLINE const BindingUnitList &getBindingUnits() const { return _bindingUnits; } protected: - GFXDevice *_device = nullptr; - GFXBindingUnitList _bindingUnits; + Device *_device = nullptr; + BindingUnitList _bindingUnits; bool _isDirty = false; }; diff --git a/native/cocos/renderer/core/gfx/GFXBuffer.cc b/native/cocos/renderer/core/gfx/GFXBuffer.cc index 4e1d3d179e..49723e821c 100755 --- a/native/cocos/renderer/core/gfx/GFXBuffer.cc +++ b/native/cocos/renderer/core/gfx/GFXBuffer.cc @@ -4,11 +4,11 @@ namespace cc { namespace gfx { -GFXBuffer::GFXBuffer(GFXDevice *device) -: GFXObject(GFXObjectType::BUFFER), _device(device) { +Buffer::Buffer(Device *device) +: GFXObject(ObjectType::BUFFER), _device(device) { } -GFXBuffer::~GFXBuffer() { +Buffer::~Buffer() { } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXBuffer.h b/native/cocos/renderer/core/gfx/GFXBuffer.h index dd66af8dbb..b670bfeefc 100755 --- a/native/cocos/renderer/core/gfx/GFXBuffer.h +++ b/native/cocos/renderer/core/gfx/GFXBuffer.h @@ -6,34 +6,34 @@ namespace cc { namespace gfx { -class CC_DLL GFXBuffer : public GFXObject { +class CC_DLL Buffer : public GFXObject { public: - GFXBuffer(GFXDevice *device); - virtual ~GFXBuffer(); + Buffer(Device *device); + virtual ~Buffer(); public: - virtual bool initialize(const GFXBufferInfo &info) = 0; + virtual bool initialize(const BufferInfo &info) = 0; virtual void destroy() = 0; virtual void resize(uint size) = 0; virtual void update(void *buffer, uint offset = 0, uint size = 0) = 0; - CC_INLINE GFXDevice *getDevice() const { return _device; } - CC_INLINE GFXBufferUsage getUsage() const { return _usage; } - CC_INLINE GFXMemoryUsage getMemUsage() const { return _memUsage; } + CC_INLINE Device *getDevice() const { return _device; } + CC_INLINE BufferUsage getUsage() const { return _usage; } + CC_INLINE MemoryUsage getMemUsage() const { return _memUsage; } CC_INLINE uint getStride() const { return _stride; } CC_INLINE uint getCount() const { return _count; } CC_INLINE uint getSize() const { return _size; } - CC_INLINE GFXBufferFlags getFlags() const { return _flags; } + CC_INLINE BufferFlags getFlags() const { return _flags; } CC_INLINE uint8_t *getBufferView() const { return _buffer; } protected: - GFXDevice *_device = nullptr; - GFXBufferUsage _usage = GFXBufferUsageBit::NONE; - GFXMemoryUsage _memUsage = GFXMemoryUsageBit::NONE; + Device *_device = nullptr; + BufferUsage _usage = BufferUsageBit::NONE; + MemoryUsage _memUsage = MemoryUsageBit::NONE; uint _stride = 0; uint _count = 0; uint _size = 0; - GFXBufferFlags _flags = GFXBufferFlagBit::NONE; + BufferFlags _flags = BufferFlagBit::NONE; uint8_t *_buffer = nullptr; }; diff --git a/native/cocos/renderer/core/gfx/GFXCommandAllocator.cc b/native/cocos/renderer/core/gfx/GFXCommandAllocator.cc index 3b2df8fd70..487d183c9e 100755 --- a/native/cocos/renderer/core/gfx/GFXCommandAllocator.cc +++ b/native/cocos/renderer/core/gfx/GFXCommandAllocator.cc @@ -4,11 +4,11 @@ namespace cc { namespace gfx { -GFXCommandAllocator::GFXCommandAllocator(GFXDevice *device) -: GFXObject(GFXObjectType::COMMAND_ALLOCATOR), _device(device) { +CommandAllocator::CommandAllocator(Device *device) +: GFXObject(ObjectType::COMMAND_ALLOCATOR), _device(device) { } -GFXCommandAllocator::~GFXCommandAllocator() { +CommandAllocator::~CommandAllocator() { } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXCommandAllocator.h b/native/cocos/renderer/core/gfx/GFXCommandAllocator.h index 088e8f4e95..04e967df89 100755 --- a/native/cocos/renderer/core/gfx/GFXCommandAllocator.h +++ b/native/cocos/renderer/core/gfx/GFXCommandAllocator.h @@ -6,19 +6,19 @@ namespace cc { namespace gfx { -class CC_DLL GFXCommandAllocator : public GFXObject { +class CC_DLL CommandAllocator : public GFXObject { public: - GFXCommandAllocator(GFXDevice *device); - virtual ~GFXCommandAllocator(); + CommandAllocator(Device *device); + virtual ~CommandAllocator(); public: - virtual bool initialize(const GFXCommandAllocatorInfo &info) = 0; + virtual bool initialize(const CommandAllocatorInfo &info) = 0; virtual void destroy() = 0; - CC_INLINE GFXDevice *getDevice() const { return _device; } + CC_INLINE Device *getDevice() const { return _device; } protected: - GFXDevice *_device = nullptr; + Device *_device = nullptr; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXCommandBuffer.cc b/native/cocos/renderer/core/gfx/GFXCommandBuffer.cc index 316e560a51..39e58b91ee 100755 --- a/native/cocos/renderer/core/gfx/GFXCommandBuffer.cc +++ b/native/cocos/renderer/core/gfx/GFXCommandBuffer.cc @@ -4,11 +4,11 @@ namespace cc { namespace gfx { -GFXCommandBuffer::GFXCommandBuffer(GFXDevice *device) -: GFXObject(GFXObjectType::COMMAND_BUFFER), _device(device) { +CommandBuffer::CommandBuffer(Device *device) +: GFXObject(ObjectType::COMMAND_BUFFER), _device(device) { } -GFXCommandBuffer::~GFXCommandBuffer() { +CommandBuffer::~CommandBuffer() { } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXCommandBuffer.h b/native/cocos/renderer/core/gfx/GFXCommandBuffer.h index 0466b86c64..10a350a724 100755 --- a/native/cocos/renderer/core/gfx/GFXCommandBuffer.h +++ b/native/cocos/renderer/core/gfx/GFXCommandBuffer.h @@ -6,45 +6,45 @@ namespace cc { namespace gfx { -class CC_DLL GFXCommandBuffer : public GFXObject { +class CC_DLL CommandBuffer : public GFXObject { public: - GFXCommandBuffer(GFXDevice *device); - virtual ~GFXCommandBuffer(); + CommandBuffer(Device *device); + virtual ~CommandBuffer(); public: - virtual bool initialize(const GFXCommandBufferInfo &info) = 0; + virtual bool initialize(const CommandBufferInfo &info) = 0; virtual void destroy() = 0; - virtual void begin(GFXRenderPass *renderPass = nullptr, uint subpass = 0, GFXFramebuffer *frameBuffer = nullptr) = 0; + virtual void begin(RenderPass *renderPass = nullptr, uint subpass = 0, Framebuffer *frameBuffer = nullptr) = 0; virtual void end() = 0; - virtual void beginRenderPass(GFXFramebuffer *fbo, const GFXRect &render_area, GFXClearFlags clear_flags, const std::vector &colors, float depth, int stencil) = 0; + virtual void beginRenderPass(Framebuffer *fbo, const Rect &render_area, ClearFlags clear_flags, const std::vector &colors, float depth, int stencil) = 0; virtual void endRenderPass() = 0; - virtual void bindPipelineState(GFXPipelineState *pso) = 0; - virtual void bindBindingLayout(GFXBindingLayout *layout) = 0; - virtual void bindInputAssembler(GFXInputAssembler *ia) = 0; - virtual void setViewport(const GFXViewport &vp) = 0; - virtual void setScissor(const GFXRect &rect) = 0; + virtual void bindPipelineState(PipelineState *pso) = 0; + virtual void bindBindingLayout(BindingLayout *layout) = 0; + virtual void bindInputAssembler(InputAssembler *ia) = 0; + virtual void setViewport(const Viewport &vp) = 0; + virtual void setScissor(const Rect &rect) = 0; virtual void setLineWidth(const float width) = 0; virtual void setDepthBias(float constant, float clamp, float slope) = 0; - virtual void setBlendConstants(const GFXColor &constants) = 0; + virtual void setBlendConstants(const Color &constants) = 0; virtual void setDepthBound(float min_bounds, float max_bounds) = 0; - virtual void setStencilWriteMask(GFXStencilFace face, uint mask) = 0; - virtual void setStencilCompareMask(GFXStencilFace face, int ref, uint mask) = 0; - virtual void draw(GFXInputAssembler *ia) = 0; - virtual void updateBuffer(GFXBuffer *buff, void *data, uint size, uint offset = 0) = 0; - virtual void copyBufferToTexture(GFXBuffer *src, GFXTexture *dst, GFXTextureLayout layout, const GFXBufferTextureCopyList ®ions) = 0; - virtual void execute(const std::vector &cmd_buffs, uint32_t count) = 0; + virtual void setStencilWriteMask(StencilFace face, uint mask) = 0; + virtual void setStencilCompareMask(StencilFace face, int ref, uint mask) = 0; + virtual void draw(InputAssembler *ia) = 0; + virtual void updateBuffer(Buffer *buff, void *data, uint size, uint offset = 0) = 0; + virtual void copyBufferToTexture(Buffer *src, Texture *dst, TextureLayout layout, const BufferTextureCopyList ®ions) = 0; + virtual void execute(const std::vector &cmd_buffs, uint32_t count) = 0; - CC_INLINE GFXDevice *getDevice() const { return _device; } - CC_INLINE GFXCommandAllocator *getAllocator() const { return _allocator; } - CC_INLINE GFXCommandBufferType getType() const { return _type; } + CC_INLINE Device *getDevice() const { return _device; } + CC_INLINE CommandAllocator *getAllocator() const { return _allocator; } + CC_INLINE CommandBufferType getType() const { return _type; } CC_INLINE uint getNumDrawCalls() const { return _numDrawCalls; } CC_INLINE uint getNumInstances() const { return _numInstances; } CC_INLINE uint getNumTris() const { return _numTriangles; } protected: - GFXDevice *_device = nullptr; - GFXCommandAllocator *_allocator = nullptr; - GFXCommandBufferType _type = GFXCommandBufferType::PRIMARY; + Device *_device = nullptr; + CommandAllocator *_allocator = nullptr; + CommandBufferType _type = CommandBufferType::PRIMARY; uint32_t _numDrawCalls = 0; uint32_t _numInstances = 0; uint32_t _numTriangles = 0; diff --git a/native/cocos/renderer/core/gfx/GFXCommandPool.h b/native/cocos/renderer/core/gfx/GFXCommandPool.h index 5635c038f2..de1b3e79d0 100644 --- a/native/cocos/renderer/core/gfx/GFXCommandPool.h +++ b/native/cocos/renderer/core/gfx/GFXCommandPool.h @@ -8,9 +8,9 @@ namespace gfx { #define INITIAL_CAPACITY 1 template ::value>> -class GFXCommandPool { +class CommandPool { public: - GFXCommandPool() : _freeCmds(INITIAL_CAPACITY) { + CommandPool() : _freeCmds(INITIAL_CAPACITY) { _frees = new T *[INITIAL_CAPACITY]; _count = INITIAL_CAPACITY; _freeIdx = INITIAL_CAPACITY - 1; @@ -19,7 +19,7 @@ public: } } - ~GFXCommandPool() { + ~CommandPool() { for (uint i = 0; i < _count; ++i) { CC_DELETE(_frees[i]); } diff --git a/native/cocos/renderer/core/gfx/GFXContext.cc b/native/cocos/renderer/core/gfx/GFXContext.cc index 5fed32f57c..dd6cf31140 100755 --- a/native/cocos/renderer/core/gfx/GFXContext.cc +++ b/native/cocos/renderer/core/gfx/GFXContext.cc @@ -4,11 +4,11 @@ namespace cc { namespace gfx { -GFXContext::GFXContext(GFXDevice *device) +Context::Context(Device *device) : _device(device) { } -GFXContext::~GFXContext() { +Context::~Context() { } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXContext.h b/native/cocos/renderer/core/gfx/GFXContext.h index 1a2ee78c2e..a63ecc8794 100755 --- a/native/cocos/renderer/core/gfx/GFXContext.h +++ b/native/cocos/renderer/core/gfx/GFXContext.h @@ -6,29 +6,29 @@ namespace cc { namespace gfx { -class CC_DLL GFXContext : public Object { +class CC_DLL Context : public Object { public: - GFXContext(GFXDevice *device); - virtual ~GFXContext(); + Context(Device *device); + virtual ~Context(); public: - virtual bool initialize(const GFXContextInfo &info) = 0; + virtual bool initialize(const ContextInfo &info) = 0; virtual void destroy() = 0; virtual void present() = 0; - CC_INLINE GFXDevice *getDevice() const { return _device; } - CC_INLINE GFXContext *getSharedContext() const { return _sharedContext; } - CC_INLINE GFXVsyncMode getVsyncMode() const { return _vsyncMode; } - CC_INLINE GFXFormat getColorFormat() const { return _colorFmt; } - CC_INLINE GFXFormat getDepthStencilFormat() const { return _depthStencilFmt; } + CC_INLINE Device *getDevice() const { return _device; } + CC_INLINE Context *getSharedContext() const { return _sharedContext; } + CC_INLINE VsyncMode getVsyncMode() const { return _vsyncMode; } + CC_INLINE Format getColorFormat() const { return _colorFmt; } + CC_INLINE Format getDepthStencilFormat() const { return _depthStencilFmt; } protected: - GFXDevice *_device = nullptr; + Device *_device = nullptr; uintptr_t _windowHandle = 0; - GFXContext *_sharedContext = nullptr; - GFXVsyncMode _vsyncMode = GFXVsyncMode::OFF; - GFXFormat _colorFmt = GFXFormat::UNKNOWN; - GFXFormat _depthStencilFmt = GFXFormat::UNKNOWN; + Context *_sharedContext = nullptr; + VsyncMode _vsyncMode = VsyncMode::OFF; + Format _colorFmt = Format::UNKNOWN; + Format _depthStencilFmt = Format::UNKNOWN; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXDef.cc b/native/cocos/renderer/core/gfx/GFXDef.cc index 9026af87ec..7cc705f970 100755 --- a/native/cocos/renderer/core/gfx/GFXDef.cc +++ b/native/cocos/renderer/core/gfx/GFXDef.cc @@ -4,154 +4,154 @@ namespace cc { namespace gfx { -const GFXFormatInfo GFX_FORMAT_INFOS[] = { - {"UNKNOWN", 0, 0, GFXFormatType::NONE, false, false, false, false}, - {"A8", 1, 1, GFXFormatType::UNORM, true, false, false, false}, - {"L8", 1, 1, GFXFormatType::UNORM, false, false, false, false}, - {"LA8", 1, 2, GFXFormatType::UNORM, false, false, false, false}, +const FormatInfo GFX_FORMAT_INFOS[] = { + {"UNKNOWN", 0, 0, FormatType::NONE, false, false, false, false}, + {"A8", 1, 1, FormatType::UNORM, true, false, false, false}, + {"L8", 1, 1, FormatType::UNORM, false, false, false, false}, + {"LA8", 1, 2, FormatType::UNORM, false, false, false, false}, - {"R8", 1, 1, GFXFormatType::UNORM, false, false, false, false}, - {"R8SN", 1, 1, GFXFormatType::SNORM, false, false, false, false}, - {"R8UI", 1, 1, GFXFormatType::UINT, false, false, false, false}, - {"R8I", 1, 1, GFXFormatType::INT, false, false, false, false}, - {"R16F", 2, 1, GFXFormatType::FLOAT, false, false, false, false}, - {"R16UI", 2, 1, GFXFormatType::UINT, false, false, false, false}, - {"R16I", 2, 1, GFXFormatType::INT, false, false, false, false}, - {"R32F", 4, 1, GFXFormatType::FLOAT, false, false, false, false}, - {"R32UI", 4, 1, GFXFormatType::UINT, false, false, false, false}, - {"R32I", 4, 1, GFXFormatType::INT, false, false, false, false}, + {"R8", 1, 1, FormatType::UNORM, false, false, false, false}, + {"R8SN", 1, 1, FormatType::SNORM, false, false, false, false}, + {"R8UI", 1, 1, FormatType::UINT, false, false, false, false}, + {"R8I", 1, 1, FormatType::INT, false, false, false, false}, + {"R16F", 2, 1, FormatType::FLOAT, false, false, false, false}, + {"R16UI", 2, 1, FormatType::UINT, false, false, false, false}, + {"R16I", 2, 1, FormatType::INT, false, false, false, false}, + {"R32F", 4, 1, FormatType::FLOAT, false, false, false, false}, + {"R32UI", 4, 1, FormatType::UINT, false, false, false, false}, + {"R32I", 4, 1, FormatType::INT, false, false, false, false}, - {"RG8", 2, 2, GFXFormatType::UNORM, false, false, false, false}, - {"RG8SN", 2, 2, GFXFormatType::SNORM, false, false, false, false}, - {"RG8UI", 2, 2, GFXFormatType::UINT, false, false, false, false}, - {"RG8I", 2, 2, GFXFormatType::INT, false, false, false, false}, - {"RG16F", 4, 2, GFXFormatType::FLOAT, false, false, false, false}, - {"RG16UI", 4, 2, GFXFormatType::UINT, false, false, false, false}, - {"RG16I", 4, 2, GFXFormatType::INT, false, false, false, false}, - {"RG32F", 8, 2, GFXFormatType::FLOAT, false, false, false, false}, - {"RG32UI", 8, 2, GFXFormatType::UINT, false, false, false, false}, - {"RG32I", 8, 2, GFXFormatType::INT, false, false, false, false}, + {"RG8", 2, 2, FormatType::UNORM, false, false, false, false}, + {"RG8SN", 2, 2, FormatType::SNORM, false, false, false, false}, + {"RG8UI", 2, 2, FormatType::UINT, false, false, false, false}, + {"RG8I", 2, 2, FormatType::INT, false, false, false, false}, + {"RG16F", 4, 2, FormatType::FLOAT, false, false, false, false}, + {"RG16UI", 4, 2, FormatType::UINT, false, false, false, false}, + {"RG16I", 4, 2, FormatType::INT, false, false, false, false}, + {"RG32F", 8, 2, FormatType::FLOAT, false, false, false, false}, + {"RG32UI", 8, 2, FormatType::UINT, false, false, false, false}, + {"RG32I", 8, 2, FormatType::INT, false, false, false, false}, - {"RGB8", 3, 3, GFXFormatType::UNORM, false, false, false, false}, - {"SRGB8", 3, 3, GFXFormatType::UNORM, false, false, false, false}, - {"RGB8SN", 3, 3, GFXFormatType::SNORM, false, false, false, false}, - {"RGB8UI", 3, 3, GFXFormatType::UINT, false, false, false, false}, - {"RGB8I", 3, 3, GFXFormatType::INT, false, false, false, false}, - {"RGB16F", 6, 3, GFXFormatType::FLOAT, false, false, false, false}, - {"RGB16UI", 6, 3, GFXFormatType::UINT, false, false, false, false}, - {"RGB16I", 6, 3, GFXFormatType::INT, false, false, false, false}, - {"RGB32F", 12, 3, GFXFormatType::FLOAT, false, false, false, false}, - {"RGB32UI", 12, 3, GFXFormatType::UINT, false, false, false, false}, - {"RGB32I", 12, 3, GFXFormatType::INT, false, false, false, false}, + {"RGB8", 3, 3, FormatType::UNORM, false, false, false, false}, + {"SRGB8", 3, 3, FormatType::UNORM, false, false, false, false}, + {"RGB8SN", 3, 3, FormatType::SNORM, false, false, false, false}, + {"RGB8UI", 3, 3, FormatType::UINT, false, false, false, false}, + {"RGB8I", 3, 3, FormatType::INT, false, false, false, false}, + {"RGB16F", 6, 3, FormatType::FLOAT, false, false, false, false}, + {"RGB16UI", 6, 3, FormatType::UINT, false, false, false, false}, + {"RGB16I", 6, 3, FormatType::INT, false, false, false, false}, + {"RGB32F", 12, 3, FormatType::FLOAT, false, false, false, false}, + {"RGB32UI", 12, 3, FormatType::UINT, false, false, false, false}, + {"RGB32I", 12, 3, FormatType::INT, false, false, false, false}, - {"RGBA8", 4, 4, GFXFormatType::UNORM, true, false, false, false}, - {"BGRA8", 4, 4, GFXFormatType::UNORM, true, false, false, false}, - {"SRGB8_A8", 4, 4, GFXFormatType::UNORM, true, false, false, false}, - {"RGBA8SN", 4, 4, GFXFormatType::SNORM, true, false, false, false}, - {"RGBA8UI", 4, 4, GFXFormatType::UINT, true, false, false, false}, - {"RGBA8I", 4, 4, GFXFormatType::INT, true, false, false, false}, - {"RGBA16F", 8, 4, GFXFormatType::FLOAT, true, false, false, false}, - {"RGBA16UI", 8, 4, GFXFormatType::UINT, true, false, false, false}, - {"RGBA16I", 8, 4, GFXFormatType::INT, true, false, false, false}, - {"RGBA32F", 16, 4, GFXFormatType::FLOAT, true, false, false, false}, - {"RGBA32UI", 16, 4, GFXFormatType::UINT, true, false, false, false}, - {"RGBA32I", 16, 4, GFXFormatType::INT, true, false, false, false}, + {"RGBA8", 4, 4, FormatType::UNORM, true, false, false, false}, + {"BGRA8", 4, 4, FormatType::UNORM, true, false, false, false}, + {"SRGB8_A8", 4, 4, FormatType::UNORM, true, false, false, false}, + {"RGBA8SN", 4, 4, FormatType::SNORM, true, false, false, false}, + {"RGBA8UI", 4, 4, FormatType::UINT, true, false, false, false}, + {"RGBA8I", 4, 4, FormatType::INT, true, false, false, false}, + {"RGBA16F", 8, 4, FormatType::FLOAT, true, false, false, false}, + {"RGBA16UI", 8, 4, FormatType::UINT, true, false, false, false}, + {"RGBA16I", 8, 4, FormatType::INT, true, false, false, false}, + {"RGBA32F", 16, 4, FormatType::FLOAT, true, false, false, false}, + {"RGBA32UI", 16, 4, FormatType::UINT, true, false, false, false}, + {"RGBA32I", 16, 4, FormatType::INT, true, false, false, false}, - {"R5G6B5", 2, 3, GFXFormatType::UNORM, false, false, false, false}, - {"R11G11B10F", 4, 3, GFXFormatType::FLOAT, false, false, false, false}, - {"RGB5A1", 2, 4, GFXFormatType::UNORM, true, false, false, false}, - {"RGBA4", 2, 4, GFXFormatType::UNORM, true, false, false, false}, - {"RGB10A2", 2, 4, GFXFormatType::UNORM, true, false, false, false}, - {"RGB10A2UI", 2, 4, GFXFormatType::UINT, true, false, false, false}, - {"RGB9E5", 2, 4, GFXFormatType::FLOAT, true, false, false, false}, + {"R5G6B5", 2, 3, FormatType::UNORM, false, false, false, false}, + {"R11G11B10F", 4, 3, FormatType::FLOAT, false, false, false, false}, + {"RGB5A1", 2, 4, FormatType::UNORM, true, false, false, false}, + {"RGBA4", 2, 4, FormatType::UNORM, true, false, false, false}, + {"RGB10A2", 2, 4, FormatType::UNORM, true, false, false, false}, + {"RGB10A2UI", 2, 4, FormatType::UINT, true, false, false, false}, + {"RGB9E5", 2, 4, FormatType::FLOAT, true, false, false, false}, - {"D16", 2, 1, GFXFormatType::UINT, false, true, false, false}, - {"D16S8", 3, 1, GFXFormatType::UINT, false, true, true, false}, - {"D24", 3, 1, GFXFormatType::UINT, false, true, false, false}, - {"D24S8", 2, 1, GFXFormatType::UINT, false, true, true, false}, - {"D32F", 4, 1, GFXFormatType::FLOAT, false, true, false, false}, - {"D32FS8", 5, 2, GFXFormatType::FLOAT, false, true, true, false}, + {"D16", 2, 1, FormatType::UINT, false, true, false, false}, + {"D16S8", 3, 1, FormatType::UINT, false, true, true, false}, + {"D24", 3, 1, FormatType::UINT, false, true, false, false}, + {"D24S8", 2, 1, FormatType::UINT, false, true, true, false}, + {"D32F", 4, 1, FormatType::FLOAT, false, true, false, false}, + {"D32FS8", 5, 2, FormatType::FLOAT, false, true, true, false}, - {"BC1", 1, 3, GFXFormatType::UNORM, false, false, false, true}, - {"BC1_ALPHA", 1, 4, GFXFormatType::UNORM, true, false, false, true}, - {"BC1_SRGB", 1, 3, GFXFormatType::UNORM, false, false, false, true}, - {"BC1_SRGB_ALPHA", 1, 4, GFXFormatType::UNORM, true, false, false, true}, - {"BC2", 1, 4, GFXFormatType::UNORM, true, false, false, true}, - {"BC2_SRGB", 1, 4, GFXFormatType::UNORM, true, false, false, true}, - {"BC3", 1, 4, GFXFormatType::UNORM, true, false, false, true}, - {"BC3_SRGB", 1, 4, GFXFormatType::UNORM, true, false, false, true}, - {"BC4", 1, 1, GFXFormatType::UNORM, false, false, false, true}, - {"BC4_SNORM", 1, 1, GFXFormatType::SNORM, false, false, false, true}, - {"BC5", 1, 2, GFXFormatType::UNORM, false, false, false, true}, - {"BC5_SNORM", 1, 2, GFXFormatType::SNORM, false, false, false, true}, - {"BC6H_UF16", 1, 3, GFXFormatType::UFLOAT, false, false, false, true}, - {"BC6H_SF16", 1, 3, GFXFormatType::FLOAT, false, false, false, true}, - {"BC7", 1, 4, GFXFormatType::UNORM, true, false, false, true}, - {"BC7_SRGB", 1, 4, GFXFormatType::UNORM, true, false, false, true}, + {"BC1", 1, 3, FormatType::UNORM, false, false, false, true}, + {"BC1_ALPHA", 1, 4, FormatType::UNORM, true, false, false, true}, + {"BC1_SRGB", 1, 3, FormatType::UNORM, false, false, false, true}, + {"BC1_SRGB_ALPHA", 1, 4, FormatType::UNORM, true, false, false, true}, + {"BC2", 1, 4, FormatType::UNORM, true, false, false, true}, + {"BC2_SRGB", 1, 4, FormatType::UNORM, true, false, false, true}, + {"BC3", 1, 4, FormatType::UNORM, true, false, false, true}, + {"BC3_SRGB", 1, 4, FormatType::UNORM, true, false, false, true}, + {"BC4", 1, 1, FormatType::UNORM, false, false, false, true}, + {"BC4_SNORM", 1, 1, FormatType::SNORM, false, false, false, true}, + {"BC5", 1, 2, FormatType::UNORM, false, false, false, true}, + {"BC5_SNORM", 1, 2, FormatType::SNORM, false, false, false, true}, + {"BC6H_UF16", 1, 3, FormatType::UFLOAT, false, false, false, true}, + {"BC6H_SF16", 1, 3, FormatType::FLOAT, false, false, false, true}, + {"BC7", 1, 4, FormatType::UNORM, true, false, false, true}, + {"BC7_SRGB", 1, 4, FormatType::UNORM, true, false, false, true}, - {"ETC_RGB8", 1, 3, GFXFormatType::UNORM, false, false, false, true}, - {"ETC2_RGB8", 1, 3, GFXFormatType::UNORM, false, false, false, true}, - {"ETC2_SRGB8", 1, 3, GFXFormatType::UNORM, false, false, false, true}, - {"ETC2_RGB8_A1", 1, 4, GFXFormatType::UNORM, true, false, false, true}, - {"ETC2_SRGB8_A1", 1, 4, GFXFormatType::UNORM, true, false, false, true}, - {"EAC_R11", 1, 1, GFXFormatType::UNORM, false, false, false, true}, - {"EAC_R11SN", 1, 1, GFXFormatType::SNORM, false, false, false, true}, - {"EAC_RG11", 2, 2, GFXFormatType::UNORM, false, false, false, true}, - {"EAC_RG11SN", 2, 2, GFXFormatType::SNORM, false, false, false, true}, + {"ETC_RGB8", 1, 3, FormatType::UNORM, false, false, false, true}, + {"ETC2_RGB8", 1, 3, FormatType::UNORM, false, false, false, true}, + {"ETC2_SRGB8", 1, 3, FormatType::UNORM, false, false, false, true}, + {"ETC2_RGB8_A1", 1, 4, FormatType::UNORM, true, false, false, true}, + {"ETC2_SRGB8_A1", 1, 4, FormatType::UNORM, true, false, false, true}, + {"EAC_R11", 1, 1, FormatType::UNORM, false, false, false, true}, + {"EAC_R11SN", 1, 1, FormatType::SNORM, false, false, false, true}, + {"EAC_RG11", 2, 2, FormatType::UNORM, false, false, false, true}, + {"EAC_RG11SN", 2, 2, FormatType::SNORM, false, false, false, true}, - {"PVRTC_RGB2", 2, 3, GFXFormatType::UNORM, false, false, false, true}, - {"PVRTC_RGBA2", 2, 4, GFXFormatType::UNORM, true, false, false, true}, - {"PVRTC_RGB4", 2, 3, GFXFormatType::UNORM, false, false, false, true}, - {"PVRTC_RGBA4", 2, 4, GFXFormatType::UNORM, true, false, false, true}, - {"PVRTC2_2BPP", 2, 4, GFXFormatType::UNORM, true, false, false, true}, - {"PVRTC2_4BPP", 2, 4, GFXFormatType::UNORM, true, false, false, true}, + {"PVRTC_RGB2", 2, 3, FormatType::UNORM, false, false, false, true}, + {"PVRTC_RGBA2", 2, 4, FormatType::UNORM, true, false, false, true}, + {"PVRTC_RGB4", 2, 3, FormatType::UNORM, false, false, false, true}, + {"PVRTC_RGBA4", 2, 4, FormatType::UNORM, true, false, false, true}, + {"PVRTC2_2BPP", 2, 4, FormatType::UNORM, true, false, false, true}, + {"PVRTC2_4BPP", 2, 4, FormatType::UNORM, true, false, false, true}, }; -uint GFXFormatSize(GFXFormat format, uint width, uint height, uint depth) { +uint FormatSize(Format format, uint width, uint height, uint depth) { if (!GFX_FORMAT_INFOS[(uint)format].isCompressed) { return (width * height * depth * GFX_FORMAT_INFOS[(uint)format].size); } else { switch (format) { - case GFXFormat::BC1: - case GFXFormat::BC1_ALPHA: - case GFXFormat::BC1_SRGB: - case GFXFormat::BC1_SRGB_ALPHA: + case Format::BC1: + case Format::BC1_ALPHA: + case Format::BC1_SRGB: + case Format::BC1_SRGB_ALPHA: return (uint)std::ceil(width / 4) * (uint)std::ceil(height / 4) * 8 * depth; - case GFXFormat::BC2: - case GFXFormat::BC2_SRGB: - case GFXFormat::BC3: - case GFXFormat::BC3_SRGB: - case GFXFormat::BC4: - case GFXFormat::BC4_SNORM: - case GFXFormat::BC6H_SF16: - case GFXFormat::BC6H_UF16: - case GFXFormat::BC7: - case GFXFormat::BC7_SRGB: + case Format::BC2: + case Format::BC2_SRGB: + case Format::BC3: + case Format::BC3_SRGB: + case Format::BC4: + case Format::BC4_SNORM: + case Format::BC6H_SF16: + case Format::BC6H_UF16: + case Format::BC7: + case Format::BC7_SRGB: return (uint)std::ceil(width / 4) * (uint)std::ceil(height / 4) * 16 * depth; - case GFXFormat::BC5: - case GFXFormat::BC5_SNORM: + case Format::BC5: + case Format::BC5_SNORM: return (uint)std::ceil(width / 4) * (uint)std::ceil(height / 4) * 32 * depth; - case GFXFormat::ETC_RGB8: - case GFXFormat::ETC2_RGB8: - case GFXFormat::ETC2_SRGB8: - case GFXFormat::ETC2_RGB8_A1: - case GFXFormat::ETC2_SRGB8_A1: - case GFXFormat::EAC_R11: - case GFXFormat::EAC_R11SN: + case Format::ETC_RGB8: + case Format::ETC2_RGB8: + case Format::ETC2_SRGB8: + case Format::ETC2_RGB8_A1: + case Format::ETC2_SRGB8_A1: + case Format::EAC_R11: + case Format::EAC_R11SN: return (uint)std::ceil(width / 4) * (uint)std::ceil(height / 4) * 8 * depth; - case GFXFormat::EAC_RG11: - case GFXFormat::EAC_RG11SN: + case Format::EAC_RG11: + case Format::EAC_RG11SN: return (uint)std::ceil(width / 4) * (uint)std::ceil(height / 4) * 16 * depth; - case GFXFormat::PVRTC_RGB2: - case GFXFormat::PVRTC_RGBA2: - case GFXFormat::PVRTC2_2BPP: + case Format::PVRTC_RGB2: + case Format::PVRTC_RGBA2: + case Format::PVRTC2_2BPP: return (uint)std::ceil(std::max(width, 16U) * std::max(height, 8U) / 4) * depth; - case GFXFormat::PVRTC_RGB4: - case GFXFormat::PVRTC_RGBA4: - case GFXFormat::PVRTC2_4BPP: + case Format::PVRTC_RGB4: + case Format::PVRTC_RGBA4: + case Format::PVRTC2_4BPP: return (uint)std::ceil(std::max(width, 16U) * std::max(height, 8U) / 2) * depth; default: { return 0; @@ -195,12 +195,12 @@ const uint GFX_TYPE_SIZES[] = { 4, // SAMPLER_CUBE }; -uint GFXFormatSurfaceSize(GFXFormat format, uint width, uint height, uint depth, uint mips) { +uint FormatSurfaceSize(Format format, uint width, uint height, uint depth, uint mips) { uint size = 0; for (uint i = 0; i < mips; ++i) { - size += GFXFormatSize(format, width, height, depth); + size += FormatSize(format, width, height, depth); width = std::max(width >> 1, 1U); height = std::max(height >> 1, 1U); } diff --git a/native/cocos/renderer/core/gfx/GFXDef.h b/native/cocos/renderer/core/gfx/GFXDef.h index 96c149dc06..9f273a702f 100755 --- a/native/cocos/renderer/core/gfx/GFXDef.h +++ b/native/cocos/renderer/core/gfx/GFXDef.h @@ -4,23 +4,23 @@ namespace cc { namespace gfx { -class GFXDevice; -class GFXBuffer; -class GFXTexture; -class GFXSampler; -class GFXShader; -class GFXInputAssembler; -class GFXRenderPass; -class GFXFramebuffer; -class GFXBindingLayout; -class GFXPipelineLayout; -class GFXPipelineState; -class GFXCommandAllocator; -class GFXCommandBuffer; -class GFXFence; -class GFXQueue; -class GFXWindow; -class GFXContext; +class Device; +class Buffer; +class Texture; +class Sampler; +class Shader; +class InputAssembler; +class RenderPass; +class Framebuffer; +class BindingLayout; +class PipelineLayout; +class PipelineState; +class CommandAllocator; +class CommandBuffer; +class Fence; +class Queue; +class Window; +class Context; #define GFX_MAX_VERTEX_ATTRIBUTES 16 #define GFX_MAX_TEXTURE_UNITS 16 @@ -29,7 +29,7 @@ class GFXContext; #define GFX_INVALID_BINDING ((uint8_t)-1) #define GFX_INVALID_HANDLE ((uint)-1) -enum class GFXObjectType : uint8_t { +enum class ObjectType : uint8_t { UNKNOWN, BUFFER, TEXTURE, @@ -49,13 +49,13 @@ enum class GFXObjectType : uint8_t { WINDOW, }; -enum class GFXStatus : uint8_t { +enum class Status : uint8_t { UNREADY, FAILED, SUCCESS, }; -enum class GFXAPI : uint8_t { +enum class API : uint8_t { UNKNOWN, GL, GLES2, @@ -67,7 +67,7 @@ enum class GFXAPI : uint8_t { WEBGL2, }; -enum class GFXFeature : uint8_t { +enum class Feature : uint8_t { COLOR_FLOAT, COLOR_HALF_FLOAT, TEXTURE_FLOAT, @@ -97,7 +97,7 @@ enum class GFXFeature : uint8_t { COUNT, }; -enum class GFXFormat : uint { +enum class Format : uint { UNKNOWN, @@ -223,7 +223,7 @@ enum class GFXFormat : uint { COUNT, }; -enum class GFXFormatType : uint8_t { +enum class FormatType : uint8_t { NONE, UNORM, SNORM, @@ -233,7 +233,7 @@ enum class GFXFormatType : uint8_t { FLOAT, }; -enum class GFXType : uint8_t { +enum class Type : uint8_t { UNKNOWN, BOOL, BOOL2, @@ -269,7 +269,7 @@ enum class GFXType : uint8_t { COUNT, }; -enum class GFXBufferUsageBit : FlagBits { +enum class BufferUsageBit : FlagBits { NONE = 0, TRANSFER_SRC = 0x1, TRANSFER_DST = 0x2, @@ -279,33 +279,33 @@ enum class GFXBufferUsageBit : FlagBits { STORAGE = 0x20, INDIRECT = 0x40, }; -typedef GFXBufferUsageBit GFXBufferUsage; -CC_ENUM_OPERATORS(GFXBufferUsageBit); +typedef BufferUsageBit BufferUsage; +CC_ENUM_OPERATORS(BufferUsageBit); -enum class GFXBufferFlagBit : FlagBits { +enum class BufferFlagBit : FlagBits { NONE = 0, BAKUP_BUFFER = 0x4, }; -typedef GFXBufferFlagBit GFXBufferFlags; -CC_ENUM_OPERATORS(GFXBufferFlagBit); +typedef BufferFlagBit BufferFlags; +CC_ENUM_OPERATORS(BufferFlagBit); -enum class GFXBufferAccessBit : FlagBits { +enum class BufferAccessBit : FlagBits { NONE = 0, READ = 0x1, WRITE = 0x2, }; -typedef GFXBufferAccessBit GFXBufferAccess; -CC_ENUM_OPERATORS(GFXBufferAccessBit); +typedef BufferAccessBit BufferAccess; +CC_ENUM_OPERATORS(BufferAccessBit); -enum class GFXMemoryUsageBit : FlagBits { +enum class MemoryUsageBit : FlagBits { NONE = 0, DEVICE = 0x1, HOST = 0x2, }; -typedef GFXMemoryUsageBit GFXMemoryUsage; -CC_ENUM_OPERATORS(GFXMemoryUsageBit); +typedef MemoryUsageBit MemoryUsage; +CC_ENUM_OPERATORS(MemoryUsageBit); -enum class GFXTextureType { +enum class TextureType { TEX1D, TEX2D, TEX3D, @@ -314,7 +314,7 @@ enum class GFXTextureType { TEX2D_ARRAY, }; -enum class GFXTextureUsageBit : FlagBits { +enum class TextureUsageBit : FlagBits { NONE = 0, TRANSFER_SRC = 0x1, TRANSFER_DST = 0x2, @@ -325,19 +325,19 @@ enum class GFXTextureUsageBit : FlagBits { TRANSIENT_ATTACHMENT = 0x40, INPUT_ATTACHMENT = 0x80, }; -typedef GFXTextureUsageBit GFXTextureUsage; -CC_ENUM_OPERATORS(GFXTextureUsageBit); +typedef TextureUsageBit TextureUsage; +CC_ENUM_OPERATORS(TextureUsageBit); -enum class GFXTextureFlagBit : FlagBits { +enum class TextureFlagBit : FlagBits { NONE = 0, GEN_MIPMAP = 0x1, CUBEMAP = 0x2, BAKUP_BUFFER = 0x4, }; -typedef GFXTextureFlagBit GFXTextureFlags; -CC_ENUM_OPERATORS(GFXTextureFlagBit); +typedef TextureFlagBit TextureFlags; +CC_ENUM_OPERATORS(TextureFlagBit); -enum class GFXSampleCount : uint8_t { +enum class SampleCount : uint8_t { X1, X2, X4, @@ -347,21 +347,21 @@ enum class GFXSampleCount : uint8_t { X64, }; -enum class GFXFilter : uint8_t { +enum class Filter : uint8_t { NONE, POINT, LINEAR, ANISOTROPIC, }; -enum class GFXAddress : uint8_t { +enum class Address : uint8_t { WRAP, MIRROR, CLAMP, BORDER, }; -enum class GFXComparisonFunc : uint8_t { +enum class ComparisonFunc : uint8_t { NEVER, LESS, EQUAL, @@ -372,7 +372,7 @@ enum class GFXComparisonFunc : uint8_t { ALWAYS, }; -enum class GFXStencilOp : uint8_t { +enum class StencilOp : uint8_t { ZERO, KEEP, REPLACE, @@ -383,7 +383,7 @@ enum class GFXStencilOp : uint8_t { DECR_WRAP, }; -enum class GFXBlendFactor : uint8_t { +enum class BlendFactor : uint8_t { ZERO, ONE, SRC_ALPHA, @@ -401,7 +401,7 @@ enum class GFXBlendFactor : uint8_t { ONE_MINUS_CONSTANT_ALPHA, }; -enum class GFXBlendOp : uint8_t { +enum class BlendOp : uint8_t { ADD, SUB, REV_SUB, @@ -409,7 +409,7 @@ enum class GFXBlendOp : uint8_t { MAX, }; -enum class GFXColorMask : uint8_t { +enum class ColorMask : uint8_t { NONE = 0x0, R = 0x1, G = 0x2, @@ -417,9 +417,9 @@ enum class GFXColorMask : uint8_t { A = 0x8, ALL = R | G | B | A, }; -CC_ENUM_OPERATORS(GFXColorMask); +CC_ENUM_OPERATORS(ColorMask); -enum class GFXShaderType : uint8_t { +enum class ShaderType : uint8_t { NONE = 0x0, VERTEX = 0x1, CONTROL = 0x2, @@ -429,20 +429,20 @@ enum class GFXShaderType : uint8_t { COMPUTE = 0x20, ALL = 0x3f, }; -CC_ENUM_OPERATORS(GFXShaderType); +CC_ENUM_OPERATORS(ShaderType); -enum class GFXLoadOp : uint8_t { +enum class LoadOp : uint8_t { LOAD, // Load the contents from the fbo from previous CLEAR, // Clear the fbo DISCARD, // Ignore writing to the fbo and keep old data }; -enum class GFXStoreOp : uint8_t { +enum class StoreOp : uint8_t { STORE, // Write the source to the destination DISCARD, // Don't write the source to the destination }; -enum class GFXTextureLayout : uint8_t { +enum class TextureLayout : uint8_t { UNDEFINED, GENERAL, COLOR_ATTACHMENT_OPTIMAL, @@ -455,13 +455,13 @@ enum class GFXTextureLayout : uint8_t { PRESENT_SRC, }; -enum class GFXPipelineBindPoint : uint8_t { +enum class PipelineBindPoint : uint8_t { GRAPHICS, COMPUTE, RAY_TRACING, }; -enum class GFXPrimitiveMode : uint8_t { +enum class PrimitiveMode : uint8_t { POINT_LIST, LINE_LIST, LINE_STRIP, @@ -479,24 +479,24 @@ enum class GFXPrimitiveMode : uint8_t { QUAD_PATCH_LIST, }; -enum class GFXPolygonMode : uint8_t { +enum class PolygonMode : uint8_t { FILL, POINT, LINE, }; -enum class GFXShadeModel : uint8_t { +enum class ShadeModel : uint8_t { GOURAND, FLAT, }; -enum class GFXCullMode : uint8_t { +enum class CullMode : uint8_t { NONE, FRONT, BACK, }; -enum class GFXDynamicState : uint8_t { +enum class DynamicState : uint8_t { VIEWPORT, SCISSOR, LINE_WIDTH, @@ -507,33 +507,33 @@ enum class GFXDynamicState : uint8_t { STENCIL_COMPARE_MASK, }; -typedef vector GFXDynamicStateList; +typedef vector DynamicStateList; -enum class GFXStencilFace : uint8_t { +enum class StencilFace : uint8_t { FRONT, BACK, ALL, }; -enum class GFXBindingType : uint8_t { +enum class BindingType : uint8_t { UNKNOWN, UNIFORM_BUFFER, SAMPLER, STORAGE_BUFFER, }; -enum class GFXQueueType : uint8_t { +enum class QueueType : uint8_t { GRAPHICS, COMPUTE, TRANSFER, }; -enum class GFXCommandBufferType : uint8_t { +enum class CommandBufferType : uint8_t { PRIMARY, SECONDARY, }; -enum class GFXClearFlagBit : uint8_t { +enum class ClearFlagBit : uint8_t { NONE = 0, COLOR = 0x1, DEPTH = 0x2, @@ -541,10 +541,10 @@ enum class GFXClearFlagBit : uint8_t { DEPTH_STENCIL = DEPTH | STENCIL, ALL = COLOR | DEPTH | STENCIL, }; -typedef GFXClearFlagBit GFXClearFlags; -CC_ENUM_OPERATORS(GFXClearFlags); +typedef ClearFlagBit ClearFlags; +CC_ENUM_OPERATORS(ClearFlags); -enum class GFXVsyncMode : uint8_t { +enum class VsyncMode : uint8_t { // The application does not synchronizes with the vertical sync. If application renders faster than the display refreshes, frames are wasted and tearing may be observed. FPS is uncapped. Maximum power consumption. If unsupported, "ON" value will be used instead. Minimum latency. OFF, // The application is always synchronized with the vertical sync. Tearing does not happen. FPS is capped to the display's refresh rate. For fast applications, battery life is improved. Always supported. @@ -557,19 +557,19 @@ enum class GFXVsyncMode : uint8_t { HALF, }; -struct GFXOffset { +struct Offset { int x; int y; int z; }; -struct GFXRect { +struct Rect { int x = 0; int y = 0; uint width = 0u; uint height = 0u; - bool operator==(const GFXRect &rs) { + bool operator==(const Rect &rs) { if (x == rs.x && y == rs.y && width == rs.width && @@ -579,45 +579,45 @@ struct GFXRect { return false; } - bool operator!=(const GFXRect &rs) { + bool operator!=(const Rect &rs) { return !(*this == rs); } }; -struct GFXExtent { +struct Extent { uint width; uint height; uint depth; }; -struct GFXTextureSubres { +struct TextureSubres { uint mipLevel = 0u; uint baseArrayLayer = 0u; uint layerCount = 1u; }; -struct GFXTextureCopy { - GFXTextureSubres srcSubres; - GFXOffset srcOffset = {0, 0, 0}; - GFXTextureSubres dstSubres; - GFXOffset dstOffset = {0, 0, 0}; - GFXExtent extent = {0, 0, 1}; +struct TextureCopy { + TextureSubres srcSubres; + Offset srcOffset = {0, 0, 0}; + TextureSubres dstSubres; + Offset dstOffset = {0, 0, 0}; + Extent extent = {0, 0, 1}; }; -struct GFXBufferTextureCopy { +struct BufferTextureCopy { uint buffStride = 0; uint buffTexHeight = 0; - GFXOffset texOffset = {0, 0, 0}; - GFXExtent texExtent = {0, 0, 1}; - GFXTextureSubres texSubres; + Offset texOffset = {0, 0, 0}; + Extent texExtent = {0, 0, 1}; + TextureSubres texSubres; }; -typedef vector GFXBufferTextureCopyList; +typedef vector BufferTextureCopyList; -struct GFXDataArray { +struct DataArray { std::vector datas; }; -struct GFXViewport { +struct Viewport { int left = 0; int top = 0; uint width = 0; @@ -625,7 +625,7 @@ struct GFXViewport { float minDepth = 0.0f; float maxDepth = 1.0f; - bool operator==(const GFXViewport &rs) { + bool operator==(const Viewport &rs) { if (left == rs.left && top == rs.top && width == rs.width && @@ -637,13 +637,13 @@ struct GFXViewport { return false; } - bool operator!=(const GFXViewport &rs) { + bool operator!=(const Viewport &rs) { return !(*this == rs); } }; #pragma pack(push, 1) -struct GFXColor { +struct Color { float r = 0.0f; float g = 0.0f; float b = 0.0f; @@ -651,46 +651,46 @@ struct GFXColor { }; #pragma pack(pop) -struct GFXDeviceInfo { +struct DeviceInfo { uintptr_t windowHandle = 0; uint width = 0; uint height = 0; uint nativeWidth = 0; uint nativeHeight = 0; - GFXContext *sharedCtx = nullptr; + Context *sharedCtx = nullptr; }; -struct GFXWindowInfo { +struct WindowInfo { String title; int left = 0; int top = 0; uint width = 800; uint height = 600; - GFXFormat colorFmt = GFXFormat::UNKNOWN; - GFXFormat depthStencilFmt = GFXFormat::UNKNOWN; + Format colorFmt = Format::UNKNOWN; + Format depthStencilFmt = Format::UNKNOWN; bool isOffscreen = false; bool isFullscreen = false; - GFXVsyncMode vsyncMode = GFXVsyncMode::OFF; + VsyncMode vsyncMode = VsyncMode::OFF; uintptr_t windowHandle = 0; - GFXRenderPass *renderPass = nullptr; + RenderPass *renderPass = nullptr; }; -struct GFXContextInfo { +struct ContextInfo { uintptr_t windowHandle = 0; - GFXContext *sharedCtx = nullptr; - GFXVsyncMode vsyncMode = GFXVsyncMode::RELAXED; + Context *sharedCtx = nullptr; + VsyncMode vsyncMode = VsyncMode::RELAXED; }; -struct GFXBufferInfo { - GFXBufferUsage usage = GFXBufferUsage::NONE; - GFXMemoryUsage memUsage = GFXMemoryUsage::NONE; +struct BufferInfo { + BufferUsage usage = BufferUsage::NONE; + MemoryUsage memUsage = MemoryUsage::NONE; uint stride = 1; uint size = 0; - GFXBufferFlags flags = GFXBufferFlagBit::NONE; + BufferFlags flags = BufferFlagBit::NONE; }; #pragma pack(push, 1) -struct GFXDrawInfo { +struct DrawInfo { uint vertexCount = 0; uint firstVertex = 0; uint indexCount = 0; @@ -701,151 +701,151 @@ struct GFXDrawInfo { }; #pragma pack(pop) -typedef vector GFXDrawInfoList; +typedef vector DrawInfoList; -struct GFXIndirectBuffer { - GFXDrawInfoList drawInfos; +struct IndirectBuffer { + DrawInfoList drawInfos; }; -struct GFXTextureInfo { - GFXTextureType type = GFXTextureType::TEX2D; - GFXTextureUsage usage = GFXTextureUsageBit::NONE; - GFXFormat format = GFXFormat::UNKNOWN; +struct TextureInfo { + TextureType type = TextureType::TEX2D; + TextureUsage usage = TextureUsageBit::NONE; + Format format = Format::UNKNOWN; uint width = 0; uint height = 0; uint depth = 1; uint arrayLayer = 1; uint mipLevel = 1; - GFXSampleCount samples = GFXSampleCount::X1; - GFXTextureFlags flags = GFXTextureFlagBit::NONE; + SampleCount samples = SampleCount::X1; + TextureFlags flags = TextureFlagBit::NONE; }; -struct GFXTextureViewInfo { - GFXTexture *texture = nullptr; - GFXTextureType type = GFXTextureType::TEX2D; - GFXFormat format = GFXFormat::UNKNOWN; +struct TextureViewInfo { + Texture *texture = nullptr; + TextureType type = TextureType::TEX2D; + Format format = Format::UNKNOWN; uint baseLevel = 0; uint levelCount = 1; uint baseLayer = 0; uint layerCount = 1; }; -struct GFXSamplerInfo { +struct SamplerInfo { String name; - GFXFilter minFilter = GFXFilter::LINEAR; - GFXFilter magFilter = GFXFilter::LINEAR; - GFXFilter mipFilter = GFXFilter::NONE; - GFXAddress addressU = GFXAddress::WRAP; - GFXAddress addressV = GFXAddress::WRAP; - GFXAddress addressW = GFXAddress::WRAP; + Filter minFilter = Filter::LINEAR; + Filter magFilter = Filter::LINEAR; + Filter mipFilter = Filter::NONE; + Address addressU = Address::WRAP; + Address addressV = Address::WRAP; + Address addressW = Address::WRAP; uint maxAnisotropy = 16; - GFXComparisonFunc cmpFunc = GFXComparisonFunc::NEVER; - GFXColor borderColor; + ComparisonFunc cmpFunc = ComparisonFunc::NEVER; + Color borderColor; uint minLOD = 0; uint maxLOD = 1000; float mipLODBias = 0.0f; }; -struct GFXShaderMacro { +struct ShaderMacro { String macro; String value; }; -typedef vector GFXShaderMacroList; +typedef vector ShaderMacroList; -struct GFXUniform { +struct Uniform { String name; - GFXType type = GFXType::UNKNOWN; + Type type = Type::UNKNOWN; uint count = 0; }; -typedef vector GFXUniformList; +typedef vector UniformList; -struct GFXUniformBlock { - GFXShaderType shaderStages = GFXShaderType::NONE; +struct UniformBlock { + ShaderType shaderStages = ShaderType::NONE; uint binding = 0; String name; - GFXUniformList uniforms; + UniformList uniforms; }; -typedef vector GFXUniformBlockList; +typedef vector UniformBlockList; -struct GFXUniformSampler { - GFXShaderType shaderStages = GFXShaderType::NONE; +struct UniformSampler { + ShaderType shaderStages = ShaderType::NONE; uint binding = 0; String name; - GFXType type = GFXType::UNKNOWN; + Type type = Type::UNKNOWN; uint count = 0; }; -typedef vector GFXUniformSamplerList; +typedef vector UniformSamplerList; -struct GFXShaderStage { - GFXShaderType type; +struct ShaderStage { + ShaderType type; String source; - GFXShaderMacroList macros; + ShaderMacroList macros; }; -typedef vector GFXShaderStageList; +typedef vector ShaderStageList; -struct GFXAttribute { +struct Attribute { String name; - GFXFormat format = GFXFormat::UNKNOWN; + Format format = Format::UNKNOWN; bool isNormalized = false; uint stream = 0; bool isInstanced = false; uint location = 0; }; -typedef vector GFXAttributeList; -typedef vector GFXBufferList; +typedef vector AttributeList; +typedef vector BufferList; -struct GFXShaderInfo { +struct ShaderInfo { String name; - GFXShaderStageList stages; - GFXAttributeList attributes; - GFXUniformBlockList blocks; - GFXUniformSamplerList samplers; + ShaderStageList stages; + AttributeList attributes; + UniformBlockList blocks; + UniformSamplerList samplers; }; -struct GFXInputAssemblerInfo { - GFXAttributeList attributes; - GFXBufferList vertexBuffers; - GFXBuffer *indexBuffer = nullptr; - GFXBuffer *indirectBuffer = nullptr; +struct InputAssemblerInfo { + AttributeList attributes; + BufferList vertexBuffers; + Buffer *indexBuffer = nullptr; + Buffer *indirectBuffer = nullptr; }; -struct GFXColorAttachment { - GFXFormat format = GFXFormat::UNKNOWN; - GFXLoadOp loadOp = GFXLoadOp::CLEAR; - GFXStoreOp storeOp = GFXStoreOp::STORE; +struct ColorAttachment { + Format format = Format::UNKNOWN; + LoadOp loadOp = LoadOp::CLEAR; + StoreOp storeOp = StoreOp::STORE; uint sampleCount = 1; - GFXTextureLayout beginLayout = GFXTextureLayout::COLOR_ATTACHMENT_OPTIMAL; - GFXTextureLayout endLayout = GFXTextureLayout::COLOR_ATTACHMENT_OPTIMAL; + TextureLayout beginLayout = TextureLayout::COLOR_ATTACHMENT_OPTIMAL; + TextureLayout endLayout = TextureLayout::COLOR_ATTACHMENT_OPTIMAL; }; -typedef vector GFXColorAttachmentList; +typedef vector ColorAttachmentList; -struct GFXDepthStencilAttachment { - GFXFormat format = GFXFormat::UNKNOWN; - GFXLoadOp depthLoadOp = GFXLoadOp::CLEAR; - GFXStoreOp depthStoreOp = GFXStoreOp::STORE; - GFXLoadOp stencilLoadOp = GFXLoadOp::CLEAR; - GFXStoreOp stencilStoreOp = GFXStoreOp::STORE; +struct DepthStencilAttachment { + Format format = Format::UNKNOWN; + LoadOp depthLoadOp = LoadOp::CLEAR; + StoreOp depthStoreOp = StoreOp::STORE; + LoadOp stencilLoadOp = LoadOp::CLEAR; + StoreOp stencilStoreOp = StoreOp::STORE; uint sampleCount = 1; - GFXTextureLayout beginLayout = GFXTextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - GFXTextureLayout endLayout = GFXTextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + TextureLayout beginLayout = TextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + TextureLayout endLayout = TextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL; }; -struct GFXSubPass { - GFXPipelineBindPoint bindPoint = GFXPipelineBindPoint::GRAPHICS; +struct SubPass { + PipelineBindPoint bindPoint = PipelineBindPoint::GRAPHICS; uint8_t inputs[GFX_MAX_ATTACHMENTS]; uint8_t colors[GFX_MAX_ATTACHMENTS]; uint8_t resolves[GFX_MAX_ATTACHMENTS]; uint8_t depthStencil = GFX_INVALID_BINDING; uint8_t preserves[GFX_MAX_ATTACHMENTS]; - GFXSubPass() { + SubPass() { memset(inputs, -1, sizeof(inputs)); memset(colors, -1, sizeof(colors)); memset(resolves, -1, sizeof(resolves)); @@ -853,75 +853,75 @@ struct GFXSubPass { } }; -typedef vector GFXSubPassList; +typedef vector SubPassList; -struct GFXRenderPassInfo { - GFXColorAttachmentList colorAttachments; - GFXDepthStencilAttachment depthStencilAttachment; - GFXSubPassList subPasses; +struct RenderPassInfo { + ColorAttachmentList colorAttachments; + DepthStencilAttachment depthStencilAttachment; + SubPassList subPasses; }; -typedef vector GFXTextureList; +typedef vector TextureList; -struct GFXFramebufferInfo { - GFXRenderPass *renderPass = nullptr; - GFXTextureList colorTextures; +struct FramebufferInfo { + RenderPass *renderPass = nullptr; + TextureList colorTextures; vector colorMipmapLevels; - GFXTexture *depthStencilTexture = nullptr; + Texture *depthStencilTexture = nullptr; int depthStencilMipmapLevel = 0; bool isOffscreen = true; }; -struct GFXBinding { - GFXShaderType shaderStages = GFXShaderType::NONE; +struct Binding { + ShaderType shaderStages = ShaderType::NONE; uint binding = 0; - GFXBindingType type = GFXBindingType::UNKNOWN; + BindingType type = BindingType::UNKNOWN; String name; uint count = 0; }; -typedef vector GFXBindingList; +typedef vector BindingList; -struct GFXBindingLayoutInfo { - GFXBindingList bindings; +struct BindingLayoutInfo { + BindingList bindings; }; -struct GFXBindingUnit { - GFXShaderType shaderStages = GFXShaderType::NONE; +struct BindingUnit { + ShaderType shaderStages = ShaderType::NONE; uint binding = 0; - GFXBindingType type = GFXBindingType::UNKNOWN; + BindingType type = BindingType::UNKNOWN; String name; uint count = 0; - GFXBuffer *buffer = nullptr; - GFXTexture *texture = nullptr; - GFXSampler *sampler = nullptr; + Buffer *buffer = nullptr; + Texture *texture = nullptr; + Sampler *sampler = nullptr; }; -typedef vector GFXBindingUnitList; +typedef vector BindingUnitList; -struct GFXPushConstantRange { - GFXShaderType shaderType = GFXShaderType::NONE; +struct PushConstantRange { + ShaderType shaderType = ShaderType::NONE; uint offset = 0; uint count = 0; }; -typedef vector GFXPushConstantRangeList; -typedef vector GFXBindingLayoutList; +typedef vector PushConstantRangeList; +typedef vector BindingLayoutList; -struct GFXPipelineLayoutInfo { - GFXPushConstantRangeList pushConstantsRanges; - GFXBindingLayoutList layouts; +struct PipelineLayoutInfo { + PushConstantRangeList pushConstantsRanges; + BindingLayoutList layouts; }; -struct GFXInputState { - GFXAttributeList attributes; +struct InputState { + AttributeList attributes; }; -struct GFXRasterizerState { +struct RasterizerState { bool isDiscard = false; - GFXPolygonMode polygonMode = GFXPolygonMode::FILL; - GFXShadeModel shadeModel = GFXShadeModel::GOURAND; - GFXCullMode cullMode = GFXCullMode::BACK; + PolygonMode polygonMode = PolygonMode::FILL; + ShadeModel shadeModel = ShadeModel::GOURAND; + CullMode cullMode = CullMode::BACK; bool isFrontFaceCCW = true; bool depthBiasEnabled = false; float depthBias = 0.0f; @@ -932,102 +932,102 @@ struct GFXRasterizerState { float lineWidth = 1.0f; }; -struct GFXDepthStencilState { +struct DepthStencilState { bool depthTest = true; bool depthWrite = true; - GFXComparisonFunc depthFunc = GFXComparisonFunc::LESS; + ComparisonFunc depthFunc = ComparisonFunc::LESS; bool stencilTestFront = false; - GFXComparisonFunc stencilFuncFront = GFXComparisonFunc::ALWAYS; + ComparisonFunc stencilFuncFront = ComparisonFunc::ALWAYS; uint stencilReadMaskFront = 0xffffffff; uint stencilWriteMaskFront = 0xffffffff; - GFXStencilOp stencilFailOpFront = GFXStencilOp::KEEP; - GFXStencilOp stencilZFailOpFront = GFXStencilOp::KEEP; - GFXStencilOp stencilPassOpFront = GFXStencilOp::KEEP; + StencilOp stencilFailOpFront = StencilOp::KEEP; + StencilOp stencilZFailOpFront = StencilOp::KEEP; + StencilOp stencilPassOpFront = StencilOp::KEEP; uint stencilRefFront = 1; bool stencilTestBack = false; - GFXComparisonFunc stencilFuncBack = GFXComparisonFunc::ALWAYS; + ComparisonFunc stencilFuncBack = ComparisonFunc::ALWAYS; uint stencilReadMaskBack = 0xffffffff; uint stencilWriteMaskBack = 0xffffffff; - GFXStencilOp stencilFailOpBack = GFXStencilOp::KEEP; - GFXStencilOp stencilZFailOpBack = GFXStencilOp::KEEP; - GFXStencilOp stencilPassOpBack = GFXStencilOp::KEEP; + StencilOp stencilFailOpBack = StencilOp::KEEP; + StencilOp stencilZFailOpBack = StencilOp::KEEP; + StencilOp stencilPassOpBack = StencilOp::KEEP; uint stencilRefBack = 1; }; -struct GFXBlendTarget { +struct BlendTarget { bool blend = false; - GFXBlendFactor blendSrc = GFXBlendFactor::ONE; - GFXBlendFactor blendDst = GFXBlendFactor::ZERO; - GFXBlendOp blendEq = GFXBlendOp::ADD; - GFXBlendFactor blendSrcAlpha = GFXBlendFactor::ONE; - GFXBlendFactor blendDstAlpha = GFXBlendFactor::ZERO; - GFXBlendOp blendAlphaEq = GFXBlendOp::ADD; - GFXColorMask blendColorMask = GFXColorMask::ALL; + BlendFactor blendSrc = BlendFactor::ONE; + BlendFactor blendDst = BlendFactor::ZERO; + BlendOp blendEq = BlendOp::ADD; + BlendFactor blendSrcAlpha = BlendFactor::ONE; + BlendFactor blendDstAlpha = BlendFactor::ZERO; + BlendOp blendAlphaEq = BlendOp::ADD; + ColorMask blendColorMask = ColorMask::ALL; }; -typedef vector GFXBlendTargetList; +typedef vector BlendTargetList; -struct GFXBlendState { +struct BlendState { bool isA2C = false; bool isIndepend = false; - GFXColor blendColor; - GFXBlendTargetList targets; + Color blendColor; + BlendTargetList targets; - GFXBlendState() { - targets.emplace_back(GFXBlendTarget()); + BlendState() { + targets.emplace_back(BlendTarget()); } }; -struct GFXPipelineStateInfo { - GFXPrimitiveMode primitive = GFXPrimitiveMode::TRIANGLE_LIST; - GFXShader *shader = nullptr; - GFXInputState inputState; - GFXRasterizerState rasterizerState; - GFXDepthStencilState depthStencilState; - GFXBlendState blendState; - GFXDynamicStateList dynamicStates; - GFXPipelineLayout *layout = nullptr; - GFXRenderPass *renderPass = nullptr; +struct PipelineStateInfo { + PrimitiveMode primitive = PrimitiveMode::TRIANGLE_LIST; + Shader *shader = nullptr; + InputState inputState; + RasterizerState rasterizerState; + DepthStencilState depthStencilState; + BlendState blendState; + DynamicStateList dynamicStates; + PipelineLayout *layout = nullptr; + RenderPass *renderPass = nullptr; }; -struct GFXCommandAllocatorInfo { +struct CommandAllocatorInfo { }; -struct GFXCommandBufferInfo { - GFXCommandAllocator *allocator = nullptr; - GFXCommandBufferType type = GFXCommandBufferType::PRIMARY; +struct CommandBufferInfo { + CommandAllocator *allocator = nullptr; + CommandBufferType type = CommandBufferType::PRIMARY; }; -struct GFXQueueInfo { - GFXQueueType type = GFXQueueType::GRAPHICS; +struct QueueInfo { + QueueType type = QueueType::GRAPHICS; bool forceSync = false; }; -struct GFXFenceInfo { +struct FenceInfo { }; -struct GFXFormatInfo { +struct FormatInfo { String name; uint size = 0; uint count = 0; - GFXFormatType type = GFXFormatType::NONE; + FormatType type = FormatType::NONE; bool hasAlpha = false; bool hasDepth = false; bool hasStencil = false; bool isCompressed = false; }; -extern CC_DLL const GFXFormatInfo GFX_FORMAT_INFOS[]; +extern CC_DLL const FormatInfo GFX_FORMAT_INFOS[]; extern CC_DLL const uint GFX_TYPE_SIZES[]; -struct GFXMemoryStatus { +struct MemoryStatus { uint bufferSize = 0; uint textureSize = 0; }; -extern CC_DLL uint GFXFormatSize(GFXFormat format, uint width, uint height, uint depth); +extern CC_DLL uint FormatSize(Format format, uint width, uint height, uint depth); -extern CC_DLL uint GFXFormatSurfaceSize(GFXFormat format, uint width, uint height, uint depth, uint mips); +extern CC_DLL uint FormatSurfaceSize(Format format, uint width, uint height, uint depth, uint mips); } // namespace gfx } // namespace cc diff --git a/native/cocos/renderer/core/gfx/GFXDevice.cc b/native/cocos/renderer/core/gfx/GFXDevice.cc index ab5d45dbe6..80a46b015a 100755 --- a/native/cocos/renderer/core/gfx/GFXDevice.cc +++ b/native/cocos/renderer/core/gfx/GFXDevice.cc @@ -4,18 +4,18 @@ namespace cc { namespace gfx { -GFXDevice::GFXDevice() { +Device::Device() { memset(_features, 0, sizeof(_features)); } -GFXDevice::~GFXDevice() { +Device::~Device() { } -GFXFormat GFXDevice::getColorFormat() const { +Format Device::getColorFormat() const { return _context->getColorFormat(); } -GFXFormat GFXDevice::getDepthStencilFormat() const { +Format Device::getDepthStencilFormat() const { return _context->getDepthStencilFormat(); } diff --git a/native/cocos/renderer/core/gfx/GFXDevice.h b/native/cocos/renderer/core/gfx/GFXDevice.h index fa49a8542f..2e8473f7a4 100755 --- a/native/cocos/renderer/core/gfx/GFXDevice.h +++ b/native/cocos/renderer/core/gfx/GFXDevice.h @@ -6,44 +6,44 @@ namespace cc { namespace gfx { -class CC_DLL GFXDevice : public Object { +class CC_DLL Device : public Object { public: - GFXDevice(); - virtual ~GFXDevice(); + Device(); + virtual ~Device(); public: - virtual bool initialize(const GFXDeviceInfo &info) = 0; + virtual bool initialize(const DeviceInfo &info) = 0; virtual void destroy() = 0; virtual void resize(uint width, uint height) = 0; virtual void acquire() = 0; virtual void present() = 0; - virtual GFXFence *createFence(const GFXFenceInfo &info) = 0; - virtual GFXQueue *createQueue(const GFXQueueInfo &info) = 0; - virtual GFXCommandAllocator *createCommandAllocator(const GFXCommandAllocatorInfo &info) = 0; - virtual GFXCommandBuffer *createCommandBuffer(const GFXCommandBufferInfo &info) = 0; - virtual GFXBuffer *createBuffer(const GFXBufferInfo &info) = 0; - virtual GFXTexture *createTexture(const GFXTextureInfo &info) = 0; - virtual GFXTexture *createTexture(const GFXTextureViewInfo &info) = 0; - virtual GFXSampler *createSampler(const GFXSamplerInfo &info) = 0; - virtual GFXShader *createShader(const GFXShaderInfo &info) = 0; - virtual GFXInputAssembler *createInputAssembler(const GFXInputAssemblerInfo &info) = 0; - virtual GFXRenderPass *createRenderPass(const GFXRenderPassInfo &info) = 0; - virtual GFXFramebuffer *createFramebuffer(const GFXFramebufferInfo &info) = 0; - virtual GFXBindingLayout *createBindingLayout(const GFXBindingLayoutInfo &info) = 0; - virtual GFXPipelineState *createPipelineState(const GFXPipelineStateInfo &info) = 0; - virtual GFXPipelineLayout *createPipelineLayout(const GFXPipelineLayoutInfo &info) = 0; - virtual void copyBuffersToTexture(const GFXDataArray &buffers, GFXTexture *dst, const GFXBufferTextureCopyList ®ions) = 0; + virtual Fence *createFence(const FenceInfo &info) = 0; + virtual Queue *createQueue(const QueueInfo &info) = 0; + virtual CommandAllocator *createCommandAllocator(const CommandAllocatorInfo &info) = 0; + virtual CommandBuffer *createCommandBuffer(const CommandBufferInfo &info) = 0; + virtual Buffer *createBuffer(const BufferInfo &info) = 0; + virtual Texture *createTexture(const TextureInfo &info) = 0; + virtual Texture *createTexture(const TextureViewInfo &info) = 0; + virtual Sampler *createSampler(const SamplerInfo &info) = 0; + virtual Shader *createShader(const ShaderInfo &info) = 0; + virtual InputAssembler *createInputAssembler(const InputAssemblerInfo &info) = 0; + virtual RenderPass *createRenderPass(const RenderPassInfo &info) = 0; + virtual Framebuffer *createFramebuffer(const FramebufferInfo &info) = 0; + virtual BindingLayout *createBindingLayout(const BindingLayoutInfo &info) = 0; + virtual PipelineState *createPipelineState(const PipelineStateInfo &info) = 0; + virtual PipelineLayout *createPipelineLayout(const PipelineLayoutInfo &info) = 0; + virtual void copyBuffersToTexture(const DataArray &buffers, Texture *dst, const BufferTextureCopyList ®ions) = 0; - CC_INLINE GFXAPI getGfxAPI() const { return _gfxAPI; } + CC_INLINE API getGfxAPI() const { return _API; } CC_INLINE const String &getDeviceName() const { return _deviceName; } CC_INLINE uint getWidth() { return _width; } CC_INLINE uint getHeight() { return _height; } CC_INLINE uint getNativeWidth() { return _nativeWidth; } CC_INLINE uint getNativeHeight() { return _nativeHeight; } - CC_INLINE GFXMemoryStatus &getMemoryStatus() { return _memoryStatus; } - CC_INLINE GFXContext *getContext() const { return _context; } - CC_INLINE GFXQueue *getQueue() const { return _queue; } - CC_INLINE GFXCommandAllocator *getCommandAllocator() const { return _cmdAllocator; } + CC_INLINE MemoryStatus &getMemoryStatus() { return _memoryStatus; } + CC_INLINE Context *getContext() const { return _context; } + CC_INLINE Queue *getQueue() const { return _queue; } + CC_INLINE CommandAllocator *getCommandAllocator() const { return _cmdAllocator; } CC_INLINE const String &getRenderer() const { return _renderer; } CC_INLINE const String &getVendor() const { return _vendor; } CC_INLINE uint getNumDrawCalls() const { return _numDrawCalls; } @@ -62,30 +62,30 @@ public: CC_INLINE int getStencilBits() const { return _stencilBits; } CC_INLINE uint getShaderIdGen() { return _shaderIdGen++; } CC_INLINE bool getReverseCW() const { return _reverseCW; } - GFXFormat getColorFormat() const; - GFXFormat getDepthStencilFormat() const; - CC_INLINE bool hasFeature(GFXFeature feature) const { return _features[static_cast(feature)]; } + Format getColorFormat() const; + Format getDepthStencilFormat() const; + CC_INLINE bool hasFeature(Feature feature) const { return _features[static_cast(feature)]; } CC_INLINE void defineMacro(const String ¯o, const String &value) { _macros[macro] = value; } CC_INLINE void setReverseCW(bool reverseCW) { _reverseCW = reverseCW; } CC_INLINE float getMinClipZ() const { return _minClipZ; } CC_INLINE float getProjectionSignY() const { return _projectionSignY; } protected: - GFXAPI _gfxAPI = GFXAPI::UNKNOWN; + API _API = API::UNKNOWN; String _deviceName; String _renderer; String _vendor; String _version; - bool _features[static_cast(GFXFeature::COUNT)]; + bool _features[static_cast(Feature::COUNT)]; uint _width = 0; uint _height = 0; uint _nativeWidth = 0; uint _nativeHeight = 0; - GFXMemoryStatus _memoryStatus; + MemoryStatus _memoryStatus; uintptr_t _windowHandle = 0; - GFXContext *_context = nullptr; - GFXQueue *_queue = nullptr; - GFXCommandAllocator *_cmdAllocator = nullptr; + Context *_context = nullptr; + Queue *_queue = nullptr; + CommandAllocator *_cmdAllocator = nullptr; uint _numDrawCalls = 0; uint _numInstances = 0; uint _numTriangles = 0; diff --git a/native/cocos/renderer/core/gfx/GFXFence.cc b/native/cocos/renderer/core/gfx/GFXFence.cc index 981cb761f4..60ea9a40c9 100644 --- a/native/cocos/renderer/core/gfx/GFXFence.cc +++ b/native/cocos/renderer/core/gfx/GFXFence.cc @@ -4,11 +4,11 @@ namespace cc { namespace gfx { -GFXFence::GFXFence(GFXDevice *device) -: GFXObject(GFXObjectType::FENCE), _device(device) { +Fence::Fence(Device *device) +: GFXObject(ObjectType::FENCE), _device(device) { } -GFXFence::~GFXFence() { +Fence::~Fence() { } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXFence.h b/native/cocos/renderer/core/gfx/GFXFence.h index 9bf8151bc4..fb2f9f80c8 100644 --- a/native/cocos/renderer/core/gfx/GFXFence.h +++ b/native/cocos/renderer/core/gfx/GFXFence.h @@ -6,19 +6,19 @@ namespace cc { namespace gfx { -class CC_DLL GFXFence : public GFXObject { +class CC_DLL Fence : public GFXObject { public: - GFXFence(GFXDevice *device); - virtual ~GFXFence(); + Fence(Device *device); + virtual ~Fence(); public: - virtual bool initialize(const GFXFenceInfo &info) = 0; + virtual bool initialize(const FenceInfo &info) = 0; virtual void destroy() = 0; virtual void wait() = 0; virtual void reset() = 0; protected: - GFXDevice *_device = nullptr; + Device *_device = nullptr; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXFramebuffer.cc b/native/cocos/renderer/core/gfx/GFXFramebuffer.cc index 873cdfd877..9f63e53960 100755 --- a/native/cocos/renderer/core/gfx/GFXFramebuffer.cc +++ b/native/cocos/renderer/core/gfx/GFXFramebuffer.cc @@ -4,11 +4,11 @@ namespace cc { namespace gfx { -GFXFramebuffer::GFXFramebuffer(GFXDevice *device) -: GFXObject(GFXObjectType::FRAMEBUFFER), _device(device) { +Framebuffer::Framebuffer(Device *device) +: GFXObject(ObjectType::FRAMEBUFFER), _device(device) { } -GFXFramebuffer::~GFXFramebuffer() { +Framebuffer::~Framebuffer() { } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXFramebuffer.h b/native/cocos/renderer/core/gfx/GFXFramebuffer.h index 21e71ae069..11c7946c11 100755 --- a/native/cocos/renderer/core/gfx/GFXFramebuffer.h +++ b/native/cocos/renderer/core/gfx/GFXFramebuffer.h @@ -6,26 +6,26 @@ namespace cc { namespace gfx { -class CC_DLL GFXFramebuffer : public GFXObject { +class CC_DLL Framebuffer : public GFXObject { public: - GFXFramebuffer(GFXDevice *device); - virtual ~GFXFramebuffer(); + Framebuffer(Device *device); + virtual ~Framebuffer(); public: - virtual bool initialize(const GFXFramebufferInfo &info) = 0; + virtual bool initialize(const FramebufferInfo &info) = 0; virtual void destroy() = 0; - CC_INLINE GFXDevice *getDevice() const { return _device; } - CC_INLINE GFXRenderPass *getRenderPass() const { return _renderPass; } - CC_INLINE const GFXTextureList &getColorTextures() const { return _colorTextures; } - CC_INLINE GFXTexture *getDepthStencilTexture() const { return _depthStencilTexture; } + CC_INLINE Device *getDevice() const { return _device; } + CC_INLINE RenderPass *getRenderPass() const { return _renderPass; } + CC_INLINE const TextureList &getColorTextures() const { return _colorTextures; } + CC_INLINE Texture *getDepthStencilTexture() const { return _depthStencilTexture; } CC_INLINE bool isOffscreen() const { return _isOffscreen; } protected: - GFXDevice *_device = nullptr; - GFXRenderPass *_renderPass = nullptr; - GFXTextureList _colorTextures; - GFXTexture *_depthStencilTexture = nullptr; + Device *_device = nullptr; + RenderPass *_renderPass = nullptr; + TextureList _colorTextures; + Texture *_depthStencilTexture = nullptr; bool _isOffscreen = true; }; diff --git a/native/cocos/renderer/core/gfx/GFXInputAssembler.cc b/native/cocos/renderer/core/gfx/GFXInputAssembler.cc index 07e7bdbaaf..69838840b2 100755 --- a/native/cocos/renderer/core/gfx/GFXInputAssembler.cc +++ b/native/cocos/renderer/core/gfx/GFXInputAssembler.cc @@ -4,14 +4,14 @@ namespace cc { namespace gfx { -GFXInputAssembler::GFXInputAssembler(GFXDevice *device) -: GFXObject(GFXObjectType::INPUT_ASSEMBLER), _device(device) { +InputAssembler::InputAssembler(Device *device) +: GFXObject(ObjectType::INPUT_ASSEMBLER), _device(device) { } -GFXInputAssembler::~GFXInputAssembler() { +InputAssembler::~InputAssembler() { } -void GFXInputAssembler::extractDrawInfo(GFXDrawInfo &drawInfo) const { +void InputAssembler::extractDrawInfo(DrawInfo &drawInfo) const { drawInfo.vertexCount = _vertexCount; drawInfo.firstVertex = _firstVertex; drawInfo.indexCount = _indexCount; @@ -21,9 +21,9 @@ void GFXInputAssembler::extractDrawInfo(GFXDrawInfo &drawInfo) const { drawInfo.firstInstance = _firstInstance; } -uint GFXInputAssembler::computeAttributesHash() const { +uint InputAssembler::computeAttributesHash() const { // https://stackoverflow.com/questions/20511347/a-good-hash-function-for-a-vector - // 6: GFXAttribute has 6 elements. + // 6: Attribute has 6 elements. std::size_t seed = _attributes.size() * 6; for (const auto attribute : _attributes) { seed ^= std::hash{}(attribute.name) + 0x9e3779b9 + (seed << 6) + (seed >> 2); diff --git a/native/cocos/renderer/core/gfx/GFXInputAssembler.h b/native/cocos/renderer/core/gfx/GFXInputAssembler.h index d9029f56c1..f87d219c8d 100755 --- a/native/cocos/renderer/core/gfx/GFXInputAssembler.h +++ b/native/cocos/renderer/core/gfx/GFXInputAssembler.h @@ -6,22 +6,22 @@ namespace cc { namespace gfx { -class CC_DLL GFXInputAssembler : public GFXObject { +class CC_DLL InputAssembler : public GFXObject { public: - GFXInputAssembler(GFXDevice *device); - virtual ~GFXInputAssembler(); + InputAssembler(Device *device); + virtual ~InputAssembler(); public: - virtual bool initialize(const GFXInputAssemblerInfo &info) = 0; + virtual bool initialize(const InputAssemblerInfo &info) = 0; virtual void destroy() = 0; - void extractDrawInfo(GFXDrawInfo &drawInfo) const; + void extractDrawInfo(DrawInfo &drawInfo) const; - CC_INLINE GFXDevice *getDevice() const { return _device; } - CC_INLINE const GFXAttributeList &getAttributes() const { return _attributes; } - CC_INLINE const GFXBufferList &getVertexBuffers() const { return _vertexBuffers; } - CC_INLINE GFXBuffer *getIndexBuffer() const { return _indexBuffer; } - CC_INLINE GFXBuffer *getIndirectBuffer() const { return _indirectBuffer; } + CC_INLINE Device *getDevice() const { return _device; } + CC_INLINE const AttributeList &getAttributes() const { return _attributes; } + CC_INLINE const BufferList &getVertexBuffers() const { return _vertexBuffers; } + CC_INLINE Buffer *getIndexBuffer() const { return _indexBuffer; } + CC_INLINE Buffer *getIndirectBuffer() const { return _indirectBuffer; } CC_INLINE uint getVertexCount() const { return _vertexCount; } CC_INLINE uint getFirstVertex() const { return _firstVertex; } CC_INLINE uint getIndexCount() const { return _indexCount; } @@ -42,11 +42,11 @@ public: protected: uint computeAttributesHash() const; - GFXDevice *_device = nullptr; - GFXAttributeList _attributes; - GFXBufferList _vertexBuffers; - GFXBuffer *_indexBuffer = nullptr; - GFXBuffer *_indirectBuffer = nullptr; + Device *_device = nullptr; + AttributeList _attributes; + BufferList _vertexBuffers; + Buffer *_indexBuffer = nullptr; + Buffer *_indirectBuffer = nullptr; uint _vertexCount = 0; uint _firstVertex = 0; uint _indexCount = 0; diff --git a/native/cocos/renderer/core/gfx/GFXObject.cc b/native/cocos/renderer/core/gfx/GFXObject.cc index e646c64bc1..701bc34b1c 100644 --- a/native/cocos/renderer/core/gfx/GFXObject.cc +++ b/native/cocos/renderer/core/gfx/GFXObject.cc @@ -4,8 +4,8 @@ namespace cc { namespace gfx { -GFXObject::GFXObject(GFXObjectType gfxType) -: _gfxType(gfxType) {} +GFXObject::GFXObject(ObjectType Type) +: _Type(Type) {} } // namespace gfx } // namespace cc diff --git a/native/cocos/renderer/core/gfx/GFXObject.h b/native/cocos/renderer/core/gfx/GFXObject.h index c43f64c14c..8fe9b2fb71 100644 --- a/native/cocos/renderer/core/gfx/GFXObject.h +++ b/native/cocos/renderer/core/gfx/GFXObject.h @@ -7,15 +7,15 @@ namespace gfx { class GFXObject : public Object { public: - GFXObject(GFXObjectType gfxType); + GFXObject(ObjectType Type); virtual ~GFXObject() = default; - CC_INLINE GFXObjectType getType() const { return _gfxType; } - CC_INLINE GFXStatus getStatus() const { return _status; } + CC_INLINE ObjectType getType() const { return _Type; } + CC_INLINE Status getStatus() const { return _status; } protected: - GFXObjectType _gfxType = GFXObjectType::UNKNOWN; - GFXStatus _status = GFXStatus::UNREADY; + ObjectType _Type = ObjectType::UNKNOWN; + Status _status = Status::UNREADY; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXPipelineLayout.cc b/native/cocos/renderer/core/gfx/GFXPipelineLayout.cc index 10198e9d80..4b45efd2cc 100755 --- a/native/cocos/renderer/core/gfx/GFXPipelineLayout.cc +++ b/native/cocos/renderer/core/gfx/GFXPipelineLayout.cc @@ -4,11 +4,11 @@ namespace cc { namespace gfx { -GFXPipelineLayout::GFXPipelineLayout(GFXDevice *device) -: GFXObject(GFXObjectType::PIPELINE_LAYOUT), _device(device) { +PipelineLayout::PipelineLayout(Device *device) +: GFXObject(ObjectType::PIPELINE_LAYOUT), _device(device) { } -GFXPipelineLayout::~GFXPipelineLayout() { +PipelineLayout::~PipelineLayout() { } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXPipelineLayout.h b/native/cocos/renderer/core/gfx/GFXPipelineLayout.h index 9fa3b8e787..619a0d13a8 100755 --- a/native/cocos/renderer/core/gfx/GFXPipelineLayout.h +++ b/native/cocos/renderer/core/gfx/GFXPipelineLayout.h @@ -6,23 +6,23 @@ namespace cc { namespace gfx { -class CC_DLL GFXPipelineLayout : public GFXObject { +class CC_DLL PipelineLayout : public GFXObject { public: - GFXPipelineLayout(GFXDevice *device); - virtual ~GFXPipelineLayout(); + PipelineLayout(Device *device); + virtual ~PipelineLayout(); public: - virtual bool initialize(const GFXPipelineLayoutInfo &info) = 0; + virtual bool initialize(const PipelineLayoutInfo &info) = 0; virtual void destroy() = 0; - CC_INLINE GFXDevice *getDevice() const { return _device; } - CC_INLINE const GFXPushConstantRangeList &getPushConstantsRanges() const { return _pushConstantsRanges; } - CC_INLINE const GFXBindingLayoutList &getLayouts() const { return _layouts; } + CC_INLINE Device *getDevice() const { return _device; } + CC_INLINE const PushConstantRangeList &getPushConstantsRanges() const { return _pushConstantsRanges; } + CC_INLINE const BindingLayoutList &getLayouts() const { return _layouts; } protected: - GFXDevice *_device = nullptr; - GFXPushConstantRangeList _pushConstantsRanges; - GFXBindingLayoutList _layouts; + Device *_device = nullptr; + PushConstantRangeList _pushConstantsRanges; + BindingLayoutList _layouts; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXPipelineState.cc b/native/cocos/renderer/core/gfx/GFXPipelineState.cc index 0b761c1cf4..374d76753b 100755 --- a/native/cocos/renderer/core/gfx/GFXPipelineState.cc +++ b/native/cocos/renderer/core/gfx/GFXPipelineState.cc @@ -4,11 +4,11 @@ namespace cc { namespace gfx { -GFXPipelineState::GFXPipelineState(GFXDevice *device) -: GFXObject(GFXObjectType::PIPELINE_STATE), _device(device) { +PipelineState::PipelineState(Device *device) +: GFXObject(ObjectType::PIPELINE_STATE), _device(device) { } -GFXPipelineState::~GFXPipelineState() { +PipelineState::~PipelineState() { } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXPipelineState.h b/native/cocos/renderer/core/gfx/GFXPipelineState.h index e75d66f914..9a7dc1f479 100755 --- a/native/cocos/renderer/core/gfx/GFXPipelineState.h +++ b/native/cocos/renderer/core/gfx/GFXPipelineState.h @@ -6,37 +6,37 @@ namespace cc { namespace gfx { -class CC_DLL GFXPipelineState : public GFXObject { +class CC_DLL PipelineState : public GFXObject { public: - GFXPipelineState(GFXDevice *device); - virtual ~GFXPipelineState(); + PipelineState(Device *device); + virtual ~PipelineState(); public: - virtual bool initialize(const GFXPipelineStateInfo &info) = 0; + virtual bool initialize(const PipelineStateInfo &info) = 0; virtual void destroy() = 0; - CC_INLINE GFXDevice *getDevice() const { return _device; } - CC_INLINE GFXShader *getShader() const { return _shader; } - CC_INLINE GFXPrimitiveMode getPrimitive() const { return _primitive; } - CC_INLINE const GFXInputState &getInputState() const { return _inputState; } - CC_INLINE const GFXRasterizerState &getRasterizerState() const { return _rasterizerState; } - CC_INLINE const GFXDepthStencilState &getDepthStencilState() const { return _depthStencilState; } - CC_INLINE const GFXBlendState &getBlendState() const { return _blendState; } - CC_INLINE const GFXDynamicStateList &getDynamicStates() const { return _dynamicStates; } - CC_INLINE const GFXPipelineLayout *getPipelineLayout() const { return _layout; } - CC_INLINE const GFXRenderPass *getRenderPass() const { return _renderPass; } + CC_INLINE Device *getDevice() const { return _device; } + CC_INLINE Shader *getShader() const { return _shader; } + CC_INLINE PrimitiveMode getPrimitive() const { return _primitive; } + CC_INLINE const InputState &getInputState() const { return _inputState; } + CC_INLINE const RasterizerState &getRasterizerState() const { return _rasterizerState; } + CC_INLINE const DepthStencilState &getDepthStencilState() const { return _depthStencilState; } + CC_INLINE const BlendState &getBlendState() const { return _blendState; } + CC_INLINE const DynamicStateList &getDynamicStates() const { return _dynamicStates; } + CC_INLINE const PipelineLayout *getPipelineLayout() const { return _layout; } + CC_INLINE const RenderPass *getRenderPass() const { return _renderPass; } protected: - GFXDevice *_device = nullptr; - GFXShader *_shader = nullptr; - GFXPrimitiveMode _primitive = GFXPrimitiveMode::TRIANGLE_LIST; - GFXInputState _inputState; - GFXRasterizerState _rasterizerState; - GFXDepthStencilState _depthStencilState; - GFXBlendState _blendState; - GFXDynamicStateList _dynamicStates; - GFXPipelineLayout *_layout = nullptr; - GFXRenderPass *_renderPass = nullptr; + Device *_device = nullptr; + Shader *_shader = nullptr; + PrimitiveMode _primitive = PrimitiveMode::TRIANGLE_LIST; + InputState _inputState; + RasterizerState _rasterizerState; + DepthStencilState _depthStencilState; + BlendState _blendState; + DynamicStateList _dynamicStates; + PipelineLayout *_layout = nullptr; + RenderPass *_renderPass = nullptr; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXQueue.cc b/native/cocos/renderer/core/gfx/GFXQueue.cc index 57a4e2979d..91b4f9497c 100755 --- a/native/cocos/renderer/core/gfx/GFXQueue.cc +++ b/native/cocos/renderer/core/gfx/GFXQueue.cc @@ -4,11 +4,11 @@ namespace cc { namespace gfx { -GFXQueue::GFXQueue(GFXDevice *device) -: GFXObject(GFXObjectType::QUEUE), _device(device) { +Queue::Queue(Device *device) +: GFXObject(ObjectType::QUEUE), _device(device) { } -GFXQueue::~GFXQueue() { +Queue::~Queue() { } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXQueue.h b/native/cocos/renderer/core/gfx/GFXQueue.h index 4f7f6cce8b..85677f19eb 100755 --- a/native/cocos/renderer/core/gfx/GFXQueue.h +++ b/native/cocos/renderer/core/gfx/GFXQueue.h @@ -6,24 +6,24 @@ namespace cc { namespace gfx { -class CC_DLL GFXQueue : public GFXObject { +class CC_DLL Queue : public GFXObject { public: - GFXQueue(GFXDevice *device); - virtual ~GFXQueue(); + Queue(Device *device); + virtual ~Queue(); public: - virtual bool initialize(const GFXQueueInfo &info) = 0; + virtual bool initialize(const QueueInfo &info) = 0; virtual void destroy() = 0; - virtual void submit(const vector &cmdBuffs, GFXFence *fence) = 0; + virtual void submit(const vector &cmdBuffs, Fence *fence) = 0; - CC_INLINE void submit(const vector &cmdBuffs) { submit(cmdBuffs, nullptr); } - CC_INLINE GFXDevice *getDevice() const { return _device; } - CC_INLINE GFXQueueType getType() const { return _type; } + CC_INLINE void submit(const vector &cmdBuffs) { submit(cmdBuffs, nullptr); } + CC_INLINE Device *getDevice() const { return _device; } + CC_INLINE QueueType getType() const { return _type; } CC_INLINE bool isAsync() const { return _isAsync; } protected: - GFXDevice *_device = nullptr; - GFXQueueType _type = GFXQueueType::GRAPHICS; + Device *_device = nullptr; + QueueType _type = QueueType::GRAPHICS; bool _isAsync = false; }; diff --git a/native/cocos/renderer/core/gfx/GFXRenderPass.cc b/native/cocos/renderer/core/gfx/GFXRenderPass.cc index 8ff21592fb..1774212795 100755 --- a/native/cocos/renderer/core/gfx/GFXRenderPass.cc +++ b/native/cocos/renderer/core/gfx/GFXRenderPass.cc @@ -4,17 +4,17 @@ namespace cc { namespace gfx { -GFXRenderPass::GFXRenderPass(GFXDevice *device) -: GFXObject(GFXObjectType::RENDER_PASS), _device(device) { +RenderPass::RenderPass(Device *device) +: GFXObject(ObjectType::RENDER_PASS), _device(device) { } -GFXRenderPass::~GFXRenderPass() { +RenderPass::~RenderPass() { } -uint GFXRenderPass::computeHash() const { +uint RenderPass::computeHash() const { // https://stackoverflow.com/questions/20511347/a-good-hash-function-for-a-vector - // 6: GFXColorAttament has 6 elements. - // 8: GFXDepthStencilAttachment has 8 elements. + // 6: ColorAttament has 6 elements. + // 8: DepthStencilAttachment has 8 elements. uint seed = _colorAttachments.size() * 6 + 8; for (const auto &colorAttachment : _colorAttachments) { seed ^= (uint)(colorAttachment.format) + 0x9e3779b9 + (seed << 6) + (seed >> 2); diff --git a/native/cocos/renderer/core/gfx/GFXRenderPass.h b/native/cocos/renderer/core/gfx/GFXRenderPass.h index 8f8a53ccab..7c1311a304 100755 --- a/native/cocos/renderer/core/gfx/GFXRenderPass.h +++ b/native/cocos/renderer/core/gfx/GFXRenderPass.h @@ -6,28 +6,28 @@ namespace cc { namespace gfx { -class CC_DLL GFXRenderPass : public GFXObject { +class CC_DLL RenderPass : public GFXObject { public: - GFXRenderPass(GFXDevice *device); - virtual ~GFXRenderPass(); + RenderPass(Device *device); + virtual ~RenderPass(); public: - virtual bool initialize(const GFXRenderPassInfo &info) = 0; + virtual bool initialize(const RenderPassInfo &info) = 0; virtual void destroy() = 0; - CC_INLINE GFXDevice *getDevice() const { return _device; } - CC_INLINE const GFXColorAttachmentList &getColorAttachments() const { return _colorAttachments; } - CC_INLINE const GFXDepthStencilAttachment &getDepthStencilAttachment() const { return _depthStencilAttachment; } - CC_INLINE const GFXSubPassList &getSubPasses() const { return _subPasses; } + CC_INLINE Device *getDevice() const { return _device; } + CC_INLINE const ColorAttachmentList &getColorAttachments() const { return _colorAttachments; } + CC_INLINE const DepthStencilAttachment &getDepthStencilAttachment() const { return _depthStencilAttachment; } + CC_INLINE const SubPassList &getSubPasses() const { return _subPasses; } CC_INLINE uint getHash() const { return _hash; } protected: uint computeHash() const; - GFXDevice *_device = nullptr; - GFXColorAttachmentList _colorAttachments; - GFXDepthStencilAttachment _depthStencilAttachment; - GFXSubPassList _subPasses; + Device *_device = nullptr; + ColorAttachmentList _colorAttachments; + DepthStencilAttachment _depthStencilAttachment; + SubPassList _subPasses; uint _hash = 0; }; diff --git a/native/cocos/renderer/core/gfx/GFXSampler.cc b/native/cocos/renderer/core/gfx/GFXSampler.cc index dac66e9650..2e9b904013 100755 --- a/native/cocos/renderer/core/gfx/GFXSampler.cc +++ b/native/cocos/renderer/core/gfx/GFXSampler.cc @@ -4,15 +4,15 @@ namespace cc { namespace gfx { -GFXSampler::GFXSampler(GFXDevice *device) -: GFXObject(GFXObjectType::SAMPLER), _device(device) { +Sampler::Sampler(Device *device) +: GFXObject(ObjectType::SAMPLER), _device(device) { _borderColor.r = 0.0f; _borderColor.g = 0.0f; _borderColor.b = 0.0f; _borderColor.a = 0.0f; } -GFXSampler::~GFXSampler() { +Sampler::~Sampler() { } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXSampler.h b/native/cocos/renderer/core/gfx/GFXSampler.h index ff9f4baae1..42f5c1d770 100755 --- a/native/cocos/renderer/core/gfx/GFXSampler.h +++ b/native/cocos/renderer/core/gfx/GFXSampler.h @@ -6,42 +6,42 @@ namespace cc { namespace gfx { -class CC_DLL GFXSampler : public GFXObject { +class CC_DLL Sampler : public GFXObject { public: - GFXSampler(GFXDevice *device); - virtual ~GFXSampler(); + Sampler(Device *device); + virtual ~Sampler(); public: - virtual bool initialize(const GFXSamplerInfo &info) = 0; + virtual bool initialize(const SamplerInfo &info) = 0; virtual void destroy() = 0; - CC_INLINE GFXDevice *getDevice() const { return _device; } + CC_INLINE Device *getDevice() const { return _device; } CC_INLINE const String &getName() const { return _name; } - CC_INLINE GFXFilter getMinFilter() const { return _minFilter; } - CC_INLINE GFXFilter getMagFilter() const { return _magFilter; } - CC_INLINE GFXFilter getMipFilter() const { return _mipFilter; } - CC_INLINE GFXAddress getAddressU() const { return _addressU; } - CC_INLINE GFXAddress getAddressV() const { return _addressV; } - CC_INLINE GFXAddress getAddressW() const { return _addressW; } + CC_INLINE Filter getMinFilter() const { return _minFilter; } + CC_INLINE Filter getMagFilter() const { return _magFilter; } + CC_INLINE Filter getMipFilter() const { return _mipFilter; } + CC_INLINE Address getAddressU() const { return _addressU; } + CC_INLINE Address getAddressV() const { return _addressV; } + CC_INLINE Address getAddressW() const { return _addressW; } CC_INLINE uint getMaxAnisotropy() const { return _maxAnisotropy; } - CC_INLINE GFXComparisonFunc getCmpFunc() const { return _cmpFunc; } - CC_INLINE const GFXColor &getBorderColor() const { return _borderColor; } + CC_INLINE ComparisonFunc getCmpFunc() const { return _cmpFunc; } + CC_INLINE const Color &getBorderColor() const { return _borderColor; } CC_INLINE uint getMinLOD() const { return _minLOD; } CC_INLINE uint getMaxLOD() const { return _maxLOD; } CC_INLINE float getMipLODBias() const { return _mipLODBias; } protected: - GFXDevice *_device = nullptr; + Device *_device = nullptr; String _name; - GFXFilter _minFilter = GFXFilter::NONE; - GFXFilter _magFilter = GFXFilter::NONE; - GFXFilter _mipFilter = GFXFilter::NONE; - GFXAddress _addressU = GFXAddress::WRAP; - GFXAddress _addressV = GFXAddress::WRAP; - GFXAddress _addressW = GFXAddress::WRAP; + Filter _minFilter = Filter::NONE; + Filter _magFilter = Filter::NONE; + Filter _mipFilter = Filter::NONE; + Address _addressU = Address::WRAP; + Address _addressV = Address::WRAP; + Address _addressW = Address::WRAP; uint _maxAnisotropy = 0; - GFXComparisonFunc _cmpFunc = GFXComparisonFunc::ALWAYS; - GFXColor _borderColor; + ComparisonFunc _cmpFunc = ComparisonFunc::ALWAYS; + Color _borderColor; uint _minLOD = 0; uint _maxLOD = 0; float _mipLODBias = 0.0f; diff --git a/native/cocos/renderer/core/gfx/GFXShader.cc b/native/cocos/renderer/core/gfx/GFXShader.cc index 19e08758e3..848a2d4b1b 100755 --- a/native/cocos/renderer/core/gfx/GFXShader.cc +++ b/native/cocos/renderer/core/gfx/GFXShader.cc @@ -4,11 +4,11 @@ namespace cc { namespace gfx { -GFXShader::GFXShader(GFXDevice *device) -: GFXObject(GFXObjectType::SHADER), _device(device) { +Shader::Shader(Device *device) +: GFXObject(ObjectType::SHADER), _device(device) { } -GFXShader::~GFXShader() { +Shader::~Shader() { } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXShader.h b/native/cocos/renderer/core/gfx/GFXShader.h index fddd549d89..d911c5b51d 100755 --- a/native/cocos/renderer/core/gfx/GFXShader.h +++ b/native/cocos/renderer/core/gfx/GFXShader.h @@ -6,32 +6,32 @@ namespace cc { namespace gfx { -class CC_DLL GFXShader : public GFXObject { +class CC_DLL Shader : public GFXObject { public: - GFXShader(GFXDevice *device); - virtual ~GFXShader(); + Shader(Device *device); + virtual ~Shader(); public: - virtual bool initialize(const GFXShaderInfo &info) = 0; + virtual bool initialize(const ShaderInfo &info) = 0; virtual void destroy() = 0; - CC_INLINE GFXDevice *getDevice() const { return _device; } + CC_INLINE Device *getDevice() const { return _device; } // Can not rename to `id` as JS code, because `id` is a keyword in objective-c. CC_INLINE uint getHash() const { return _hash; } CC_INLINE const String &getName() const { return _name; } - CC_INLINE const GFXShaderStageList &getStages() const { return _stages; } - CC_INLINE const GFXAttributeList &getAttributes() const { return _attributes; } - CC_INLINE const GFXUniformBlockList &getBlocks() const { return _blocks; } - CC_INLINE const GFXUniformSamplerList &getSamplers() const { return _samplers; } + CC_INLINE const ShaderStageList &getStages() const { return _stages; } + CC_INLINE const AttributeList &getAttributes() const { return _attributes; } + CC_INLINE const UniformBlockList &getBlocks() const { return _blocks; } + CC_INLINE const UniformSamplerList &getSamplers() const { return _samplers; } protected: - GFXDevice *_device = nullptr; + Device *_device = nullptr; uint _hash = 0; String _name; - GFXShaderStageList _stages; - GFXAttributeList _attributes; - GFXUniformBlockList _blocks; - GFXUniformSamplerList _samplers; + ShaderStageList _stages; + AttributeList _attributes; + UniformBlockList _blocks; + UniformSamplerList _samplers; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXTexture.cc b/native/cocos/renderer/core/gfx/GFXTexture.cc index 4762787aca..00454e483c 100755 --- a/native/cocos/renderer/core/gfx/GFXTexture.cc +++ b/native/cocos/renderer/core/gfx/GFXTexture.cc @@ -4,11 +4,11 @@ namespace cc { namespace gfx { -GFXTexture::GFXTexture(GFXDevice *device) -: GFXObject(GFXObjectType::TEXTURE), _device(device) { +Texture::Texture(Device *device) +: GFXObject(ObjectType::TEXTURE), _device(device) { } -GFXTexture::~GFXTexture() { +Texture::~Texture() { } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXTexture.h b/native/cocos/renderer/core/gfx/GFXTexture.h index 7a5205bd6c..832724106d 100755 --- a/native/cocos/renderer/core/gfx/GFXTexture.h +++ b/native/cocos/renderer/core/gfx/GFXTexture.h @@ -6,43 +6,43 @@ namespace cc { namespace gfx { -class CC_DLL GFXTexture : public GFXObject { +class CC_DLL Texture : public GFXObject { public: - GFXTexture(GFXDevice *device); - virtual ~GFXTexture(); + Texture(Device *device); + virtual ~Texture(); public: - virtual bool initialize(const GFXTextureInfo &info) = 0; - virtual bool initialize(const GFXTextureViewInfo &info) = 0; + virtual bool initialize(const TextureInfo &info) = 0; + virtual bool initialize(const TextureViewInfo &info) = 0; virtual void destroy() = 0; virtual void resize(uint width, uint height) = 0; - CC_INLINE GFXTextureType getType() const { return _type; } - CC_INLINE GFXTextureUsage getUsage() const { return _usage; } - CC_INLINE GFXFormat getFormat() const { return _format; } + CC_INLINE TextureType getType() const { return _type; } + CC_INLINE TextureUsage getUsage() const { return _usage; } + CC_INLINE Format getFormat() const { return _format; } CC_INLINE uint getWidth() const { return _width; } CC_INLINE uint getHeight() const { return _height; } CC_INLINE uint getDepth() const { return _depth; } CC_INLINE uint getArrayLayer() const { return _arrayLayer; } CC_INLINE uint getMipLevel() const { return _mipLevel; } CC_INLINE uint getSize() const { return _size; } - CC_INLINE GFXSampleCount getSamples() const { return _samples; } - CC_INLINE GFXTextureFlags getFlags() const { return _flags; } + CC_INLINE SampleCount getSamples() const { return _samples; } + CC_INLINE TextureFlags getFlags() const { return _flags; } CC_INLINE uint8_t *getBuffer() const { return _buffer; } protected: - GFXDevice *_device = nullptr; - GFXTextureType _type = GFXTextureType::TEX2D; - GFXTextureUsage _usage = GFXTextureUsageBit::NONE; - GFXFormat _format = GFXFormat::UNKNOWN; + Device *_device = nullptr; + TextureType _type = TextureType::TEX2D; + TextureUsage _usage = TextureUsageBit::NONE; + Format _format = Format::UNKNOWN; uint _width = 0; uint _height = 0; uint _depth = 1; uint _arrayLayer = 1; uint _mipLevel = 1; uint _size = 0; - GFXSampleCount _samples = GFXSampleCount::X1; - GFXTextureFlags _flags = GFXTextureFlagBit::NONE; + SampleCount _samples = SampleCount::X1; + TextureFlags _flags = TextureFlagBit::NONE; uint8_t *_buffer = nullptr; }; diff --git a/native/cocos/renderer/gfx-gles2/GLES2BindingLayout.cc b/native/cocos/renderer/gfx-gles2/GLES2BindingLayout.cc index 6cef283252..820492b80e 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2BindingLayout.cc +++ b/native/cocos/renderer/gfx-gles2/GLES2BindingLayout.cc @@ -8,20 +8,20 @@ namespace cc { namespace gfx { -GLES2BindingLayout::GLES2BindingLayout(GFXDevice *device) -: GFXBindingLayout(device) { +GLES2BindingLayout::GLES2BindingLayout(Device *device) +: BindingLayout(device) { } GLES2BindingLayout::~GLES2BindingLayout() { } -bool GLES2BindingLayout::initialize(const GFXBindingLayoutInfo &info) { +bool GLES2BindingLayout::initialize(const BindingLayoutInfo &info) { if (info.bindings.size()) { _bindingUnits.resize(info.bindings.size()); for (size_t i = 0; i < _bindingUnits.size(); ++i) { - GFXBindingUnit &bindingUnit = _bindingUnits[i]; - const GFXBinding &binding = info.bindings[i]; + BindingUnit &bindingUnit = _bindingUnits[i]; + const Binding &binding = info.bindings[i]; bindingUnit.shaderStages = binding.shaderStages; bindingUnit.binding = binding.binding; bindingUnit.type = binding.type; @@ -33,13 +33,13 @@ bool GLES2BindingLayout::initialize(const GFXBindingLayoutInfo &info) { _gpuBindingLayout->gpuBindings.resize(_bindingUnits.size()); for (size_t i = 0; i < _gpuBindingLayout->gpuBindings.size(); ++i) { GLES2GPUBinding &gpuBinding = _gpuBindingLayout->gpuBindings[i]; - const GFXBindingUnit &bindingUnit = _bindingUnits[i]; + const BindingUnit &bindingUnit = _bindingUnits[i]; gpuBinding.binding = bindingUnit.binding; gpuBinding.type = bindingUnit.type; gpuBinding.name = bindingUnit.name; } - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -49,21 +49,21 @@ void GLES2BindingLayout::destroy() { CC_DELETE(_gpuBindingLayout); _gpuBindingLayout = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void GLES2BindingLayout::update() { if (_isDirty && _gpuBindingLayout) { for (size_t i = 0; i < _bindingUnits.size(); ++i) { - GFXBindingUnit &bindingUnit = _bindingUnits[i]; + BindingUnit &bindingUnit = _bindingUnits[i]; switch (bindingUnit.type) { - case GFXBindingType::UNIFORM_BUFFER: { + case BindingType::UNIFORM_BUFFER: { if (bindingUnit.buffer) { _gpuBindingLayout->gpuBindings[i].gpuBuffer = ((GLES2Buffer *)bindingUnit.buffer)->gpuBuffer(); } break; } - case GFXBindingType::SAMPLER: { + case BindingType::SAMPLER: { if (bindingUnit.texture) { _gpuBindingLayout->gpuBindings[i].gpuTexture = ((GLES2Texture *)bindingUnit.texture)->gpuTexture(); } diff --git a/native/cocos/renderer/gfx-gles2/GLES2BindingLayout.h b/native/cocos/renderer/gfx-gles2/GLES2BindingLayout.h index 9294a05f9f..5e7f6e2fce 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2BindingLayout.h +++ b/native/cocos/renderer/gfx-gles2/GLES2BindingLayout.h @@ -6,13 +6,13 @@ namespace gfx { class GLES2GPUBindingLayout; -class CC_GLES2_API GLES2BindingLayout : public GFXBindingLayout { +class CC_GLES2_API GLES2BindingLayout : public BindingLayout { public: - GLES2BindingLayout(GFXDevice *device); + GLES2BindingLayout(Device *device); ~GLES2BindingLayout(); public: - virtual bool initialize(const GFXBindingLayoutInfo &info) override; + virtual bool initialize(const BindingLayoutInfo &info) override; virtual void destroy() override; virtual void update() override; diff --git a/native/cocos/renderer/gfx-gles2/GLES2Buffer.cc b/native/cocos/renderer/gfx-gles2/GLES2Buffer.cc index 5d381d1884..7675d2fe7b 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Buffer.cc +++ b/native/cocos/renderer/gfx-gles2/GLES2Buffer.cc @@ -5,14 +5,14 @@ namespace cc { namespace gfx { -GLES2Buffer::GLES2Buffer(GFXDevice *device) -: GFXBuffer(device) { +GLES2Buffer::GLES2Buffer(Device *device) +: Buffer(device) { } GLES2Buffer::~GLES2Buffer() { } -bool GLES2Buffer::initialize(const GFXBufferInfo &info) { +bool GLES2Buffer::initialize(const BufferInfo &info) { _usage = info.usage; _memUsage = info.memUsage; @@ -21,10 +21,10 @@ bool GLES2Buffer::initialize(const GFXBufferInfo &info) { _count = _size / _stride; _flags = info.flags; - if ((_flags & GFXBufferFlagBit::BAKUP_BUFFER) && _size > 0) { + if ((_flags & BufferFlagBit::BAKUP_BUFFER) && _size > 0) { _buffer = (uint8_t *)CC_MALLOC(_size); if (!_buffer) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CC_LOG_ERROR("GLES2Buffer: CC_MALLOC backup buffer faild."); return false; } @@ -33,7 +33,7 @@ bool GLES2Buffer::initialize(const GFXBufferInfo &info) { _gpuBuffer = CC_NEW(GLES2GPUBuffer); if (!_gpuBuffer) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CC_LOG_ERROR("GLES2Buffer: CC_NEW GLES2GPUBuffer failed."); return false; } @@ -43,7 +43,7 @@ bool GLES2Buffer::initialize(const GFXBufferInfo &info) { _gpuBuffer->stride = _stride; _gpuBuffer->count = _count; - if (_usage & GFXBufferUsageBit::INDIRECT) { + if (_usage & BufferUsageBit::INDIRECT) { _gpuBuffer->indirects.resize(_count); } else { _gpuBuffer->buffer = _buffer; @@ -52,7 +52,7 @@ bool GLES2Buffer::initialize(const GFXBufferInfo &info) { GLES2CmdFuncCreateBuffer((GLES2Device *)_device, _gpuBuffer); _device->getMemoryStatus().bufferSize += _size; - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -71,7 +71,7 @@ void GLES2Buffer::destroy() { _buffer = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void GLES2Buffer::resize(uint size) { @@ -80,7 +80,7 @@ void GLES2Buffer::resize(uint size) { _size = size; _count = _size / _stride; - GFXMemoryStatus &status = _device->getMemoryStatus(); + MemoryStatus &status = _device->getMemoryStatus(); _gpuBuffer->size = _size; _gpuBuffer->count = _count; GLES2CmdFuncResizeBuffer((GLES2Device *)_device, _gpuBuffer); @@ -91,7 +91,7 @@ void GLES2Buffer::resize(uint size) { const uint8_t *oldBuffer = _buffer; uint8_t *buffer = (uint8_t *)CC_MALLOC(_size); if (!buffer) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CC_LOG_ERROR("GLES2Buffer: CC_MALLOC backup buffer failed."); return; } @@ -101,7 +101,7 @@ void GLES2Buffer::resize(uint size) { status.bufferSize -= oldSize; status.bufferSize += _size; } - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; } } diff --git a/native/cocos/renderer/gfx-gles2/GLES2Buffer.h b/native/cocos/renderer/gfx-gles2/GLES2Buffer.h index 1509f510c4..dcc4caf9c0 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Buffer.h +++ b/native/cocos/renderer/gfx-gles2/GLES2Buffer.h @@ -6,13 +6,13 @@ namespace gfx { class GLES2GPUBuffer; -class CC_GLES2_API GLES2Buffer : public GFXBuffer { +class CC_GLES2_API GLES2Buffer : public Buffer { public: - GLES2Buffer(GFXDevice *device); + GLES2Buffer(Device *device); ~GLES2Buffer(); public: - virtual bool initialize(const GFXBufferInfo &info) override; + virtual bool initialize(const BufferInfo &info) override; virtual void destroy() override; virtual void resize(uint size) override; virtual void update(void *buffer, uint offset, uint size) override; diff --git a/native/cocos/renderer/gfx-gles2/GLES2CommandAllocator.cc b/native/cocos/renderer/gfx-gles2/GLES2CommandAllocator.cc index a8a71357d5..ee92866142 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2CommandAllocator.cc +++ b/native/cocos/renderer/gfx-gles2/GLES2CommandAllocator.cc @@ -4,20 +4,20 @@ namespace cc { namespace gfx { -GLES2CommandAllocator::GLES2CommandAllocator(GFXDevice *device) -: GFXCommandAllocator(device) { +GLES2CommandAllocator::GLES2CommandAllocator(Device *device) +: CommandAllocator(device) { } GLES2CommandAllocator::~GLES2CommandAllocator() { } -bool GLES2CommandAllocator::initialize(const GFXCommandAllocatorInfo &info) { - _status = GFXStatus::SUCCESS; +bool GLES2CommandAllocator::initialize(const CommandAllocatorInfo &info) { + _status = Status::SUCCESS; return true; } void GLES2CommandAllocator::destroy() { - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void GLES2CommandAllocator::clearCmds(GLES2CmdPackage *cmd_package) { diff --git a/native/cocos/renderer/gfx-gles2/GLES2CommandAllocator.h b/native/cocos/renderer/gfx-gles2/GLES2CommandAllocator.h index 75b863a041..0359f5ac8f 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2CommandAllocator.h +++ b/native/cocos/renderer/gfx-gles2/GLES2CommandAllocator.h @@ -7,19 +7,19 @@ namespace cc { namespace gfx { -class CC_GLES2_API GLES2CommandAllocator : public GFXCommandAllocator { +class CC_GLES2_API GLES2CommandAllocator : public CommandAllocator { public: - GLES2CommandAllocator(GFXDevice *device); + GLES2CommandAllocator(Device *device); ~GLES2CommandAllocator(); - GFXCommandPool beginRenderPassCmdPool; - GFXCommandPool bindStatesCmdPool; - GFXCommandPool drawCmdPool; - GFXCommandPool updateBufferCmdPool; - GFXCommandPool copyBufferToTextureCmdPool; + CommandPool beginRenderPassCmdPool; + CommandPool bindStatesCmdPool; + CommandPool drawCmdPool; + CommandPool updateBufferCmdPool; + CommandPool copyBufferToTextureCmdPool; public: - virtual bool initialize(const GFXCommandAllocatorInfo &info) override; + virtual bool initialize(const CommandAllocatorInfo &info) override; virtual void destroy() override; void clearCmds(GLES2CmdPackage *cmd_package); diff --git a/native/cocos/renderer/gfx-gles2/GLES2CommandBuffer.cc b/native/cocos/renderer/gfx-gles2/GLES2CommandBuffer.cc index 2e0d771e11..7cd7755a63 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2CommandBuffer.cc +++ b/native/cocos/renderer/gfx-gles2/GLES2CommandBuffer.cc @@ -11,14 +11,14 @@ namespace cc { namespace gfx { -GLES2CommandBuffer::GLES2CommandBuffer(GFXDevice *device) -: GFXCommandBuffer(device) { +GLES2CommandBuffer::GLES2CommandBuffer(Device *device) +: CommandBuffer(device) { } GLES2CommandBuffer::~GLES2CommandBuffer() { } -bool GLES2CommandBuffer::initialize(const GFXCommandBufferInfo &info) { +bool GLES2CommandBuffer::initialize(const CommandBufferInfo &info) { if (!info.allocator) { return false; @@ -29,7 +29,7 @@ bool GLES2CommandBuffer::initialize(const GFXCommandBufferInfo &info) { _type = info.type; _cmdPackage = CC_NEW(GLES2CmdPackage); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -40,12 +40,12 @@ void GLES2CommandBuffer::destroy() { _gles2Allocator = nullptr; } _allocator = nullptr; - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; CC_SAFE_DELETE(_cmdPackage); } -void GLES2CommandBuffer::begin(GFXRenderPass *renderPass, uint subpass, GFXFramebuffer *frameBuffer) { +void GLES2CommandBuffer::begin(RenderPass *renderPass, uint subpass, Framebuffer *frameBuffer) { _gles2Allocator->clearCmds(_cmdPackage); _curGPUPipelineState = nullptr; _curGPUBlendLayout = nullptr; @@ -62,7 +62,7 @@ void GLES2CommandBuffer::end() { _isInRenderPass = false; } -void GLES2CommandBuffer::beginRenderPass(GFXFramebuffer *fbo, const GFXRect &render_area, GFXClearFlags clear_flags, const std::vector &colors, float depth, int stencil) { +void GLES2CommandBuffer::beginRenderPass(Framebuffer *fbo, const Rect &render_area, ClearFlags clear_flags, const std::vector &colors, float depth, int stencil) { _isInRenderPass = true; GLES2CmdBeginRenderPass *cmd = _gles2Allocator->beginRenderPassCmdPool.alloc(); @@ -84,22 +84,22 @@ void GLES2CommandBuffer::endRenderPass() { _cmdPackage->cmds.push(GFXCmdType::END_RENDER_PASS); } -void GLES2CommandBuffer::bindPipelineState(GFXPipelineState *pso) { +void GLES2CommandBuffer::bindPipelineState(PipelineState *pso) { _curGPUPipelineState = ((GLES2PipelineState *)pso)->gpuPipelineState(); _isStateInvalid = true; } -void GLES2CommandBuffer::bindBindingLayout(GFXBindingLayout *layout) { +void GLES2CommandBuffer::bindBindingLayout(BindingLayout *layout) { _curGPUBlendLayout = ((GLES2BindingLayout *)layout)->gpuBindingLayout(); _isStateInvalid = true; } -void GLES2CommandBuffer::bindInputAssembler(GFXInputAssembler *ia) { +void GLES2CommandBuffer::bindInputAssembler(InputAssembler *ia) { _curGPUInputAssember = ((GLES2InputAssembler *)ia)->gpuInputAssembler(); _isStateInvalid = true; } -void GLES2CommandBuffer::setViewport(const GFXViewport &vp) { +void GLES2CommandBuffer::setViewport(const Viewport &vp) { if ((_curViewport.left != vp.left) || (_curViewport.top != vp.top) || @@ -112,7 +112,7 @@ void GLES2CommandBuffer::setViewport(const GFXViewport &vp) { } } -void GLES2CommandBuffer::setScissor(const GFXRect &rect) { +void GLES2CommandBuffer::setScissor(const Rect &rect) { if ((_curScissor.x != rect.x) || (_curScissor.y != rect.y) || (_curScissor.width != rect.width) || @@ -140,7 +140,7 @@ void GLES2CommandBuffer::setDepthBias(float constant, float clamp, float slope) } } -void GLES2CommandBuffer::setBlendConstants(const GFXColor &constants) { +void GLES2CommandBuffer::setBlendConstants(const Color &constants) { if (math::IsNotEqualF(_curBlendConstants.r, constants.r) || math::IsNotEqualF(_curBlendConstants.g, constants.g) || math::IsNotEqualF(_curBlendConstants.b, constants.b) || @@ -162,7 +162,7 @@ void GLES2CommandBuffer::setDepthBound(float min_bounds, float max_bounds) { } } -void GLES2CommandBuffer::setStencilWriteMask(GFXStencilFace face, uint mask) { +void GLES2CommandBuffer::setStencilWriteMask(StencilFace face, uint mask) { if ((_curStencilWriteMask.face != face) || (_curStencilWriteMask.write_mask != mask)) { _curStencilWriteMask.face = face; @@ -171,7 +171,7 @@ void GLES2CommandBuffer::setStencilWriteMask(GFXStencilFace face, uint mask) { } } -void GLES2CommandBuffer::setStencilCompareMask(GFXStencilFace face, int ref, uint mask) { +void GLES2CommandBuffer::setStencilCompareMask(StencilFace face, int ref, uint mask) { if ((_curStencilCompareMask.face != face) || (_curStencilCompareMask.refrence != ref) || (_curStencilCompareMask.compare_mask != mask)) { @@ -182,9 +182,9 @@ void GLES2CommandBuffer::setStencilCompareMask(GFXStencilFace face, int ref, uin } } -void GLES2CommandBuffer::draw(GFXInputAssembler *ia) { - if ((_type == GFXCommandBufferType::PRIMARY && _isInRenderPass) || - (_type == GFXCommandBufferType::SECONDARY)) { +void GLES2CommandBuffer::draw(InputAssembler *ia) { + if ((_type == CommandBufferType::PRIMARY && _isInRenderPass) || + (_type == CommandBufferType::SECONDARY)) { if (_isStateInvalid) { BindStates(); } @@ -220,9 +220,9 @@ void GLES2CommandBuffer::draw(GFXInputAssembler *ia) { } } -void GLES2CommandBuffer::updateBuffer(GFXBuffer *buff, void *data, uint size, uint offset) { - if ((_type == GFXCommandBufferType::PRIMARY && !_isInRenderPass) || - (_type == GFXCommandBufferType::SECONDARY)) { +void GLES2CommandBuffer::updateBuffer(Buffer *buff, void *data, uint size, uint offset) { + if ((_type == CommandBufferType::PRIMARY && !_isInRenderPass) || + (_type == CommandBufferType::SECONDARY)) { GLES2GPUBuffer *gpuBuffer = ((GLES2Buffer *)buff)->gpuBuffer(); if (gpuBuffer) { GLES2CmdUpdateBuffer *cmd = _gles2Allocator->updateBufferCmdPool.alloc(); @@ -239,9 +239,9 @@ void GLES2CommandBuffer::updateBuffer(GFXBuffer *buff, void *data, uint size, ui } } -void GLES2CommandBuffer::copyBufferToTexture(GFXBuffer *src, GFXTexture *dst, GFXTextureLayout layout, const GFXBufferTextureCopyList ®ions) { - if ((_type == GFXCommandBufferType::PRIMARY && !_isInRenderPass) || - (_type == GFXCommandBufferType::SECONDARY)) { +void GLES2CommandBuffer::copyBufferToTexture(Buffer *src, Texture *dst, TextureLayout layout, const BufferTextureCopyList ®ions) { + if ((_type == CommandBufferType::PRIMARY && !_isInRenderPass) || + (_type == CommandBufferType::SECONDARY)) { GLES2GPUBuffer *gpuBuffer = ((GLES2Buffer *)src)->gpuBuffer(); GLES2GPUTexture *gpuTexture = ((GLES2Texture *)dst)->gpuTexture(); if (gpuBuffer && gpuTexture) { @@ -262,7 +262,7 @@ void GLES2CommandBuffer::copyBufferToTexture(GFXBuffer *src, GFXTexture *dst, GF } } -void GLES2CommandBuffer::execute(const std::vector &cmd_buffs, uint32_t count) { +void GLES2CommandBuffer::execute(const std::vector &cmd_buffs, uint32_t count) { for (uint i = 0; i < count; ++i) { GLES2CommandBuffer *cmd_buff = (GLES2CommandBuffer *)cmd_buffs[i]; diff --git a/native/cocos/renderer/gfx-gles2/GLES2CommandBuffer.h b/native/cocos/renderer/gfx-gles2/GLES2CommandBuffer.h index 697512b19d..3364e752a9 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2CommandBuffer.h +++ b/native/cocos/renderer/gfx-gles2/GLES2CommandBuffer.h @@ -8,36 +8,36 @@ namespace gfx { class GLES2CommandAllocator; -class CC_GLES2_API GLES2CommandBuffer : public GFXCommandBuffer { +class CC_GLES2_API GLES2CommandBuffer : public CommandBuffer { public: - GLES2CommandBuffer(GFXDevice *device); + GLES2CommandBuffer(Device *device); ~GLES2CommandBuffer(); friend class GLES2Queue; public: - virtual bool initialize(const GFXCommandBufferInfo &info) override; + virtual bool initialize(const CommandBufferInfo &info) override; virtual void destroy() override; - virtual void begin(GFXRenderPass *renderPass = nullptr, uint subpass = 0, GFXFramebuffer *frameBuffer = nullptr) override; + virtual void begin(RenderPass *renderPass = nullptr, uint subpass = 0, Framebuffer *frameBuffer = nullptr) override; virtual void end() override; - virtual void beginRenderPass(GFXFramebuffer *fbo, const GFXRect &render_area, GFXClearFlags clear_flags, const std::vector &colors, float depth, int stencil) override; + virtual void beginRenderPass(Framebuffer *fbo, const Rect &render_area, ClearFlags clear_flags, const std::vector &colors, float depth, int stencil) override; virtual void endRenderPass() override; - virtual void bindPipelineState(GFXPipelineState *pso) override; - virtual void bindBindingLayout(GFXBindingLayout *layout) override; - virtual void bindInputAssembler(GFXInputAssembler *ia) override; - virtual void setViewport(const GFXViewport &vp) override; - virtual void setScissor(const GFXRect &rect) override; + virtual void bindPipelineState(PipelineState *pso) override; + virtual void bindBindingLayout(BindingLayout *layout) override; + virtual void bindInputAssembler(InputAssembler *ia) override; + virtual void setViewport(const Viewport &vp) override; + virtual void setScissor(const Rect &rect) override; virtual void setLineWidth(const float width) override; virtual void setDepthBias(float constant, float clamp, float slope) override; - virtual void setBlendConstants(const GFXColor &constants) override; + virtual void setBlendConstants(const Color &constants) override; virtual void setDepthBound(float min_bounds, float max_bounds) override; - virtual void setStencilWriteMask(GFXStencilFace face, uint mask) override; - virtual void setStencilCompareMask(GFXStencilFace face, int ref, uint mask) override; - virtual void draw(GFXInputAssembler *ia) override; - virtual void updateBuffer(GFXBuffer *buff, void *data, uint size, uint offset) override; - virtual void copyBufferToTexture(GFXBuffer *src, GFXTexture *dst, GFXTextureLayout layout, const GFXBufferTextureCopyList ®ions) override; - virtual void execute(const std::vector &cmd_buffs, uint32_t count) override; + virtual void setStencilWriteMask(StencilFace face, uint mask) override; + virtual void setStencilCompareMask(StencilFace face, int ref, uint mask) override; + virtual void draw(InputAssembler *ia) override; + virtual void updateBuffer(Buffer *buff, void *data, uint size, uint offset) override; + virtual void copyBufferToTexture(Buffer *src, Texture *dst, TextureLayout layout, const BufferTextureCopyList ®ions) override; + virtual void execute(const std::vector &cmd_buffs, uint32_t count) override; private: void BindStates(); @@ -49,11 +49,11 @@ private: GLES2GPUPipelineState *_curGPUPipelineState = nullptr; GLES2GPUBindingLayout *_curGPUBlendLayout = nullptr; GLES2GPUInputAssembler *_curGPUInputAssember = nullptr; - GFXViewport _curViewport; - GFXRect _curScissor; + Viewport _curViewport; + Rect _curScissor; float _curLineWidth = 1.0f; GLES2DepthBias _curDepthBias; - GFXColor _curBlendConstants; + Color _curBlendConstants; GLES2DepthBounds _curDepthBounds; GLES2StencilWriteMask _curStencilWriteMask; GLES2StencilCompareMask _curStencilCompareMask; diff --git a/native/cocos/renderer/gfx-gles2/GLES2Commands.cc b/native/cocos/renderer/gfx-gles2/GLES2Commands.cc index 91e758e5f9..9c01106491 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Commands.cc +++ b/native/cocos/renderer/gfx-gles2/GLES2Commands.cc @@ -10,192 +10,192 @@ namespace cc { namespace gfx { namespace { -GLenum MapGLInternalFormat(GFXFormat format) { +GLenum MapGLInternalFormat(Format format) { switch (format) { - case GFXFormat::A8: return GL_ALPHA; - case GFXFormat::L8: return GL_LUMINANCE; - case GFXFormat::LA8: return GL_LUMINANCE_ALPHA; - case GFXFormat::R8: return GL_LUMINANCE; - case GFXFormat::R8SN: return GL_LUMINANCE; - case GFXFormat::R8UI: return GL_LUMINANCE; - case GFXFormat::R8I: return GL_LUMINANCE; - case GFXFormat::RG8: return GL_LUMINANCE_ALPHA; - case GFXFormat::RG8SN: return GL_LUMINANCE_ALPHA; - case GFXFormat::RG8UI: return GL_LUMINANCE_ALPHA; - case GFXFormat::RG8I: return GL_LUMINANCE_ALPHA; - case GFXFormat::RGB8: return GL_RGB; - case GFXFormat::RGB8SN: return GL_RGB; - case GFXFormat::RGB8UI: return GL_RGB; - case GFXFormat::RGB8I: return GL_RGB; - case GFXFormat::RGBA8: return GL_RGBA; - case GFXFormat::RGBA8SN: return GL_RGBA; - case GFXFormat::RGBA8UI: return GL_RGBA; - case GFXFormat::RGBA8I: return GL_RGBA; - case GFXFormat::R16I: return GL_LUMINANCE; - case GFXFormat::R16UI: return GL_LUMINANCE; - case GFXFormat::R16F: return GL_LUMINANCE; - case GFXFormat::RG16I: return GL_LUMINANCE_ALPHA; - case GFXFormat::RG16UI: return GL_LUMINANCE_ALPHA; - case GFXFormat::RG16F: return GL_LUMINANCE_ALPHA; - case GFXFormat::RGB16I: return GL_RGB; - case GFXFormat::RGB16UI: return GL_RGB; - case GFXFormat::RGB16F: return GL_RGB; - case GFXFormat::RGBA16I: return GL_RGBA; - case GFXFormat::RGBA16UI: return GL_RGBA; - case GFXFormat::RGBA16F: return GL_RGBA; - case GFXFormat::R32I: return GL_LUMINANCE; - case GFXFormat::R32UI: return GL_LUMINANCE; - case GFXFormat::R32F: return GL_LUMINANCE; - case GFXFormat::RG32I: return GL_LUMINANCE_ALPHA; - case GFXFormat::RG32UI: return GL_LUMINANCE_ALPHA; - case GFXFormat::RG32F: return GL_LUMINANCE_ALPHA; - case GFXFormat::RGB32I: return GL_RGB; - case GFXFormat::RGB32UI: return GL_RGB; - case GFXFormat::RGB32F: return GL_RGB; - case GFXFormat::RGBA32I: return GL_RGBA; - case GFXFormat::RGBA32UI: return GL_RGBA; + case Format::A8: return GL_ALPHA; + case Format::L8: return GL_LUMINANCE; + case Format::LA8: return GL_LUMINANCE_ALPHA; + case Format::R8: return GL_LUMINANCE; + case Format::R8SN: return GL_LUMINANCE; + case Format::R8UI: return GL_LUMINANCE; + case Format::R8I: return GL_LUMINANCE; + case Format::RG8: return GL_LUMINANCE_ALPHA; + case Format::RG8SN: return GL_LUMINANCE_ALPHA; + case Format::RG8UI: return GL_LUMINANCE_ALPHA; + case Format::RG8I: return GL_LUMINANCE_ALPHA; + case Format::RGB8: return GL_RGB; + case Format::RGB8SN: return GL_RGB; + case Format::RGB8UI: return GL_RGB; + case Format::RGB8I: return GL_RGB; + case Format::RGBA8: return GL_RGBA; + case Format::RGBA8SN: return GL_RGBA; + case Format::RGBA8UI: return GL_RGBA; + case Format::RGBA8I: return GL_RGBA; + case Format::R16I: return GL_LUMINANCE; + case Format::R16UI: return GL_LUMINANCE; + case Format::R16F: return GL_LUMINANCE; + case Format::RG16I: return GL_LUMINANCE_ALPHA; + case Format::RG16UI: return GL_LUMINANCE_ALPHA; + case Format::RG16F: return GL_LUMINANCE_ALPHA; + case Format::RGB16I: return GL_RGB; + case Format::RGB16UI: return GL_RGB; + case Format::RGB16F: return GL_RGB; + case Format::RGBA16I: return GL_RGBA; + case Format::RGBA16UI: return GL_RGBA; + case Format::RGBA16F: return GL_RGBA; + case Format::R32I: return GL_LUMINANCE; + case Format::R32UI: return GL_LUMINANCE; + case Format::R32F: return GL_LUMINANCE; + case Format::RG32I: return GL_LUMINANCE_ALPHA; + case Format::RG32UI: return GL_LUMINANCE_ALPHA; + case Format::RG32F: return GL_LUMINANCE_ALPHA; + case Format::RGB32I: return GL_RGB; + case Format::RGB32UI: return GL_RGB; + case Format::RGB32F: return GL_RGB; + case Format::RGBA32I: return GL_RGBA; + case Format::RGBA32UI: return GL_RGBA; #if CC_PLATFORM == CC_PLATFORM_WINDOWS - case GFXFormat::RGBA32F: return GL_RGBA32F_EXT; // driver issue + case Format::RGBA32F: return GL_RGBA32F_EXT; // driver issue #else - case GFXFormat::RGBA32F: return GL_RGBA; + case Format::RGBA32F: return GL_RGBA; #endif - case GFXFormat::R5G6B5: return GL_RGB565; - case GFXFormat::RGB5A1: return GL_RGB5_A1; - case GFXFormat::RGBA4: return GL_RGBA4; - case GFXFormat::RGB10A2: return GL_RGB; - case GFXFormat::RGB10A2UI: return GL_RGB; - case GFXFormat::R11G11B10F: return GL_RGB; - case GFXFormat::D16: return GL_DEPTH_COMPONENT; - case GFXFormat::D16S8: return GL_DEPTH_STENCIL_OES; - case GFXFormat::D24: return GL_DEPTH_COMPONENT; - case GFXFormat::D24S8: return GL_DEPTH_STENCIL_OES; - case GFXFormat::D32F: return GL_DEPTH_COMPONENT; - case GFXFormat::D32F_S8: return GL_DEPTH_STENCIL_OES; + case Format::R5G6B5: return GL_RGB565; + case Format::RGB5A1: return GL_RGB5_A1; + case Format::RGBA4: return GL_RGBA4; + case Format::RGB10A2: return GL_RGB; + case Format::RGB10A2UI: return GL_RGB; + case Format::R11G11B10F: return GL_RGB; + case Format::D16: return GL_DEPTH_COMPONENT; + case Format::D16S8: return GL_DEPTH_STENCIL_OES; + case Format::D24: return GL_DEPTH_COMPONENT; + case Format::D24S8: return GL_DEPTH_STENCIL_OES; + case Format::D32F: return GL_DEPTH_COMPONENT; + case Format::D32F_S8: return GL_DEPTH_STENCIL_OES; - case GFXFormat::BC1: return GL_COMPRESSED_RGB_S3TC_DXT1_EXT; - case GFXFormat::BC1_ALPHA: return GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; - case GFXFormat::BC1_SRGB: return GL_COMPRESSED_SRGB_S3TC_DXT1_EXT; - case GFXFormat::BC1_SRGB_ALPHA: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT; - case GFXFormat::BC2: return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; - case GFXFormat::BC2_SRGB: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT; - case GFXFormat::BC3: return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; - case GFXFormat::BC3_SRGB: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT; + case Format::BC1: return GL_COMPRESSED_RGB_S3TC_DXT1_EXT; + case Format::BC1_ALPHA: return GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; + case Format::BC1_SRGB: return GL_COMPRESSED_SRGB_S3TC_DXT1_EXT; + case Format::BC1_SRGB_ALPHA: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT; + case Format::BC2: return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; + case Format::BC2_SRGB: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT; + case Format::BC3: return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; + case Format::BC3_SRGB: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT; - case GFXFormat::ETC_RGB8: return GL_ETC1_RGB8_OES; + case Format::ETC_RGB8: return GL_ETC1_RGB8_OES; - case GFXFormat::PVRTC_RGB2: return GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG; - case GFXFormat::PVRTC_RGBA2: return GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG; - case GFXFormat::PVRTC_RGB4: return GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; - case GFXFormat::PVRTC_RGBA4: return GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; + case Format::PVRTC_RGB2: return GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG; + case Format::PVRTC_RGBA2: return GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG; + case Format::PVRTC_RGB4: return GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; + case Format::PVRTC_RGBA4: return GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; default: { - CCASSERT(false, "Unsupported GFXFormat, convert to GL internal format failed."); + CCASSERT(false, "Unsupported Format, convert to GL internal format failed."); return GL_RGBA; } } } -GLenum MapGLFormat(GFXFormat format) { +GLenum MapGLFormat(Format format) { switch (format) { - case GFXFormat::A8: return GL_ALPHA; - case GFXFormat::L8: return GL_LUMINANCE; - case GFXFormat::LA8: return GL_LUMINANCE_ALPHA; - case GFXFormat::R8: - case GFXFormat::R8SN: - case GFXFormat::R8UI: - case GFXFormat::R8I: return GL_LUMINANCE; - case GFXFormat::RG8: - case GFXFormat::RG8SN: - case GFXFormat::RG8UI: - case GFXFormat::RG8I: return GL_LUMINANCE_ALPHA; - case GFXFormat::RGB8: - case GFXFormat::RGB8SN: - case GFXFormat::RGB8UI: - case GFXFormat::RGB8I: return GL_RGB; - case GFXFormat::RGBA8: - case GFXFormat::RGBA8SN: - case GFXFormat::RGBA8UI: - case GFXFormat::RGBA8I: return GL_RGBA; - case GFXFormat::R16UI: - case GFXFormat::R16I: - case GFXFormat::R16F: return GL_LUMINANCE; - case GFXFormat::RG16UI: - case GFXFormat::RG16I: - case GFXFormat::RG16F: return GL_LUMINANCE_ALPHA; - case GFXFormat::RGB16UI: - case GFXFormat::RGB16I: - case GFXFormat::RGB16F: return GL_RGB; - case GFXFormat::RGBA16UI: - case GFXFormat::RGBA16I: - case GFXFormat::RGBA16F: return GL_RGBA; - case GFXFormat::R32UI: - case GFXFormat::R32I: - case GFXFormat::R32F: return GL_LUMINANCE; - case GFXFormat::RG32UI: - case GFXFormat::RG32I: - case GFXFormat::RG32F: return GL_LUMINANCE_ALPHA; - case GFXFormat::RGB32UI: - case GFXFormat::RGB32I: - case GFXFormat::RGB32F: return GL_RGB; - case GFXFormat::RGBA32UI: - case GFXFormat::RGBA32I: - case GFXFormat::RGBA32F: return GL_RGBA; - case GFXFormat::RGB10A2: return GL_RGBA; - case GFXFormat::R11G11B10F: return GL_RGB; - case GFXFormat::R5G6B5: return GL_RGB; - case GFXFormat::RGB5A1: return GL_RGBA; - case GFXFormat::RGBA4: return GL_RGBA; - case GFXFormat::D16: return GL_DEPTH_COMPONENT; - case GFXFormat::D16S8: return GL_DEPTH_STENCIL_OES; - case GFXFormat::D24: return GL_DEPTH_COMPONENT; - case GFXFormat::D24S8: return GL_DEPTH_STENCIL_OES; - case GFXFormat::D32F: return GL_DEPTH_COMPONENT; - case GFXFormat::D32F_S8: return GL_DEPTH_STENCIL_OES; + case Format::A8: return GL_ALPHA; + case Format::L8: return GL_LUMINANCE; + case Format::LA8: return GL_LUMINANCE_ALPHA; + case Format::R8: + case Format::R8SN: + case Format::R8UI: + case Format::R8I: return GL_LUMINANCE; + case Format::RG8: + case Format::RG8SN: + case Format::RG8UI: + case Format::RG8I: return GL_LUMINANCE_ALPHA; + case Format::RGB8: + case Format::RGB8SN: + case Format::RGB8UI: + case Format::RGB8I: return GL_RGB; + case Format::RGBA8: + case Format::RGBA8SN: + case Format::RGBA8UI: + case Format::RGBA8I: return GL_RGBA; + case Format::R16UI: + case Format::R16I: + case Format::R16F: return GL_LUMINANCE; + case Format::RG16UI: + case Format::RG16I: + case Format::RG16F: return GL_LUMINANCE_ALPHA; + case Format::RGB16UI: + case Format::RGB16I: + case Format::RGB16F: return GL_RGB; + case Format::RGBA16UI: + case Format::RGBA16I: + case Format::RGBA16F: return GL_RGBA; + case Format::R32UI: + case Format::R32I: + case Format::R32F: return GL_LUMINANCE; + case Format::RG32UI: + case Format::RG32I: + case Format::RG32F: return GL_LUMINANCE_ALPHA; + case Format::RGB32UI: + case Format::RGB32I: + case Format::RGB32F: return GL_RGB; + case Format::RGBA32UI: + case Format::RGBA32I: + case Format::RGBA32F: return GL_RGBA; + case Format::RGB10A2: return GL_RGBA; + case Format::R11G11B10F: return GL_RGB; + case Format::R5G6B5: return GL_RGB; + case Format::RGB5A1: return GL_RGBA; + case Format::RGBA4: return GL_RGBA; + case Format::D16: return GL_DEPTH_COMPONENT; + case Format::D16S8: return GL_DEPTH_STENCIL_OES; + case Format::D24: return GL_DEPTH_COMPONENT; + case Format::D24S8: return GL_DEPTH_STENCIL_OES; + case Format::D32F: return GL_DEPTH_COMPONENT; + case Format::D32F_S8: return GL_DEPTH_STENCIL_OES; - case GFXFormat::BC1: return GL_COMPRESSED_RGB_S3TC_DXT1_EXT; - case GFXFormat::BC1_ALPHA: return GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; - case GFXFormat::BC1_SRGB: return GL_COMPRESSED_SRGB_S3TC_DXT1_EXT; - case GFXFormat::BC1_SRGB_ALPHA: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT; - case GFXFormat::BC2: return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; - case GFXFormat::BC2_SRGB: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT; - case GFXFormat::BC3: return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; - case GFXFormat::BC3_SRGB: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT; + case Format::BC1: return GL_COMPRESSED_RGB_S3TC_DXT1_EXT; + case Format::BC1_ALPHA: return GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; + case Format::BC1_SRGB: return GL_COMPRESSED_SRGB_S3TC_DXT1_EXT; + case Format::BC1_SRGB_ALPHA: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT; + case Format::BC2: return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; + case Format::BC2_SRGB: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT; + case Format::BC3: return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; + case Format::BC3_SRGB: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT; - case GFXFormat::ETC_RGB8: return GL_ETC1_RGB8_OES; + case Format::ETC_RGB8: return GL_ETC1_RGB8_OES; - case GFXFormat::PVRTC_RGB2: return GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG; - case GFXFormat::PVRTC_RGBA2: return GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG; - case GFXFormat::PVRTC_RGB4: return GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; - case GFXFormat::PVRTC_RGBA4: return GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; + case Format::PVRTC_RGB2: return GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG; + case Format::PVRTC_RGBA2: return GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG; + case Format::PVRTC_RGB4: return GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; + case Format::PVRTC_RGBA4: return GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; default: { - CCASSERT(false, "Unsupported GFXFormat, convert to WebGL format failed."); + CCASSERT(false, "Unsupported Format, convert to WebGL format failed."); return GL_RGBA; } } } -GLenum MapGLType(GFXType type) { +GLenum MapGLType(Type type) { switch (type) { - case GFXType::BOOL: return GL_BOOL; - case GFXType::BOOL2: return GL_BOOL_VEC2; - case GFXType::BOOL3: return GL_BOOL_VEC3; - case GFXType::BOOL4: return GL_BOOL_VEC4; - case GFXType::INT: return GL_INT; - case GFXType::INT2: return GL_INT_VEC2; - case GFXType::INT3: return GL_INT_VEC3; - case GFXType::INT4: return GL_INT_VEC4; - case GFXType::UINT: return GL_UNSIGNED_INT; - case GFXType::FLOAT: return GL_FLOAT; - case GFXType::FLOAT2: return GL_FLOAT_VEC2; - case GFXType::FLOAT3: return GL_FLOAT_VEC3; - case GFXType::FLOAT4: return GL_FLOAT_VEC4; - case GFXType::MAT2: return GL_FLOAT_MAT2; - case GFXType::MAT3: return GL_FLOAT_MAT3; - case GFXType::MAT4: return GL_FLOAT_MAT4; - case GFXType::SAMPLER2D: return GL_SAMPLER_2D; - case GFXType::SAMPLER3D: return GL_SAMPLER_3D_OES; - case GFXType::SAMPLER_CUBE: return GL_SAMPLER_CUBE; + case Type::BOOL: return GL_BOOL; + case Type::BOOL2: return GL_BOOL_VEC2; + case Type::BOOL3: return GL_BOOL_VEC3; + case Type::BOOL4: return GL_BOOL_VEC4; + case Type::INT: return GL_INT; + case Type::INT2: return GL_INT_VEC2; + case Type::INT3: return GL_INT_VEC3; + case Type::INT4: return GL_INT_VEC4; + case Type::UINT: return GL_UNSIGNED_INT; + case Type::FLOAT: return GL_FLOAT; + case Type::FLOAT2: return GL_FLOAT_VEC2; + case Type::FLOAT3: return GL_FLOAT_VEC3; + case Type::FLOAT4: return GL_FLOAT_VEC4; + case Type::MAT2: return GL_FLOAT_MAT2; + case Type::MAT3: return GL_FLOAT_MAT3; + case Type::MAT4: return GL_FLOAT_MAT4; + case Type::SAMPLER2D: return GL_SAMPLER_2D; + case Type::SAMPLER3D: return GL_SAMPLER_3D_OES; + case Type::SAMPLER_CUBE: return GL_SAMPLER_CUBE; default: { CCASSERT(false, "Unsupported GLType, convert to GL type failed."); return GL_NONE; @@ -203,126 +203,126 @@ GLenum MapGLType(GFXType type) { } } -GFXType MapGFXType(GLenum glType) { +Type MapType(GLenum glType) { switch (glType) { - case GL_BOOL: return GFXType::BOOL; - case GL_BOOL_VEC2: return GFXType::BOOL2; - case GL_BOOL_VEC3: return GFXType::BOOL3; - case GL_BOOL_VEC4: return GFXType::BOOL4; - case GL_INT: return GFXType::INT; - case GL_INT_VEC2: return GFXType::INT2; - case GL_INT_VEC3: return GFXType::INT3; - case GL_INT_VEC4: return GFXType::INT4; - case GL_UNSIGNED_INT: return GFXType::UINT; - case GL_FLOAT: return GFXType::FLOAT; - case GL_FLOAT_VEC2: return GFXType::FLOAT2; - case GL_FLOAT_VEC3: return GFXType::FLOAT3; - case GL_FLOAT_VEC4: return GFXType::FLOAT4; - case GL_FLOAT_MAT2: return GFXType::MAT2; - case GL_FLOAT_MAT3: return GFXType::MAT3; - case GL_FLOAT_MAT4: return GFXType::MAT4; - case GL_SAMPLER_2D: return GFXType::SAMPLER2D; - case GL_SAMPLER_3D_OES: return GFXType::SAMPLER3D; - case GL_SAMPLER_CUBE: return GFXType::SAMPLER_CUBE; + case GL_BOOL: return Type::BOOL; + case GL_BOOL_VEC2: return Type::BOOL2; + case GL_BOOL_VEC3: return Type::BOOL3; + case GL_BOOL_VEC4: return Type::BOOL4; + case GL_INT: return Type::INT; + case GL_INT_VEC2: return Type::INT2; + case GL_INT_VEC3: return Type::INT3; + case GL_INT_VEC4: return Type::INT4; + case GL_UNSIGNED_INT: return Type::UINT; + case GL_FLOAT: return Type::FLOAT; + case GL_FLOAT_VEC2: return Type::FLOAT2; + case GL_FLOAT_VEC3: return Type::FLOAT3; + case GL_FLOAT_VEC4: return Type::FLOAT4; + case GL_FLOAT_MAT2: return Type::MAT2; + case GL_FLOAT_MAT3: return Type::MAT3; + case GL_FLOAT_MAT4: return Type::MAT4; + case GL_SAMPLER_2D: return Type::SAMPLER2D; + case GL_SAMPLER_3D_OES: return Type::SAMPLER3D; + case GL_SAMPLER_CUBE: return Type::SAMPLER_CUBE; default: { - CCASSERT(false, "Unsupported GLType, convert to GFXType failed."); - return GFXType::UNKNOWN; + CCASSERT(false, "Unsupported GLType, convert to Type failed."); + return Type::UNKNOWN; } } } -GLenum GFXFormatToGLType(GFXFormat format) { +GLenum FormatToGLType(Format format) { switch (format) { - case GFXFormat::R8: return GL_UNSIGNED_BYTE; - case GFXFormat::R8SN: return GL_BYTE; - case GFXFormat::R8UI: return GL_UNSIGNED_BYTE; - case GFXFormat::R8I: return GL_BYTE; - case GFXFormat::R16UI: return GL_UNSIGNED_SHORT; - case GFXFormat::R16I: return GL_SHORT; - case GFXFormat::R32F: return GL_FLOAT; - case GFXFormat::R32UI: return GL_UNSIGNED_INT; - case GFXFormat::R32I: return GL_INT; + case Format::R8: return GL_UNSIGNED_BYTE; + case Format::R8SN: return GL_BYTE; + case Format::R8UI: return GL_UNSIGNED_BYTE; + case Format::R8I: return GL_BYTE; + case Format::R16UI: return GL_UNSIGNED_SHORT; + case Format::R16I: return GL_SHORT; + case Format::R32F: return GL_FLOAT; + case Format::R32UI: return GL_UNSIGNED_INT; + case Format::R32I: return GL_INT; - case GFXFormat::RG8: return GL_UNSIGNED_BYTE; - case GFXFormat::RG8SN: return GL_BYTE; - case GFXFormat::RG8UI: return GL_UNSIGNED_BYTE; - case GFXFormat::RG8I: return GL_BYTE; - case GFXFormat::RG16UI: return GL_UNSIGNED_SHORT; - case GFXFormat::RG16I: return GL_SHORT; - case GFXFormat::RG32F: return GL_FLOAT; - case GFXFormat::RG32UI: return GL_UNSIGNED_INT; - case GFXFormat::RG32I: return GL_INT; + case Format::RG8: return GL_UNSIGNED_BYTE; + case Format::RG8SN: return GL_BYTE; + case Format::RG8UI: return GL_UNSIGNED_BYTE; + case Format::RG8I: return GL_BYTE; + case Format::RG16UI: return GL_UNSIGNED_SHORT; + case Format::RG16I: return GL_SHORT; + case Format::RG32F: return GL_FLOAT; + case Format::RG32UI: return GL_UNSIGNED_INT; + case Format::RG32I: return GL_INT; - case GFXFormat::RGB8: return GL_UNSIGNED_BYTE; - case GFXFormat::SRGB8: return GL_UNSIGNED_BYTE; - case GFXFormat::RGB8SN: return GL_BYTE; - case GFXFormat::RGB8UI: return GL_UNSIGNED_BYTE; - case GFXFormat::RGB8I: return GL_BYTE; - case GFXFormat::RGB16F: return GL_HALF_FLOAT_OES; - case GFXFormat::RGB16UI: return GL_UNSIGNED_SHORT; - case GFXFormat::RGB16I: return GL_SHORT; - case GFXFormat::RGB32F: return GL_FLOAT; - case GFXFormat::RGB32UI: return GL_UNSIGNED_INT; - case GFXFormat::RGB32I: return GL_INT; + case Format::RGB8: return GL_UNSIGNED_BYTE; + case Format::SRGB8: return GL_UNSIGNED_BYTE; + case Format::RGB8SN: return GL_BYTE; + case Format::RGB8UI: return GL_UNSIGNED_BYTE; + case Format::RGB8I: return GL_BYTE; + case Format::RGB16F: return GL_HALF_FLOAT_OES; + case Format::RGB16UI: return GL_UNSIGNED_SHORT; + case Format::RGB16I: return GL_SHORT; + case Format::RGB32F: return GL_FLOAT; + case Format::RGB32UI: return GL_UNSIGNED_INT; + case Format::RGB32I: return GL_INT; - case GFXFormat::RGBA8: return GL_UNSIGNED_BYTE; - case GFXFormat::SRGB8_A8: return GL_UNSIGNED_BYTE; - case GFXFormat::RGBA8SN: return GL_BYTE; - case GFXFormat::RGBA8UI: return GL_UNSIGNED_BYTE; - case GFXFormat::RGBA8I: return GL_BYTE; - case GFXFormat::RGBA16F: return GL_HALF_FLOAT_OES; - case GFXFormat::RGBA16UI: return GL_UNSIGNED_SHORT; - case GFXFormat::RGBA16I: return GL_SHORT; - case GFXFormat::RGBA32F: return GL_FLOAT; - case GFXFormat::RGBA32UI: return GL_UNSIGNED_INT; - case GFXFormat::RGBA32I: return GL_INT; + case Format::RGBA8: return GL_UNSIGNED_BYTE; + case Format::SRGB8_A8: return GL_UNSIGNED_BYTE; + case Format::RGBA8SN: return GL_BYTE; + case Format::RGBA8UI: return GL_UNSIGNED_BYTE; + case Format::RGBA8I: return GL_BYTE; + case Format::RGBA16F: return GL_HALF_FLOAT_OES; + case Format::RGBA16UI: return GL_UNSIGNED_SHORT; + case Format::RGBA16I: return GL_SHORT; + case Format::RGBA32F: return GL_FLOAT; + case Format::RGBA32UI: return GL_UNSIGNED_INT; + case Format::RGBA32I: return GL_INT; - case GFXFormat::R5G6B5: return GL_UNSIGNED_SHORT_5_6_5; - case GFXFormat::R11G11B10F: return GL_FLOAT; - case GFXFormat::RGB5A1: return GL_UNSIGNED_SHORT_5_5_5_1; - case GFXFormat::RGBA4: return GL_UNSIGNED_SHORT_4_4_4_4; - case GFXFormat::RGB10A2: return GL_UNSIGNED_BYTE; - case GFXFormat::RGB10A2UI: return GL_UNSIGNED_INT; - case GFXFormat::RGB9E5: return GL_FLOAT; + case Format::R5G6B5: return GL_UNSIGNED_SHORT_5_6_5; + case Format::R11G11B10F: return GL_FLOAT; + case Format::RGB5A1: return GL_UNSIGNED_SHORT_5_5_5_1; + case Format::RGBA4: return GL_UNSIGNED_SHORT_4_4_4_4; + case Format::RGB10A2: return GL_UNSIGNED_BYTE; + case Format::RGB10A2UI: return GL_UNSIGNED_INT; + case Format::RGB9E5: return GL_FLOAT; - case GFXFormat::D16: return GL_UNSIGNED_SHORT; - case GFXFormat::D16S8: return GL_UNSIGNED_INT_24_8_OES; - case GFXFormat::D24: return GL_UNSIGNED_INT; - case GFXFormat::D24S8: return GL_UNSIGNED_INT_24_8_OES; - case GFXFormat::D32F: return GL_UNSIGNED_INT; - case GFXFormat::D32F_S8: return GL_UNSIGNED_INT_24_8_OES; + case Format::D16: return GL_UNSIGNED_SHORT; + case Format::D16S8: return GL_UNSIGNED_INT_24_8_OES; + case Format::D24: return GL_UNSIGNED_INT; + case Format::D24S8: return GL_UNSIGNED_INT_24_8_OES; + case Format::D32F: return GL_UNSIGNED_INT; + case Format::D32F_S8: return GL_UNSIGNED_INT_24_8_OES; - case GFXFormat::BC1: return GL_UNSIGNED_BYTE; - case GFXFormat::BC1_SRGB: return GL_UNSIGNED_BYTE; - case GFXFormat::BC2: return GL_UNSIGNED_BYTE; - case GFXFormat::BC2_SRGB: return GL_UNSIGNED_BYTE; - case GFXFormat::BC3: return GL_UNSIGNED_BYTE; - case GFXFormat::BC3_SRGB: return GL_UNSIGNED_BYTE; - case GFXFormat::BC4: return GL_UNSIGNED_BYTE; - case GFXFormat::BC4_SNORM: return GL_BYTE; - case GFXFormat::BC5: return GL_UNSIGNED_BYTE; - case GFXFormat::BC5_SNORM: return GL_BYTE; - case GFXFormat::BC6H_SF16: return GL_FLOAT; - case GFXFormat::BC6H_UF16: return GL_FLOAT; - case GFXFormat::BC7: return GL_UNSIGNED_BYTE; - case GFXFormat::BC7_SRGB: return GL_UNSIGNED_BYTE; + case Format::BC1: return GL_UNSIGNED_BYTE; + case Format::BC1_SRGB: return GL_UNSIGNED_BYTE; + case Format::BC2: return GL_UNSIGNED_BYTE; + case Format::BC2_SRGB: return GL_UNSIGNED_BYTE; + case Format::BC3: return GL_UNSIGNED_BYTE; + case Format::BC3_SRGB: return GL_UNSIGNED_BYTE; + case Format::BC4: return GL_UNSIGNED_BYTE; + case Format::BC4_SNORM: return GL_BYTE; + case Format::BC5: return GL_UNSIGNED_BYTE; + case Format::BC5_SNORM: return GL_BYTE; + case Format::BC6H_SF16: return GL_FLOAT; + case Format::BC6H_UF16: return GL_FLOAT; + case Format::BC7: return GL_UNSIGNED_BYTE; + case Format::BC7_SRGB: return GL_UNSIGNED_BYTE; - case GFXFormat::ETC_RGB8: return GL_UNSIGNED_BYTE; - case GFXFormat::ETC2_RGB8: return GL_UNSIGNED_BYTE; - case GFXFormat::ETC2_SRGB8: return GL_UNSIGNED_BYTE; - case GFXFormat::ETC2_RGB8_A1: return GL_UNSIGNED_BYTE; - case GFXFormat::ETC2_SRGB8_A1: return GL_UNSIGNED_BYTE; - case GFXFormat::EAC_R11: return GL_UNSIGNED_BYTE; - case GFXFormat::EAC_R11SN: return GL_BYTE; - case GFXFormat::EAC_RG11: return GL_UNSIGNED_BYTE; - case GFXFormat::EAC_RG11SN: return GL_BYTE; + case Format::ETC_RGB8: return GL_UNSIGNED_BYTE; + case Format::ETC2_RGB8: return GL_UNSIGNED_BYTE; + case Format::ETC2_SRGB8: return GL_UNSIGNED_BYTE; + case Format::ETC2_RGB8_A1: return GL_UNSIGNED_BYTE; + case Format::ETC2_SRGB8_A1: return GL_UNSIGNED_BYTE; + case Format::EAC_R11: return GL_UNSIGNED_BYTE; + case Format::EAC_R11SN: return GL_BYTE; + case Format::EAC_RG11: return GL_UNSIGNED_BYTE; + case Format::EAC_RG11SN: return GL_BYTE; - case GFXFormat::PVRTC_RGB2: return GL_UNSIGNED_BYTE; - case GFXFormat::PVRTC_RGBA2: return GL_UNSIGNED_BYTE; - case GFXFormat::PVRTC_RGB4: return GL_UNSIGNED_BYTE; - case GFXFormat::PVRTC_RGBA4: return GL_UNSIGNED_BYTE; - case GFXFormat::PVRTC2_2BPP: return GL_UNSIGNED_BYTE; - case GFXFormat::PVRTC2_4BPP: return GL_UNSIGNED_BYTE; + case Format::PVRTC_RGB2: return GL_UNSIGNED_BYTE; + case Format::PVRTC_RGBA2: return GL_UNSIGNED_BYTE; + case Format::PVRTC_RGB4: return GL_UNSIGNED_BYTE; + case Format::PVRTC_RGBA4: return GL_UNSIGNED_BYTE; + case Format::PVRTC2_2BPP: return GL_UNSIGNED_BYTE; + case Format::PVRTC2_4BPP: return GL_UNSIGNED_BYTE; default: { return GL_UNSIGNED_BYTE; @@ -430,9 +430,9 @@ const GLenum GLES2_BLEND_FACTORS[] = { } // namespace void GLES2CmdFuncCreateBuffer(GLES2Device *device, GLES2GPUBuffer *gpuBuffer) { - GLenum glUsage = (gpuBuffer->memUsage & GFXMemoryUsageBit::HOST ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); + GLenum glUsage = (gpuBuffer->memUsage & MemoryUsageBit::HOST ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); - if (gpuBuffer->usage & GFXBufferUsageBit::VERTEX) { + if (gpuBuffer->usage & BufferUsageBit::VERTEX) { gpuBuffer->glTarget = GL_ARRAY_BUFFER; glGenBuffers(1, &gpuBuffer->glBuffer); if (gpuBuffer->size) { @@ -451,7 +451,7 @@ void GLES2CmdFuncCreateBuffer(GLES2Device *device, GLES2GPUBuffer *gpuBuffer) { glBindBuffer(GL_ARRAY_BUFFER, 0); device->stateCache->glArrayBuffer = 0; } - } else if (gpuBuffer->usage & GFXBufferUsageBit::INDEX) { + } else if (gpuBuffer->usage & BufferUsageBit::INDEX) { gpuBuffer->glTarget = GL_ELEMENT_ARRAY_BUFFER; glGenBuffers(1, &gpuBuffer->glBuffer); if (gpuBuffer->size) { @@ -470,29 +470,29 @@ void GLES2CmdFuncCreateBuffer(GLES2Device *device, GLES2GPUBuffer *gpuBuffer) { glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); device->stateCache->glElementArrayBuffer = 0; } - } else if (gpuBuffer->usage & GFXBufferUsageBit::UNIFORM) { + } else if (gpuBuffer->usage & BufferUsageBit::UNIFORM) { gpuBuffer->buffer = (uint8_t *)CC_MALLOC(gpuBuffer->size); gpuBuffer->glTarget = GL_NONE; - } else if (gpuBuffer->usage & GFXBufferUsageBit::INDIRECT) { + } else if (gpuBuffer->usage & BufferUsageBit::INDIRECT) { gpuBuffer->glTarget = GL_NONE; - } else if ((gpuBuffer->usage & GFXBufferUsageBit::TRANSFER_DST) || - (gpuBuffer->usage & GFXBufferUsageBit::TRANSFER_SRC)) { + } else if ((gpuBuffer->usage & BufferUsageBit::TRANSFER_DST) || + (gpuBuffer->usage & BufferUsageBit::TRANSFER_SRC)) { gpuBuffer->buffer = (uint8_t *)CC_MALLOC(gpuBuffer->size); gpuBuffer->glTarget = GL_NONE; } else { - CCASSERT(false, "Unsupported GFXBufferType, create buffer failed."); + CCASSERT(false, "Unsupported BufferType, create buffer failed."); gpuBuffer->glTarget = GL_NONE; } } void GLES2CmdFuncDestroyBuffer(GLES2Device *device, GLES2GPUBuffer *gpuBuffer) { if (gpuBuffer->glBuffer) { - if (gpuBuffer->usage & GFXBufferUsageBit::VERTEX) { + if (gpuBuffer->usage & BufferUsageBit::VERTEX) { if (device->stateCache->glArrayBuffer == gpuBuffer->glBuffer) { glBindBuffer(GL_ARRAY_BUFFER, 0); device->stateCache->glArrayBuffer = 0; } - } else if (gpuBuffer->usage & GFXBufferUsageBit::INDEX) { + } else if (gpuBuffer->usage & BufferUsageBit::INDEX) { if (device->stateCache->glElementArrayBuffer == gpuBuffer->glBuffer) { glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); device->stateCache->glElementArrayBuffer = 0; @@ -505,9 +505,9 @@ void GLES2CmdFuncDestroyBuffer(GLES2Device *device, GLES2GPUBuffer *gpuBuffer) { } void GLES2CmdFuncResizeBuffer(GLES2Device *device, GLES2GPUBuffer *gpuBuffer) { - GLenum glUsage = (gpuBuffer->memUsage & GFXMemoryUsageBit::HOST ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); + GLenum glUsage = (gpuBuffer->memUsage & MemoryUsageBit::HOST ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); - if (gpuBuffer->usage & GFXBufferUsageBit::VERTEX) { + if (gpuBuffer->usage & BufferUsageBit::VERTEX) { gpuBuffer->glTarget = GL_ARRAY_BUFFER; if (gpuBuffer->size) { if (device->useVAO()) { @@ -525,7 +525,7 @@ void GLES2CmdFuncResizeBuffer(GLES2Device *device, GLES2GPUBuffer *gpuBuffer) { glBindBuffer(GL_ARRAY_BUFFER, 0); device->stateCache->glArrayBuffer = 0; } - } else if (gpuBuffer->usage & GFXBufferUsageBit::INDEX) { + } else if (gpuBuffer->usage & BufferUsageBit::INDEX) { gpuBuffer->glTarget = GL_ELEMENT_ARRAY_BUFFER; if (gpuBuffer->size) { if (device->useVAO()) { @@ -543,35 +543,35 @@ void GLES2CmdFuncResizeBuffer(GLES2Device *device, GLES2GPUBuffer *gpuBuffer) { glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); device->stateCache->glElementArrayBuffer = 0; } - } else if (gpuBuffer->usage & GFXBufferUsageBit::UNIFORM) { + } else if (gpuBuffer->usage & BufferUsageBit::UNIFORM) { if (gpuBuffer->buffer) { CC_FREE(gpuBuffer->buffer); } gpuBuffer->buffer = (uint8_t *)CC_MALLOC(gpuBuffer->size); gpuBuffer->glTarget = GL_NONE; - } else if (gpuBuffer->usage & GFXBufferUsageBit::INDIRECT) { + } else if (gpuBuffer->usage & BufferUsageBit::INDIRECT) { gpuBuffer->indirects.resize(gpuBuffer->count); gpuBuffer->glTarget = GL_NONE; - } else if ((gpuBuffer->usage & GFXBufferUsageBit::TRANSFER_DST) || - (gpuBuffer->usage & GFXBufferUsageBit::TRANSFER_SRC)) { + } else if ((gpuBuffer->usage & BufferUsageBit::TRANSFER_DST) || + (gpuBuffer->usage & BufferUsageBit::TRANSFER_SRC)) { if (gpuBuffer->buffer) { CC_FREE(gpuBuffer->buffer); } gpuBuffer->buffer = (uint8_t *)CC_MALLOC(gpuBuffer->size); gpuBuffer->glTarget = GL_NONE; } else { - CCASSERT(false, "Unsupported GFXBufferType, resize buffer failed."); + CCASSERT(false, "Unsupported BufferType, resize buffer failed."); gpuBuffer->glTarget = GL_NONE; } } void GLES2CmdFuncUpdateBuffer(GLES2Device *device, GLES2GPUBuffer *gpuBuffer, void *buffer, uint offset, uint size) { CCASSERT(buffer, "Buffer should not be nullptr"); - if (gpuBuffer->usage & GFXBufferUsageBit::UNIFORM) { + if (gpuBuffer->usage & BufferUsageBit::UNIFORM) { memcpy(gpuBuffer->buffer + offset, buffer, size); - } else if (gpuBuffer->usage & GFXBufferUsageBit::INDIRECT) { + } else if (gpuBuffer->usage & BufferUsageBit::INDIRECT) { memcpy((uint8_t *)gpuBuffer->indirects.data() + offset, buffer, size); - } else if (gpuBuffer->usage & GFXBufferUsageBit::TRANSFER_SRC) { + } else if (gpuBuffer->usage & BufferUsageBit::TRANSFER_SRC) { memcpy(gpuBuffer->buffer + offset, buffer, size); } else { switch (gpuBuffer->glTarget) { @@ -604,7 +604,7 @@ void GLES2CmdFuncUpdateBuffer(GLES2Device *device, GLES2GPUBuffer *gpuBuffer, vo break; } default: - CCASSERT(false, "Unsupported GFXBufferType, update buffer failed."); + CCASSERT(false, "Unsupported BufferType, update buffer failed."); break; } } @@ -613,10 +613,10 @@ void GLES2CmdFuncUpdateBuffer(GLES2Device *device, GLES2GPUBuffer *gpuBuffer, vo void GLES2CmdFuncCreateTexture(GLES2Device *device, GLES2GPUTexture *gpuTexture) { gpuTexture->glInternelFmt = MapGLInternalFormat(gpuTexture->format); gpuTexture->glFormat = MapGLFormat(gpuTexture->format); - gpuTexture->glType = GFXFormatToGLType(gpuTexture->format); + gpuTexture->glType = FormatToGLType(gpuTexture->format); switch (gpuTexture->type) { - case GFXTextureType::TEX2D: { + case TextureType::TEX2D: { gpuTexture->glTarget = GL_TEXTURE_2D; glGenTextures(1, &gpuTexture->glTexture); if (gpuTexture->size > 0) { @@ -635,7 +635,7 @@ void GLES2CmdFuncCreateTexture(GLES2Device *device, GLES2GPUTexture *gpuTexture) } } else { for (uint i = 0; i < gpuTexture->mipLevel; ++i) { - uint img_size = GFXFormatSize(gpuTexture->format, w, h, 1); + uint img_size = FormatSize(gpuTexture->format, w, h, 1); glCompressedTexImage2D(GL_TEXTURE_2D, i, gpuTexture->glInternelFmt, w, h, 0, img_size, nullptr); w = std::max(1U, w >> 1); h = std::max(1U, h >> 1); @@ -644,7 +644,7 @@ void GLES2CmdFuncCreateTexture(GLES2Device *device, GLES2GPUTexture *gpuTexture) } break; } - case GFXTextureType::CUBE: { + case TextureType::CUBE: { gpuTexture->glTarget = GL_TEXTURE_CUBE_MAP; glGenTextures(1, &gpuTexture->glTexture); if (gpuTexture->size > 0) { @@ -668,7 +668,7 @@ void GLES2CmdFuncCreateTexture(GLES2Device *device, GLES2GPUTexture *gpuTexture) uint w = gpuTexture->width; uint h = gpuTexture->height; for (uint i = 0; i < gpuTexture->mipLevel; ++i) { - uint img_size = GFXFormatSize(gpuTexture->format, w, h, 1); + uint img_size = FormatSize(gpuTexture->format, w, h, 1); glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + f, i, gpuTexture->glInternelFmt, w, h, 0, img_size, nullptr); w = std::max(1U, w >> 1); h = std::max(1U, h >> 1); @@ -679,7 +679,7 @@ void GLES2CmdFuncCreateTexture(GLES2Device *device, GLES2GPUTexture *gpuTexture) break; } default: - CCASSERT(false, "Unsupported GFXTextureType, create texture failed."); + CCASSERT(false, "Unsupported TextureType, create texture failed."); break; } } @@ -689,11 +689,11 @@ void GLES2CmdFuncDestroyTexture(GLES2Device *device, GLES2GPUTexture *gpuTexture GLuint &glTexture = device->stateCache->glTextures[device->stateCache->texUint]; if (glTexture == gpuTexture->glTexture) { switch (gpuTexture->type) { - case GFXTextureType::TEX2D: { + case TextureType::TEX2D: { glBindTexture(GL_TEXTURE_2D, 0); break; } - case GFXTextureType::CUBE: { + case TextureType::CUBE: { glBindTexture(GL_TEXTURE_CUBE_MAP, 0); break; } @@ -708,10 +708,10 @@ void GLES2CmdFuncDestroyTexture(GLES2Device *device, GLES2GPUTexture *gpuTexture void GLES2CmdFuncResizeTexture(GLES2Device *device, GLES2GPUTexture *gpuTexture) { gpuTexture->glInternelFmt = MapGLInternalFormat(gpuTexture->format); gpuTexture->glFormat = MapGLFormat(gpuTexture->format); - gpuTexture->glType = GFXFormatToGLType(gpuTexture->format); + gpuTexture->glType = FormatToGLType(gpuTexture->format); switch (gpuTexture->type) { - case GFXTextureType::TEX2D: { + case TextureType::TEX2D: { gpuTexture->glTarget = GL_TEXTURE_2D; if (gpuTexture->size > 0) { GLuint &glTexture = device->stateCache->glTextures[device->stateCache->texUint]; @@ -729,7 +729,7 @@ void GLES2CmdFuncResizeTexture(GLES2Device *device, GLES2GPUTexture *gpuTexture) } } else { for (uint i = 0; i < gpuTexture->mipLevel; ++i) { - uint img_size = GFXFormatSize(gpuTexture->format, w, h, 1); + uint img_size = FormatSize(gpuTexture->format, w, h, 1); glCompressedTexImage2D(GL_TEXTURE_2D, i, gpuTexture->glInternelFmt, w, h, 0, img_size, nullptr); w = std::max(1U, w >> 1); h = std::max(1U, h >> 1); @@ -738,7 +738,7 @@ void GLES2CmdFuncResizeTexture(GLES2Device *device, GLES2GPUTexture *gpuTexture) } break; } - case GFXTextureType::CUBE: { + case TextureType::CUBE: { gpuTexture->glTarget = GL_TEXTURE_CUBE_MAP; if (gpuTexture->size > 0) { GLuint &glTexture = device->stateCache->glTextures[device->stateCache->texUint]; @@ -761,7 +761,7 @@ void GLES2CmdFuncResizeTexture(GLES2Device *device, GLES2GPUTexture *gpuTexture) uint w = gpuTexture->width; uint h = gpuTexture->height; for (uint i = 0; i < gpuTexture->mipLevel; ++i) { - uint img_size = GFXFormatSize(gpuTexture->format, w, h, 1); + uint img_size = FormatSize(gpuTexture->format, w, h, 1); glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + f, i, gpuTexture->glInternelFmt, w, h, 0, img_size, nullptr); w = std::max(1U, w >> 1); h = std::max(1U, h >> 1); @@ -772,31 +772,31 @@ void GLES2CmdFuncResizeTexture(GLES2Device *device, GLES2GPUTexture *gpuTexture) break; } default: - CCASSERT(false, "Unsupported GFXTextureType, resize texture failed."); + CCASSERT(false, "Unsupported TextureType, resize texture failed."); break; } } void GLES2CmdFuncCreateSampler(GLES2Device *device, GLES2GPUSampler *gpuSampler) { - if (gpuSampler->minFilter == GFXFilter::LINEAR || gpuSampler->minFilter == GFXFilter::ANISOTROPIC) { - if (gpuSampler->mipFilter == GFXFilter::LINEAR || gpuSampler->mipFilter == GFXFilter::ANISOTROPIC) { + if (gpuSampler->minFilter == Filter::LINEAR || gpuSampler->minFilter == Filter::ANISOTROPIC) { + if (gpuSampler->mipFilter == Filter::LINEAR || gpuSampler->mipFilter == Filter::ANISOTROPIC) { gpuSampler->glMinFilter = GL_LINEAR_MIPMAP_LINEAR; - } else if (gpuSampler->mipFilter == GFXFilter::POINT) { + } else if (gpuSampler->mipFilter == Filter::POINT) { gpuSampler->glMinFilter = GL_LINEAR_MIPMAP_NEAREST; } else { gpuSampler->glMinFilter = GL_LINEAR; } } else { - if (gpuSampler->mipFilter == GFXFilter::LINEAR || gpuSampler->mipFilter == GFXFilter::ANISOTROPIC) { + if (gpuSampler->mipFilter == Filter::LINEAR || gpuSampler->mipFilter == Filter::ANISOTROPIC) { gpuSampler->glMinFilter = GL_NEAREST_MIPMAP_LINEAR; - } else if (gpuSampler->mipFilter == GFXFilter::POINT) { + } else if (gpuSampler->mipFilter == Filter::POINT) { gpuSampler->glMinFilter = GL_NEAREST_MIPMAP_NEAREST; } else { gpuSampler->glMinFilter = GL_NEAREST; } } - if (gpuSampler->magFilter == GFXFilter::LINEAR || gpuSampler->magFilter == GFXFilter::ANISOTROPIC) { + if (gpuSampler->magFilter == Filter::LINEAR || gpuSampler->magFilter == Filter::ANISOTROPIC) { gpuSampler->glMagFilter = GL_LINEAR; } else { gpuSampler->glMagFilter = GL_NEAREST; @@ -819,18 +819,18 @@ void GLES2CmdFuncCreateShader(GLES2Device *device, GLES2GPUShader *gpuShader) { GLES2GPUShaderStage &gpu_stage = gpuShader->gpuStages[i]; switch (gpu_stage.type) { - case GFXShaderType::VERTEX: { + case ShaderType::VERTEX: { gl_shader_type = GL_VERTEX_SHADER; shader_type_str = "Vertex Shader"; break; } - case GFXShaderType::FRAGMENT: { + case ShaderType::FRAGMENT: { gl_shader_type = GL_FRAGMENT_SHADER; shader_type_str = "Fragment Shader"; break; } default: { - CCASSERT(false, "Unsupported GFXShaderType"); + CCASSERT(false, "Unsupported ShaderType"); return; } } @@ -922,7 +922,7 @@ void GLES2CmdFuncCreateShader(GLES2Device *device, GLES2GPUShader *gpuShader) { gpuInput.glLoc = glGetAttribLocation(gpuShader->glProgram, gl_name); gpuInput.binding = gpuInput.glLoc; gpuInput.name = gl_name; - gpuInput.type = MapGFXType(glType); + gpuInput.type = MapType(glType); gpuInput.stride = GLTypeSize(glType); gpuInput.count = gl_size; gpuInput.size = gpuInput.stride * gpuInput.count; @@ -936,7 +936,7 @@ void GLES2CmdFuncCreateShader(GLES2Device *device, GLES2GPUShader *gpuShader) { for (size_t i = 0; i < gpuShader->glBlocks.size(); ++i) { GLES2GPUUniformBlock &gpuBlock = gpuShader->glBlocks[i]; - GFXUniformBlock &block = gpuShader->blocks[i]; + UniformBlock &block = gpuShader->blocks[i]; gpuBlock.name = block.name; gpuBlock.binding = block.binding; @@ -944,7 +944,7 @@ void GLES2CmdFuncCreateShader(GLES2Device *device, GLES2GPUShader *gpuShader) { for (size_t j = 0; j < gpuBlock.glUniforms.size(); ++j) { GLES2GPUUniform &gpuUniform = gpuBlock.glUniforms[j]; - GFXUniform &uniform = block.uniforms[j]; + Uniform &uniform = block.uniforms[j]; gpuUniform.binding = GFX_INVALID_BINDING; gpuUniform.name = uniform.name; @@ -967,7 +967,7 @@ void GLES2CmdFuncCreateShader(GLES2Device *device, GLES2GPUShader *gpuShader) { gpuShader->glSamplers.resize(gpuShader->samplers.size()); for (size_t i = 0; i < gpuShader->glSamplers.size(); ++i) { - GFXUniformSampler &sampler = gpuShader->samplers[i]; + UniformSampler &sampler = gpuShader->samplers[i]; GLES2GPUUniformSampler &gpuSampler = gpuShader->glSamplers[i]; gpuSampler.binding = sampler.binding; gpuSampler.name = sampler.name; @@ -1076,12 +1076,12 @@ void GLES2CmdFuncCreateInputAssembler(GLES2Device *device, GLES2GPUInputAssemble gpuInputAssembler->glAttribs.resize(gpuInputAssembler->attributes.size()); for (size_t i = 0; i < gpuInputAssembler->glAttribs.size(); ++i) { GLES2GPUAttribute &gpuAttribute = gpuInputAssembler->glAttribs[i]; - const GFXAttribute &attrib = gpuInputAssembler->attributes[i]; + const Attribute &attrib = gpuInputAssembler->attributes[i]; GLES2GPUBuffer *gpu_vb = (GLES2GPUBuffer *)gpuInputAssembler->gpuVertexBuffers[attrib.stream]; gpuAttribute.name = attrib.name; - gpuAttribute.glType = GFXFormatToGLType(attrib.format); + gpuAttribute.glType = FormatToGLType(attrib.format); gpuAttribute.size = GFX_FORMAT_INFOS[(int)attrib.format].size; gpuAttribute.count = GFX_FORMAT_INFOS[(int)attrib.format].count; gpuAttribute.componentCount = GLComponentCount(gpuAttribute.glType); @@ -1234,23 +1234,23 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) gpuRenderPass = cmd->gpuFBO->gpuRenderPass; for (uint j = 0; j < cmd->num_clear_colors; ++j) { - const GFXColorAttachment &colorAttachment = gpuRenderPass->colorAttachments[j]; - if (colorAttachment.format != GFXFormat::UNKNOWN) { + const ColorAttachment &colorAttachment = gpuRenderPass->colorAttachments[j]; + if (colorAttachment.format != Format::UNKNOWN) { switch (colorAttachment.loadOp) { - case GFXLoadOp::LOAD: break; // GL default behaviour - case GFXLoadOp::CLEAR: { - if (cmd->clear_flags & GFXClearFlagBit::COLOR) { - if (cache->bs.targets[0].blendColorMask != GFXColorMask::ALL) { + case LoadOp::LOAD: break; // GL default behaviour + case LoadOp::CLEAR: { + if (cmd->clear_flags & ClearFlagBit::COLOR) { + if (cache->bs.targets[0].blendColorMask != ColorMask::ALL) { glColorMask(true, true, true, true); } - const GFXColor &color = cmd->clear_colors[j]; + const Color &color = cmd->clear_colors[j]; glClearColor(color.r, color.g, color.b, color.a); gl_clears |= GL_COLOR_BUFFER_BIT; } break; } - case GFXLoadOp::DISCARD: { + case LoadOp::DISCARD: { // invalidate fbo gl_attachments[num_attachments++] = (cmd->gpuFBO->isOffscreen ? GL_COLOR_ATTACHMENT0 + j : GL_COLOR_EXT); break; @@ -1260,19 +1260,19 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) } } // for - if (gpuRenderPass->depthStencilAttachment.format != GFXFormat::UNKNOWN) { + if (gpuRenderPass->depthStencilAttachment.format != Format::UNKNOWN) { bool hasDepth = GFX_FORMAT_INFOS[(int)gpuRenderPass->depthStencilAttachment.format].hasDepth; if (hasDepth) { switch (gpuRenderPass->depthStencilAttachment.depthLoadOp) { - case GFXLoadOp::LOAD: break; // GL default behaviour - case GFXLoadOp::CLEAR: { + case LoadOp::LOAD: break; // GL default behaviour + case LoadOp::CLEAR: { glDepthMask(true); cache->dss.depthWrite = true; glClearDepthf(cmd->clear_depth); gl_clears |= GL_DEPTH_BUFFER_BIT; break; } - case GFXLoadOp::DISCARD: { + case LoadOp::DISCARD: { // invalidate fbo gl_attachments[num_attachments++] = (cmd->gpuFBO->isOffscreen ? GL_DEPTH_ATTACHMENT : GL_DEPTH_EXT); break; @@ -1283,8 +1283,8 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) bool has_stencils = GFX_FORMAT_INFOS[(int)gpuRenderPass->depthStencilAttachment.format].hasStencil; if (has_stencils) { switch (gpuRenderPass->depthStencilAttachment.depthLoadOp) { - case GFXLoadOp::LOAD: break; // GL default behaviour - case GFXLoadOp::CLEAR: { + case LoadOp::LOAD: break; // GL default behaviour + case LoadOp::CLEAR: { if (!cache->dss.stencilWriteMaskFront) { glStencilMaskSeparate(GL_FRONT, 0xffffffff); } @@ -1295,7 +1295,7 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) gl_clears |= GL_STENCIL_BUFFER_BIT; break; } - case GFXLoadOp::DISCARD: { + case LoadOp::DISCARD: { // invalidate fbo gl_attachments[num_attachments++] = (cmd->gpuFBO->isOffscreen ? GL_STENCIL_ATTACHMENT : GL_STENCIL_EXT); break; @@ -1315,12 +1315,12 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) // restore states if (gl_clears & GL_COLOR_BUFFER_BIT) { - GFXColorMask color_mask = cache->bs.targets[0].blendColorMask; - if (color_mask != GFXColorMask::ALL) { - glColorMask((GLboolean)(color_mask & GFXColorMask::R), - (GLboolean)(color_mask & GFXColorMask::G), - (GLboolean)(color_mask & GFXColorMask::B), - (GLboolean)(color_mask & GFXColorMask::A)); + ColorMask color_mask = cache->bs.targets[0].blendColorMask; + if (color_mask != ColorMask::ALL) { + glColorMask((GLboolean)(color_mask & ColorMask::R), + (GLboolean)(color_mask & ColorMask::G), + (GLboolean)(color_mask & ColorMask::B), + (GLboolean)(color_mask & ColorMask::A)); } } @@ -1343,12 +1343,12 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) GLES2CmdBeginRenderPass *cmd = cmdBeginRenderPass; uint num_attachments = 0; for (uint j = 0; j < cmd->num_clear_colors; ++j) { - const GFXColorAttachment &colorAttachment = gpuRenderPass->colorAttachments[j]; - if (colorAttachment.format != GFXFormat::UNKNOWN) { + const ColorAttachment &colorAttachment = gpuRenderPass->colorAttachments[j]; + if (colorAttachment.format != Format::UNKNOWN) { switch (colorAttachment.loadOp) { - case GFXLoadOp::LOAD: break; // GL default behaviour - case GFXLoadOp::CLEAR: break; - case GFXLoadOp::DISCARD: { + case LoadOp::LOAD: break; // GL default behaviour + case LoadOp::CLEAR: break; + case LoadOp::DISCARD: { // invalidate fbo gl_attachments[num_attachments++] = (cmd->gpuFBO->isOffscreen ? GL_COLOR_ATTACHMENT0 + j : GL_COLOR_EXT); break; @@ -1358,13 +1358,13 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) } } // for - if (gpuRenderPass->depthStencilAttachment.format != GFXFormat::UNKNOWN) { + if (gpuRenderPass->depthStencilAttachment.format != Format::UNKNOWN) { bool hasDepth = GFX_FORMAT_INFOS[(int)gpuRenderPass->depthStencilAttachment.format].hasDepth; if (hasDepth) { switch (gpuRenderPass->depthStencilAttachment.depthLoadOp) { - case GFXLoadOp::LOAD: break; // GL default behaviour - case GFXLoadOp::CLEAR: break; - case GFXLoadOp::DISCARD: { + case LoadOp::LOAD: break; // GL default behaviour + case LoadOp::CLEAR: break; + case LoadOp::DISCARD: { // invalidate fbo gl_attachments[num_attachments++] = (cmd->gpuFBO->isOffscreen ? GL_DEPTH_ATTACHMENT : GL_DEPTH_EXT); break; @@ -1375,9 +1375,9 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) bool has_stencils = GFX_FORMAT_INFOS[(int)gpuRenderPass->depthStencilAttachment.format].hasStencil; if (has_stencils) { switch (gpuRenderPass->depthStencilAttachment.depthLoadOp) { - case GFXLoadOp::LOAD: break; // GL default behaviour - case GFXLoadOp::CLEAR: break; - case GFXLoadOp::DISCARD: { + case LoadOp::LOAD: break; // GL default behaviour + case LoadOp::CLEAR: break; + case LoadOp::DISCARD: { // invalidate fbo gl_attachments[num_attachments++] = (cmd->gpuFBO->isOffscreen ? GL_STENCIL_ATTACHMENT : GL_STENCIL_EXT); break; @@ -1411,20 +1411,20 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) // bind rasterizer state if (cache->rs.cullMode != gpuPipelineState->rs.cullMode) { switch (gpuPipelineState->rs.cullMode) { - case GFXCullMode::NONE: { + case CullMode::NONE: { if (cache->isCullFaceEnabled) { glDisable(GL_CULL_FACE); cache->isCullFaceEnabled = false; } } break; - case GFXCullMode::FRONT: { + case CullMode::FRONT: { if (!cache->isCullFaceEnabled) { glEnable(GL_CULL_FACE); cache->isCullFaceEnabled = true; } glCullFace(GL_FRONT); } break; - case GFXCullMode::BACK: { + case CullMode::BACK: { if (!cache->isCullFaceEnabled) { glEnable(GL_CULL_FACE); cache->isCullFaceEnabled = true; @@ -1557,8 +1557,8 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) cache->bs.blendColor = gpuPipelineState->bs.blendColor; } - GFXBlendTarget &cache_target = cache->bs.targets[0]; - const GFXBlendTarget &target = gpuPipelineState->bs.targets[0]; + BlendTarget &cache_target = cache->bs.targets[0]; + const BlendTarget &target = gpuPipelineState->bs.targets[0]; if (cache_target.blend != target.blend) { if (!cache_target.blend) { glEnable(GL_BLEND); @@ -1588,10 +1588,10 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) cache_target.blendDstAlpha = target.blendDstAlpha; } if (cache_target.blendColorMask != target.blendColorMask) { - glColorMask((GLboolean)(target.blendColorMask & GFXColorMask::R), - (GLboolean)(target.blendColorMask & GFXColorMask::G), - (GLboolean)(target.blendColorMask & GFXColorMask::B), - (GLboolean)(target.blendColorMask & GFXColorMask::A)); + glColorMask((GLboolean)(target.blendColorMask & ColorMask::R), + (GLboolean)(target.blendColorMask & ColorMask::G), + (GLboolean)(target.blendColorMask & ColorMask::B), + (GLboolean)(target.blendColorMask & ColorMask::A)); cache_target.blendColorMask = target.blendColorMask; } @@ -1602,7 +1602,7 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) for (size_t j = 0; j < cmd->gpuBindingLayout->gpuBindings.size(); ++j) { const GLES2GPUBinding &gpuBinding = cmd->gpuBindingLayout->gpuBindings[j]; switch (gpuBinding.type) { - case GFXBindingType::UNIFORM_BUFFER: { + case BindingType::UNIFORM_BUFFER: { if (gpuBinding.gpuBuffer) { for (size_t k = 0; k < gpuPipelineState->gpuShader->glBlocks.size(); ++k) { const GLES2GPUUniformBlock &gpuBlock = gpuPipelineState->gpuShader->glBlocks[k]; @@ -1705,7 +1705,7 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) } break; } - case GFXBindingType::SAMPLER: { + case BindingType::SAMPLER: { if (gpuBinding.gpuSampler) { for (size_t k = 0; k < gpuPipelineState->gpuShader->glSamplers.size(); ++k) { const GLES2GPUUniformSampler &gpuSampler = gpuPipelineState->gpuShader->glSamplers[k]; @@ -1729,7 +1729,7 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) glWrapT = gpuBinding.gpuSampler->glWrapT; if (gpuBinding.gpuTexture->mipLevel <= 1 && - !(gpuBinding.gpuTexture->flags & GFXTextureFlagBit::GEN_MIPMAP) && + !(gpuBinding.gpuTexture->flags & TextureFlagBit::GEN_MIPMAP) && (gpuBinding.gpuSampler->glMinFilter == GL_LINEAR_MIPMAP_NEAREST || gpuBinding.gpuSampler->glMinFilter == GL_LINEAR_MIPMAP_LINEAR)) { glMinFilter = GL_LINEAR; @@ -1902,25 +1902,25 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) if (gpuPipelineState) { for (auto dynamicState : gpuPipelineState->dynamicStates) { switch (dynamicState) { - case GFXDynamicState::VIEWPORT: + case DynamicState::VIEWPORT: if (cache->viewport != cmd->viewport) { cache->viewport = cmd->viewport; glViewport(cmd->viewport.left, cmd->viewport.top, cmd->viewport.width, cmd->viewport.height); } break; - case GFXDynamicState::SCISSOR: + case DynamicState::SCISSOR: if (cache->scissor != cmd->scissor) { cache->scissor = cmd->scissor; glScissor(cmd->scissor.x, cmd->scissor.y, cmd->scissor.width, cmd->scissor.height); } break; - case GFXDynamicState::LINE_WIDTH: + case DynamicState::LINE_WIDTH: if (cache->rs.lineWidth != cmd->lineWidth) { cache->rs.lineWidth = cmd->lineWidth; glLineWidth(cmd->lineWidth); } break; - case GFXDynamicState::DEPTH_BIAS: + case DynamicState::DEPTH_BIAS: if (cache->rs.depthBiasEnabled != cmd->depthBiasEnabled) { if (cmd->depthBiasEnabled) glEnable(GL_POLYGON_OFFSET_FILL); @@ -1936,7 +1936,7 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) cache->rs.depthBiasSlop = cmd->depthBias.slope; } break; - case GFXDynamicState::BLEND_CONSTANTS: + case DynamicState::BLEND_CONSTANTS: if ((cache->bs.blendColor.r != gpuPipelineState->bs.blendColor.r) || (cache->bs.blendColor.g != gpuPipelineState->bs.blendColor.g) || (cache->bs.blendColor.b != gpuPipelineState->bs.blendColor.b) || @@ -1948,21 +1948,21 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) cache->bs.blendColor = gpuPipelineState->bs.blendColor; } break; - case GFXDynamicState::STENCIL_WRITE_MASK: + case DynamicState::STENCIL_WRITE_MASK: switch (cmd->stencilWriteMask.face) { - case GFXStencilFace::FRONT: + case StencilFace::FRONT: if (cache->dss.stencilWriteMaskFront != cmd->stencilWriteMask.write_mask) { glStencilMaskSeparate(GL_FRONT, cmd->stencilWriteMask.write_mask); cache->dss.stencilWriteMaskFront = cmd->stencilWriteMask.write_mask; } break; - case GFXStencilFace::BACK: + case StencilFace::BACK: if (cache->dss.stencilWriteMaskBack != cmd->stencilWriteMask.write_mask) { glStencilMaskSeparate(GL_BACK, cmd->stencilWriteMask.write_mask); cache->dss.stencilWriteMaskBack = cmd->stencilWriteMask.write_mask; } break; - case GFXStencilFace::ALL: + case StencilFace::ALL: if ((cache->dss.stencilWriteMaskFront != cmd->stencilWriteMask.write_mask) || (cache->dss.stencilWriteMaskBack != cmd->stencilWriteMask.write_mask)) { glStencilMask(cmd->stencilWriteMask.write_mask); @@ -1972,9 +1972,9 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) break; } break; - case GFXDynamicState::STENCIL_COMPARE_MASK: + case DynamicState::STENCIL_COMPARE_MASK: switch (cmd->stencilCompareMask.face) { - case GFXStencilFace::FRONT: + case StencilFace::FRONT: if ((cache->dss.stencilRefFront != (uint)cmd->stencilCompareMask.refrence) || (cache->dss.stencilReadMaskFront != cmd->stencilCompareMask.compare_mask)) { glStencilFuncSeparate(GL_FRONT, @@ -1985,7 +1985,7 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) cache->dss.stencilReadMaskFront = cmd->stencilCompareMask.compare_mask; } break; - case GFXStencilFace::BACK: + case StencilFace::BACK: if ((cache->dss.stencilRefBack != (uint)cmd->stencilCompareMask.refrence) || (cache->dss.stencilReadMaskBack != cmd->stencilCompareMask.compare_mask)) { glStencilFuncSeparate(GL_BACK, @@ -1996,7 +1996,7 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) cache->dss.stencilReadMaskBack = cmd->stencilCompareMask.compare_mask; } break; - case GFXStencilFace::ALL: + case StencilFace::ALL: if ((cache->dss.stencilRefFront != (uint)cmd->stencilCompareMask.refrence) || (cache->dss.stencilReadMaskFront != cmd->stencilCompareMask.compare_mask) || (cache->dss.stencilRefBack != (uint)cmd->stencilCompareMask.refrence) || @@ -2051,7 +2051,7 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) } } else { for (size_t j = 0; j < gpuInputAssembler->gpuIndirectBuffer->indirects.size(); ++j) { - const GFXDrawInfo &draw = gpuInputAssembler->gpuIndirectBuffer->indirects[j]; + const DrawInfo &draw = gpuInputAssembler->gpuIndirectBuffer->indirects[j]; if (gpuInputAssembler->gpuIndexBuffer && draw.indexCount >= 0) { uint8_t *offset = 0; offset += draw.firstIndex * gpuInputAssembler->gpuIndexBuffer->stride; @@ -2093,7 +2093,7 @@ void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package) } } -void GLES2CmdFuncCopyBuffersToTexture(GLES2Device *device, uint8_t *const *buffers, GLES2GPUTexture *gpuTexture, const GFXBufferTextureCopyList ®ions) { +void GLES2CmdFuncCopyBuffersToTexture(GLES2Device *device, uint8_t *const *buffers, GLES2GPUTexture *gpuTexture, const BufferTextureCopyList ®ions) { GLuint &glTexture = device->stateCache->glTextures[device->stateCache->texUint]; if (glTexture != gpuTexture->glTexture) { glBindTexture(gpuTexture->glTarget, gpuTexture->glTexture); @@ -2108,12 +2108,12 @@ void GLES2CmdFuncCopyBuffersToTexture(GLES2Device *device, uint8_t *const *buffe uint w; uint h; for (size_t i = 0; i < regions.size(); ++i) { - const GFXBufferTextureCopy ®ion = regions[i]; + const BufferTextureCopy ®ion = regions[i]; w = region.texExtent.width; h = region.texExtent.height; uint8_t *buff = buffers[n++]; if (isCompressed) { - GLsizei memSize = (GLsizei)GFXFormatSize(gpuTexture->format, w, h, 1); + GLsizei memSize = (GLsizei)FormatSize(gpuTexture->format, w, h, 1); glCompressedTexSubImage2D(GL_TEXTURE_2D, region.texSubres.mipLevel, region.texOffset.x, @@ -2139,7 +2139,7 @@ void GLES2CmdFuncCopyBuffersToTexture(GLES2Device *device, uint8_t *const *buffe uint w; uint h; for (size_t i = 0; i < regions.size(); ++i) { - const GFXBufferTextureCopy ®ion = regions[i]; + const BufferTextureCopy ®ion = regions[i]; uint d = region.texSubres.layerCount; uint layerCount = d + region.texSubres.baseArrayLayer; @@ -2148,7 +2148,7 @@ void GLES2CmdFuncCopyBuffersToTexture(GLES2Device *device, uint8_t *const *buffe h = region.texExtent.height; uint8_t *buff = buffers[n++]; if (isCompressed) { - GLsizei memSize = (GLsizei)GFXFormatSize(gpuTexture->format, w, h, 1); + GLsizei memSize = (GLsizei)FormatSize(gpuTexture->format, w, h, 1); glCompressedTexSubImage3DOES(GL_TEXTURE_2D_ARRAY, region.texSubres.mipLevel, region.texOffset.x, @@ -2177,13 +2177,13 @@ void GLES2CmdFuncCopyBuffersToTexture(GLES2Device *device, uint8_t *const *buffe uint h; uint d; for (size_t i = 0; i < regions.size(); ++i) { - const GFXBufferTextureCopy ®ion = regions[i]; + const BufferTextureCopy ®ion = regions[i]; w = region.texExtent.width; h = region.texExtent.height; d = region.texExtent.depth; uint8_t *buff = buffers[n++]; if (isCompressed) { - GLsizei memSize = (GLsizei)GFXFormatSize(gpuTexture->format, w, d + 1, 1); + GLsizei memSize = (GLsizei)FormatSize(gpuTexture->format, w, d + 1, 1); glCompressedTexSubImage3DOES(GL_TEXTURE_3D, region.texSubres.mipLevel, region.texOffset.x, @@ -2212,14 +2212,14 @@ void GLES2CmdFuncCopyBuffersToTexture(GLES2Device *device, uint8_t *const *buffe uint h; uint f; for (size_t i = 0; i < regions.size(); ++i) { - const GFXBufferTextureCopy ®ion = regions[i]; + const BufferTextureCopy ®ion = regions[i]; uint face_count = region.texSubres.baseArrayLayer + region.texSubres.layerCount; for (f = region.texSubres.baseArrayLayer; f < face_count; ++f) { w = region.texExtent.width; h = region.texExtent.height; uint8_t *buff = buffers[n++]; if (isCompressed) { - GLsizei memSize = (GLsizei)GFXFormatSize(gpuTexture->format, w, h, 1); + GLsizei memSize = (GLsizei)FormatSize(gpuTexture->format, w, h, 1); glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + f, region.texSubres.mipLevel, region.texOffset.x, @@ -2242,11 +2242,11 @@ void GLES2CmdFuncCopyBuffersToTexture(GLES2Device *device, uint8_t *const *buffe break; } default: - CCASSERT(false, "Unsupported GFXTextureType, copy buffers to texture failed."); + CCASSERT(false, "Unsupported TextureType, copy buffers to texture failed."); break; } - if (!isCompressed && (gpuTexture->flags & GFXTextureFlagBit::GEN_MIPMAP)) { + if (!isCompressed && (gpuTexture->flags & TextureFlagBit::GEN_MIPMAP)) { glBindTexture(gpuTexture->glTarget, gpuTexture->glTexture); glGenerateMipmap(gpuTexture->glTarget); } diff --git a/native/cocos/renderer/gfx-gles2/GLES2Commands.h b/native/cocos/renderer/gfx-gles2/GLES2Commands.h index be261ec722..df634323b7 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Commands.h +++ b/native/cocos/renderer/gfx-gles2/GLES2Commands.h @@ -20,12 +20,12 @@ struct GLES2DepthBounds { }; struct GLES2StencilWriteMask { - GFXStencilFace face = GFXStencilFace::FRONT; + StencilFace face = StencilFace::FRONT; uint write_mask = 0; }; struct GLES2StencilCompareMask { - GFXStencilFace face = GFXStencilFace::FRONT; + StencilFace face = StencilFace::FRONT; int refrence = 0; uint compare_mask = 0; }; @@ -49,10 +49,10 @@ struct GLES2BufferTextureCopy { class GLES2CmdBeginRenderPass : public GFXCmd { public: GLES2GPUFramebuffer *gpuFBO = nullptr; - GFXRect render_area; - GFXClearFlags clear_flags = GFXClearFlagBit::NONE; + Rect render_area; + ClearFlags clear_flags = ClearFlagBit::NONE; uint num_clear_colors = 0; - GFXColor clear_colors[GFX_MAX_ATTACHMENTS]; + Color clear_colors[GFX_MAX_ATTACHMENTS]; float clear_depth = 1.0f; int clear_stencil = 0; @@ -82,12 +82,12 @@ public: GLES2GPUBindingLayout *gpuBindingLayout = nullptr; GLES2GPUInputAssembler *gpuInputAssembler = nullptr; uint8_t state_flags[(int)GLES2State::COUNT] = {0}; - GFXViewport viewport; - GFXRect scissor; + Viewport viewport; + Rect scissor; float lineWidth = 1.0f; bool depthBiasEnabled = false; GLES2DepthBias depthBias; - GFXColor blendConstants; + Color blendConstants; GLES2DepthBounds depthBounds; GLES2StencilWriteMask stencilWriteMask; GLES2StencilCompareMask stencilCompareMask; @@ -104,7 +104,7 @@ public: class GLES2CmdDraw : public GFXCmd { public: - GFXDrawInfo draw_info; + DrawInfo draw_info; GLES2CmdDraw() : GFXCmd(GFXCmdType::DRAW) {} virtual void clear() override {} @@ -129,8 +129,8 @@ class GLES2CmdCopyBufferToTexture : public GFXCmd { public: GLES2GPUBuffer *gpuBuffer = nullptr; GLES2GPUTexture *gpuTexture = nullptr; - GFXTextureLayout dst_layout; - GFXBufferTextureCopyList regions; + TextureLayout dst_layout; + BufferTextureCopyList regions; GLES2CmdCopyBufferToTexture() : GFXCmd(GFXCmdType::COPY_BUFFER_TO_TEXTURE) {} @@ -167,7 +167,7 @@ CC_GLES2_API void GLES2CmdFuncDestroyInputAssembler(GLES2Device *device, GLES2GP CC_GLES2_API void GLES2CmdFuncCreateFramebuffer(GLES2Device *device, GLES2GPUFramebuffer *gpuFBO); CC_GLES2_API void GLES2CmdFuncDestroyFramebuffer(GLES2Device *device, GLES2GPUFramebuffer *gpuFBO); CC_GLES2_API void GLES2CmdFuncExecuteCmds(GLES2Device *device, GLES2CmdPackage *cmd_package); -CC_GLES2_API void GLES2CmdFuncCopyBuffersToTexture(GLES2Device *device, uint8_t *const *buffers, GLES2GPUTexture *gpuTexture, const GFXBufferTextureCopyList ®ions); +CC_GLES2_API void GLES2CmdFuncCopyBuffersToTexture(GLES2Device *device, uint8_t *const *buffers, GLES2GPUTexture *gpuTexture, const BufferTextureCopyList ®ions); } // namespace gfx } // namespace cc diff --git a/native/cocos/renderer/gfx-gles2/GLES2Context.cc b/native/cocos/renderer/gfx-gles2/GLES2Context.cc index 2328883f51..cd7cc6b702 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Context.cc +++ b/native/cocos/renderer/gfx-gles2/GLES2Context.cc @@ -69,8 +69,8 @@ void APIENTRY GLES2EGLDebugProc(GLenum source, #endif -GLES2Context::GLES2Context(GFXDevice *device) -: GFXContext(device) { +GLES2Context::GLES2Context(Device *device) +: Context(device) { } GLES2Context::~GLES2Context() { @@ -78,7 +78,7 @@ GLES2Context::~GLES2Context() { #if (CC_PLATFORM == CC_PLATFORM_WINDOWS || CC_PLATFORM == CC_PLATFORM_ANDROID || CC_PLATFORM == CC_PLATFORM_MAC_OSX) -bool GLES2Context::initialize(const GFXContextInfo &info) { +bool GLES2Context::initialize(const ContextInfo &info) { _vsyncMode = info.vsyncMode; _windowHandle = info.windowHandle; @@ -124,8 +124,8 @@ bool GLES2Context::initialize(const GFXContextInfo &info) { return false; } - _colorFmt = GFXFormat::RGBA8; - _depthStencilFmt = GFXFormat::D24S8; + _colorFmt = Format::RGBA8; + _depthStencilFmt = Format::D24S8; const EGLint attribs[] = { EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT, @@ -160,17 +160,17 @@ bool GLES2Context::initialize(const GFXContextInfo &info) { CC_LOG_INFO("Setup EGLConfig: depth [%d] stencil [%d]", depth, stencil); if (depth == 16 && stencil == 0) { - _depthStencilFmt = GFXFormat::D16; + _depthStencilFmt = Format::D16; } else if (depth == 16 && stencil == 8) { - _depthStencilFmt = GFXFormat::D16S8; + _depthStencilFmt = Format::D16S8; } else if (depth == 24 && stencil == 0) { - _depthStencilFmt = GFXFormat::D24; + _depthStencilFmt = Format::D24; } else if (depth == 24 && stencil == 8) { - _depthStencilFmt = GFXFormat::D24S8; + _depthStencilFmt = Format::D24S8; } else if (depth == 32 && stencil == 0) { - _depthStencilFmt = GFXFormat::D32F; + _depthStencilFmt = Format::D32F; } else if (depth == 32 && stencil == 8) { - _depthStencilFmt = GFXFormat::D32F_S8; + _depthStencilFmt = Format::D32F_S8; } else { CC_LOG_ERROR("Unknown depth stencil format."); return false; @@ -359,7 +359,7 @@ void GLES2Context::destroy() { _isPrimaryContex = false; _windowHandle = 0; _nativeDisplay = 0; - _vsyncMode = GFXVsyncMode::OFF; + _vsyncMode = VsyncMode::OFF; _isInitialized = false; } @@ -381,11 +381,11 @@ bool GLES2Context::MakeCurrent() { // Turn on or off the vertical sync depending on the input bool value. int interval = 1; switch (_vsyncMode) { - case GFXVsyncMode::OFF: interval = 0; break; - case GFXVsyncMode::ON: interval = 1; break; - case GFXVsyncMode::RELAXED: interval = -1; break; - case GFXVsyncMode::MAILBOX: interval = 0; break; - case GFXVsyncMode::HALF: interval = 2; break; + case VsyncMode::OFF: interval = 0; break; + case VsyncMode::ON: interval = 1; break; + case VsyncMode::RELAXED: interval = -1; break; + case VsyncMode::MAILBOX: interval = 0; break; + case VsyncMode::HALF: interval = 2; break; default: break; } diff --git a/native/cocos/renderer/gfx-gles2/GLES2Context.h b/native/cocos/renderer/gfx-gles2/GLES2Context.h index dd0852c34b..a5dec9ae15 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Context.h +++ b/native/cocos/renderer/gfx-gles2/GLES2Context.h @@ -31,13 +31,13 @@ namespace cc { namespace gfx { -class CC_GLES2_API GLES2Context : public GFXContext { +class CC_GLES2_API GLES2Context : public Context { public: - GLES2Context(GFXDevice *device); + GLES2Context(Device *device); ~GLES2Context(); public: - virtual bool initialize(const GFXContextInfo &info) override; + virtual bool initialize(const ContextInfo &info) override; virtual void destroy() override; virtual void present() override; bool MakeCurrent(); diff --git a/native/cocos/renderer/gfx-gles2/GLES2Context.mm b/native/cocos/renderer/gfx-gles2/GLES2Context.mm index d5734bd637..a15581b2a1 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Context.mm +++ b/native/cocos/renderer/gfx-gles2/GLES2Context.mm @@ -10,7 +10,7 @@ namespace gfx { #if (CC_PLATFORM == CC_PLATFORM_MAC_IOS) -bool GLES2Context::initialize(const GFXContextInfo &info) { +bool GLES2Context::initialize(const ContextInfo &info) { _vsyncMode = info.vsyncMode; _windowHandle = info.windowHandle; @@ -49,8 +49,8 @@ bool GLES2Context::initialize(const GFXContextInfo &info) { } } - _colorFmt = GFXFormat::RGBA8; - _depthStencilFmt = GFXFormat::D24S8; + _colorFmt = Format::RGBA8; + _depthStencilFmt = Format::D24S8; if (!MakeCurrent()) return false; @@ -169,7 +169,7 @@ void GLES2Context::destroy() { _isPrimaryContex = false; _windowHandle = 0; - _vsyncMode = GFXVsyncMode::OFF; + _vsyncMode = VsyncMode::OFF; _isInitialized = false; } diff --git a/native/cocos/renderer/gfx-gles2/GLES2Device.cc b/native/cocos/renderer/gfx-gles2/GLES2Device.cc index 087ff05e8a..a7a33e3d80 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Device.cc +++ b/native/cocos/renderer/gfx-gles2/GLES2Device.cc @@ -27,8 +27,8 @@ GLES2Device::GLES2Device() { GLES2Device::~GLES2Device() { } -bool GLES2Device::initialize(const GFXDeviceInfo &info) { - _gfxAPI = GFXAPI::GLES2; +bool GLES2Device::initialize(const DeviceInfo &info) { + _API = API::GLES2; _deviceName = "GLES2"; _width = info.width; _height = info.height; @@ -38,7 +38,7 @@ bool GLES2Device::initialize(const GFXDeviceInfo &info) { stateCache = CC_NEW(GLES2StateCache); - GFXContextInfo ctx_info; + ContextInfo ctx_info; ctx_info.windowHandle = _windowHandle; ctx_info.sharedCtx = info.sharedCtx; @@ -51,58 +51,58 @@ bool GLES2Device::initialize(const GFXDeviceInfo &info) { String extStr = (const char *)glGetString(GL_EXTENSIONS); _extensions = StringUtil::Split(extStr, " "); - _features[(int)GFXFeature::TEXTURE_FLOAT] = true; - _features[(int)GFXFeature::TEXTURE_HALF_FLOAT] = true; - _features[(int)GFXFeature::FORMAT_R11G11B10F] = true; - _features[(int)GFXFeature::FORMAT_D24S8] = true; - _features[(int)GFXFeature::MSAA] = true; + _features[(int)Feature::TEXTURE_FLOAT] = true; + _features[(int)Feature::TEXTURE_HALF_FLOAT] = true; + _features[(int)Feature::FORMAT_R11G11B10F] = true; + _features[(int)Feature::FORMAT_D24S8] = true; + _features[(int)Feature::MSAA] = true; if (checkExtension("color_buffer_float")) - _features[(int)GFXFeature::COLOR_FLOAT] = true; + _features[(int)Feature::COLOR_FLOAT] = true; if (checkExtension("color_buffer_half_float")) - _features[(int)GFXFeature::COLOR_HALF_FLOAT] = true; + _features[(int)Feature::COLOR_HALF_FLOAT] = true; if (checkExtension("texture_float_linear")) - _features[(int)GFXFeature::TEXTURE_FLOAT_LINEAR] = true; + _features[(int)Feature::TEXTURE_FLOAT_LINEAR] = true; if (checkExtension("texture_half_float_linear")) - _features[(int)GFXFeature::TEXTURE_HALF_FLOAT_LINEAR] = true; + _features[(int)Feature::TEXTURE_HALF_FLOAT_LINEAR] = true; _useVAO = checkExtension("vertex_array_object"); _useDrawInstanced = checkExtension("draw_instanced"); - _useInstancedArrays = _features[(int)GFXFeature::INSTANCED_ARRAYS] = checkExtension("instanced_arrays"); + _useInstancedArrays = _features[(int)Feature::INSTANCED_ARRAYS] = checkExtension("instanced_arrays"); _useDiscardFramebuffer = checkExtension("discard_framebuffer"); String compressed_fmts; if (checkExtension("compressed_ETC1")) { - _features[(int)GFXFeature::FORMAT_ETC1] = true; + _features[(int)Feature::FORMAT_ETC1] = true; compressed_fmts += "etc1 "; } - _features[(int)GFXFeature::FORMAT_ETC2] = true; + _features[(int)Feature::FORMAT_ETC2] = true; compressed_fmts += "etc2 "; if (checkExtension("texture_compression_pvrtc")) { - _features[(int)GFXFeature::FORMAT_PVRTC] = true; + _features[(int)Feature::FORMAT_PVRTC] = true; compressed_fmts += "pvrtc "; } if (checkExtension("texture_compression_astc")) { - _features[(int)GFXFeature::FORMAT_ASTC] = true; + _features[(int)Feature::FORMAT_ASTC] = true; compressed_fmts += "astc "; } - _features[static_cast(GFXFeature::DEPTH_BOUNDS)] = true; - _features[static_cast(GFXFeature::LINE_WIDTH)] = true; - _features[static_cast(GFXFeature::STENCIL_COMPARE_MASK)] = true; - _features[static_cast(GFXFeature::STENCIL_WRITE_MASK)] = true; - _features[static_cast(GFXFeature::FORMAT_RGB8)] = true; + _features[static_cast(Feature::DEPTH_BOUNDS)] = true; + _features[static_cast(Feature::LINE_WIDTH)] = true; + _features[static_cast(Feature::STENCIL_COMPARE_MASK)] = true; + _features[static_cast(Feature::STENCIL_WRITE_MASK)] = true; + _features[static_cast(Feature::FORMAT_RGB8)] = true; if (checkExtension("depth_texture")) { - _features[static_cast(GFXFeature::FORMAT_D16)] = true; - _features[static_cast(GFXFeature::FORMAT_D24)] = true; - _features[static_cast(GFXFeature::FORMAT_D24S8)] = checkExtension("packed_depth_stencil"); + _features[static_cast(Feature::FORMAT_D16)] = true; + _features[static_cast(Feature::FORMAT_D24)] = true; + _features[static_cast(Feature::FORMAT_D24S8)] = checkExtension("packed_depth_stencil"); } _renderer = (const char *)glGetString(GL_RENDERER); @@ -118,11 +118,11 @@ bool GLES2Device::initialize(const GFXDeviceInfo &info) { CC_LOG_INFO("USE_VAO: %s", _useVAO ? "true" : "false"); CC_LOG_INFO("COMPRESSED_FORMATS: %s", compressed_fmts.c_str()); - GFXQueueInfo queue_info; - queue_info.type = GFXQueueType::GRAPHICS; + QueueInfo queue_info; + queue_info.type = QueueType::GRAPHICS; _queue = createQueue(queue_info); - GFXCommandAllocatorInfo cmd_alloc_info; + CommandAllocatorInfo cmd_alloc_info; _cmdAllocator = createCommandAllocator(cmd_alloc_info); glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, (GLint *)&_maxVertexAttributes); @@ -165,8 +165,8 @@ void GLES2Device::present() { queue->_numTriangles = 0; } -GFXFence *GLES2Device::createFence(const GFXFenceInfo &info) { - GFXFence *fence = CC_NEW(GLES2Fence(this)); +Fence *GLES2Device::createFence(const FenceInfo &info) { + Fence *fence = CC_NEW(GLES2Fence(this)); if (fence->initialize(info)) return fence; @@ -174,8 +174,8 @@ GFXFence *GLES2Device::createFence(const GFXFenceInfo &info) { return nullptr; } -GFXQueue *GLES2Device::createQueue(const GFXQueueInfo &info) { - GFXQueue *queue = CC_NEW(GLES2Queue(this)); +Queue *GLES2Device::createQueue(const QueueInfo &info) { + Queue *queue = CC_NEW(GLES2Queue(this)); if (queue->initialize(info)) return queue; @@ -183,8 +183,8 @@ GFXQueue *GLES2Device::createQueue(const GFXQueueInfo &info) { return nullptr; } -GFXCommandAllocator *GLES2Device::createCommandAllocator(const GFXCommandAllocatorInfo &info) { - GFXCommandAllocator *cmdAllocator = CC_NEW(GLES2CommandAllocator(this)); +CommandAllocator *GLES2Device::createCommandAllocator(const CommandAllocatorInfo &info) { + CommandAllocator *cmdAllocator = CC_NEW(GLES2CommandAllocator(this)); if (cmdAllocator->initialize(info)) return cmdAllocator; @@ -193,8 +193,8 @@ GFXCommandAllocator *GLES2Device::createCommandAllocator(const GFXCommandAllocat return nullptr; } -GFXCommandBuffer *GLES2Device::createCommandBuffer(const GFXCommandBufferInfo &info) { - GFXCommandBuffer *cmdBuff = CC_NEW(GLES2CommandBuffer(this)); +CommandBuffer *GLES2Device::createCommandBuffer(const CommandBufferInfo &info) { + CommandBuffer *cmdBuff = CC_NEW(GLES2CommandBuffer(this)); if (cmdBuff->initialize(info)) return cmdBuff; @@ -202,8 +202,8 @@ GFXCommandBuffer *GLES2Device::createCommandBuffer(const GFXCommandBufferInfo &i return nullptr; } -GFXBuffer *GLES2Device::createBuffer(const GFXBufferInfo &info) { - GFXBuffer *buffer = CC_NEW(GLES2Buffer(this)); +Buffer *GLES2Device::createBuffer(const BufferInfo &info) { + Buffer *buffer = CC_NEW(GLES2Buffer(this)); if (buffer->initialize(info)) return buffer; @@ -211,8 +211,8 @@ GFXBuffer *GLES2Device::createBuffer(const GFXBufferInfo &info) { return nullptr; } -GFXTexture *GLES2Device::createTexture(const GFXTextureInfo &info) { - GFXTexture *texture = CC_NEW(GLES2Texture(this)); +Texture *GLES2Device::createTexture(const TextureInfo &info) { + Texture *texture = CC_NEW(GLES2Texture(this)); if (texture->initialize(info)) return texture; @@ -220,8 +220,8 @@ GFXTexture *GLES2Device::createTexture(const GFXTextureInfo &info) { return nullptr; } -GFXTexture *GLES2Device::createTexture(const GFXTextureViewInfo &info) { - GFXTexture *texture = CC_NEW(GLES2Texture(this)); +Texture *GLES2Device::createTexture(const TextureViewInfo &info) { + Texture *texture = CC_NEW(GLES2Texture(this)); if (texture->initialize(info)) return texture; @@ -229,8 +229,8 @@ GFXTexture *GLES2Device::createTexture(const GFXTextureViewInfo &info) { return nullptr; } -GFXSampler *GLES2Device::createSampler(const GFXSamplerInfo &info) { - GFXSampler *sampler = CC_NEW(GLES2Sampler(this)); +Sampler *GLES2Device::createSampler(const SamplerInfo &info) { + Sampler *sampler = CC_NEW(GLES2Sampler(this)); if (sampler->initialize(info)) return sampler; @@ -238,8 +238,8 @@ GFXSampler *GLES2Device::createSampler(const GFXSamplerInfo &info) { return nullptr; } -GFXShader *GLES2Device::createShader(const GFXShaderInfo &info) { - GFXShader *shader = CC_NEW(GLES2Shader(this)); +Shader *GLES2Device::createShader(const ShaderInfo &info) { + Shader *shader = CC_NEW(GLES2Shader(this)); if (shader->initialize(info)) return shader; @@ -247,8 +247,8 @@ GFXShader *GLES2Device::createShader(const GFXShaderInfo &info) { return nullptr; } -GFXInputAssembler *GLES2Device::createInputAssembler(const GFXInputAssemblerInfo &info) { - GFXInputAssembler *inputAssembler = CC_NEW(GLES2InputAssembler(this)); +InputAssembler *GLES2Device::createInputAssembler(const InputAssemblerInfo &info) { + InputAssembler *inputAssembler = CC_NEW(GLES2InputAssembler(this)); if (inputAssembler->initialize(info)) return inputAssembler; @@ -256,8 +256,8 @@ GFXInputAssembler *GLES2Device::createInputAssembler(const GFXInputAssemblerInfo return nullptr; } -GFXRenderPass *GLES2Device::createRenderPass(const GFXRenderPassInfo &info) { - GFXRenderPass *renderPass = CC_NEW(GLES2RenderPass(this)); +RenderPass *GLES2Device::createRenderPass(const RenderPassInfo &info) { + RenderPass *renderPass = CC_NEW(GLES2RenderPass(this)); if (renderPass->initialize(info)) return renderPass; @@ -265,8 +265,8 @@ GFXRenderPass *GLES2Device::createRenderPass(const GFXRenderPassInfo &info) { return nullptr; } -GFXFramebuffer *GLES2Device::createFramebuffer(const GFXFramebufferInfo &info) { - GFXFramebuffer *framebuffer = CC_NEW(GLES2Framebuffer(this)); +Framebuffer *GLES2Device::createFramebuffer(const FramebufferInfo &info) { + Framebuffer *framebuffer = CC_NEW(GLES2Framebuffer(this)); if (framebuffer->initialize(info)) return framebuffer; @@ -274,8 +274,8 @@ GFXFramebuffer *GLES2Device::createFramebuffer(const GFXFramebufferInfo &info) { return nullptr; } -GFXBindingLayout *GLES2Device::createBindingLayout(const GFXBindingLayoutInfo &info) { - GFXBindingLayout *bindingLayout = CC_NEW(GLES2BindingLayout(this)); +BindingLayout *GLES2Device::createBindingLayout(const BindingLayoutInfo &info) { + BindingLayout *bindingLayout = CC_NEW(GLES2BindingLayout(this)); if (bindingLayout->initialize(info)) return bindingLayout; @@ -283,8 +283,8 @@ GFXBindingLayout *GLES2Device::createBindingLayout(const GFXBindingLayoutInfo &i return nullptr; } -GFXPipelineState *GLES2Device::createPipelineState(const GFXPipelineStateInfo &info) { - GFXPipelineState *pipelineState = CC_NEW(GLES2PipelineState(this)); +PipelineState *GLES2Device::createPipelineState(const PipelineStateInfo &info) { + PipelineState *pipelineState = CC_NEW(GLES2PipelineState(this)); if (pipelineState->initialize(info)) return pipelineState; @@ -292,8 +292,8 @@ GFXPipelineState *GLES2Device::createPipelineState(const GFXPipelineStateInfo &i return nullptr; } -GFXPipelineLayout *GLES2Device::createPipelineLayout(const GFXPipelineLayoutInfo &info) { - GFXPipelineLayout *layout = CC_NEW(GLES2PipelineLayout(this)); +PipelineLayout *GLES2Device::createPipelineLayout(const PipelineLayoutInfo &info) { + PipelineLayout *layout = CC_NEW(GLES2PipelineLayout(this)); if (layout->initialize(info)) return layout; @@ -301,7 +301,7 @@ GFXPipelineLayout *GLES2Device::createPipelineLayout(const GFXPipelineLayoutInfo return nullptr; } -void GLES2Device::copyBuffersToTexture(const GFXDataArray &buffers, GFXTexture *dst, const GFXBufferTextureCopyList ®ions) { +void GLES2Device::copyBuffersToTexture(const DataArray &buffers, Texture *dst, const BufferTextureCopyList ®ions) { GLES2CmdFuncCopyBuffersToTexture(this, buffers.datas.data(), ((GLES2Texture *)dst)->gpuTexture(), regions); } diff --git a/native/cocos/renderer/gfx-gles2/GLES2Device.h b/native/cocos/renderer/gfx-gles2/GLES2Device.h index 60e11c2f59..5e92294628 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Device.h +++ b/native/cocos/renderer/gfx-gles2/GLES2Device.h @@ -6,7 +6,7 @@ namespace gfx { class GLES2StateCache; -class CC_GLES2_API GLES2Device : public GFXDevice { +class CC_GLES2_API GLES2Device : public Device { public: GLES2Device(); ~GLES2Device(); @@ -14,27 +14,27 @@ public: GLES2StateCache *stateCache = nullptr; public: - virtual bool initialize(const GFXDeviceInfo &info) override; + virtual bool initialize(const DeviceInfo &info) override; virtual void destroy() override; virtual void resize(uint width, uint height) override; virtual void acquire() override{}; virtual void present() override; - virtual GFXFence *createFence(const GFXFenceInfo &info) override; - virtual GFXQueue *createQueue(const GFXQueueInfo &info) override; - virtual GFXCommandAllocator *createCommandAllocator(const GFXCommandAllocatorInfo &info) override; - virtual GFXCommandBuffer *createCommandBuffer(const GFXCommandBufferInfo &info) override; - virtual GFXBuffer *createBuffer(const GFXBufferInfo &info) override; - virtual GFXTexture *createTexture(const GFXTextureInfo &info) override; - virtual GFXTexture *createTexture(const GFXTextureViewInfo &info) override; - virtual GFXSampler *createSampler(const GFXSamplerInfo &info) override; - virtual GFXShader *createShader(const GFXShaderInfo &info) override; - virtual GFXInputAssembler *createInputAssembler(const GFXInputAssemblerInfo &info) override; - virtual GFXRenderPass *createRenderPass(const GFXRenderPassInfo &info) override; - virtual GFXFramebuffer *createFramebuffer(const GFXFramebufferInfo &info) override; - virtual GFXBindingLayout *createBindingLayout(const GFXBindingLayoutInfo &info) override; - virtual GFXPipelineState *createPipelineState(const GFXPipelineStateInfo &info) override; - virtual GFXPipelineLayout *createPipelineLayout(const GFXPipelineLayoutInfo &info) override; - virtual void copyBuffersToTexture(const GFXDataArray &buffers, GFXTexture *dst, const GFXBufferTextureCopyList ®ions) override; + virtual Fence *createFence(const FenceInfo &info) override; + virtual Queue *createQueue(const QueueInfo &info) override; + virtual CommandAllocator *createCommandAllocator(const CommandAllocatorInfo &info) override; + virtual CommandBuffer *createCommandBuffer(const CommandBufferInfo &info) override; + virtual Buffer *createBuffer(const BufferInfo &info) override; + virtual Texture *createTexture(const TextureInfo &info) override; + virtual Texture *createTexture(const TextureViewInfo &info) override; + virtual Sampler *createSampler(const SamplerInfo &info) override; + virtual Shader *createShader(const ShaderInfo &info) override; + virtual InputAssembler *createInputAssembler(const InputAssemblerInfo &info) override; + virtual RenderPass *createRenderPass(const RenderPassInfo &info) override; + virtual Framebuffer *createFramebuffer(const FramebufferInfo &info) override; + virtual BindingLayout *createBindingLayout(const BindingLayoutInfo &info) override; + virtual PipelineState *createPipelineState(const PipelineStateInfo &info) override; + virtual PipelineLayout *createPipelineLayout(const PipelineLayoutInfo &info) override; + virtual void copyBuffersToTexture(const DataArray &buffers, Texture *dst, const BufferTextureCopyList ®ions) override; CC_INLINE bool useVAO() const { return _useVAO; } CC_INLINE bool useDrawInstanced() const { return _useDrawInstanced; } diff --git a/native/cocos/renderer/gfx-gles2/GLES2Fence.cc b/native/cocos/renderer/gfx-gles2/GLES2Fence.cc index 83509994f8..6030425ed9 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Fence.cc +++ b/native/cocos/renderer/gfx-gles2/GLES2Fence.cc @@ -6,14 +6,14 @@ namespace cc { namespace gfx { -GLES2Fence::GLES2Fence(GFXDevice *device) -: GFXFence(device) { +GLES2Fence::GLES2Fence(Device *device) +: Fence(device) { } GLES2Fence::~GLES2Fence() { } -bool GLES2Fence::initialize(const GFXFenceInfo &info) { +bool GLES2Fence::initialize(const FenceInfo &info) { _gpuFence = CC_NEW(GLES2GPUFence); if (!_gpuFence) { CC_LOG_ERROR("GLES2Fence: CC_NEW GLES2GPUFence failed."); @@ -22,7 +22,7 @@ bool GLES2Fence::initialize(const GFXFenceInfo &info) { // TODO - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -33,7 +33,7 @@ void GLES2Fence::destroy() { CC_DELETE(_gpuFence); _gpuFence = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void GLES2Fence::wait() { diff --git a/native/cocos/renderer/gfx-gles2/GLES2Fence.h b/native/cocos/renderer/gfx-gles2/GLES2Fence.h index 569db86041..ab6b265922 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Fence.h +++ b/native/cocos/renderer/gfx-gles2/GLES2Fence.h @@ -6,13 +6,13 @@ namespace gfx { class GLES2GPUFence; -class CC_GLES2_API GLES2Fence : public GFXFence { +class CC_GLES2_API GLES2Fence : public Fence { public: - GLES2Fence(GFXDevice *device); + GLES2Fence(Device *device); ~GLES2Fence(); public: - virtual bool initialize(const GFXFenceInfo &info) override; + virtual bool initialize(const FenceInfo &info) override; virtual void destroy() override; virtual void wait() override; virtual void reset() override; diff --git a/native/cocos/renderer/gfx-gles2/GLES2Framebuffer.cc b/native/cocos/renderer/gfx-gles2/GLES2Framebuffer.cc index db3fa93200..00b0389a28 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Framebuffer.cc +++ b/native/cocos/renderer/gfx-gles2/GLES2Framebuffer.cc @@ -8,14 +8,14 @@ namespace cc { namespace gfx { -GLES2Framebuffer::GLES2Framebuffer(GFXDevice *device) -: GFXFramebuffer(device) { +GLES2Framebuffer::GLES2Framebuffer(Device *device) +: Framebuffer(device) { } GLES2Framebuffer::~GLES2Framebuffer() { } -bool GLES2Framebuffer::initialize(const GFXFramebufferInfo &info) { +bool GLES2Framebuffer::initialize(const FramebufferInfo &info) { _renderPass = info.renderPass; _colorTextures = info.colorTextures; @@ -58,7 +58,7 @@ bool GLES2Framebuffer::initialize(const GFXFramebufferInfo &info) { _gpuFBO->glFramebuffer = static_cast(_device->getContext())->getDefaultFramebuffer(); } #endif - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -69,7 +69,7 @@ void GLES2Framebuffer::destroy() { CC_DELETE(_gpuFBO); _gpuFBO = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-gles2/GLES2Framebuffer.h b/native/cocos/renderer/gfx-gles2/GLES2Framebuffer.h index 5e3f6f5931..c56bfff815 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Framebuffer.h +++ b/native/cocos/renderer/gfx-gles2/GLES2Framebuffer.h @@ -6,13 +6,13 @@ namespace gfx { class GLES2GPUFramebuffer; -class CC_GLES2_API GLES2Framebuffer : public GFXFramebuffer { +class CC_GLES2_API GLES2Framebuffer : public Framebuffer { public: - GLES2Framebuffer(GFXDevice *device); + GLES2Framebuffer(Device *device); ~GLES2Framebuffer(); public: - virtual bool initialize(const GFXFramebufferInfo &info) override; + virtual bool initialize(const FramebufferInfo &info) override; virtual void destroy() override; CC_INLINE GLES2GPUFramebuffer *gpuFBO() const { return _gpuFBO; } diff --git a/native/cocos/renderer/gfx-gles2/GLES2GPUObjects.h b/native/cocos/renderer/gfx-gles2/GLES2GPUObjects.h index b384629c7a..22cdda69d2 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2GPUObjects.h +++ b/native/cocos/renderer/gfx-gles2/GLES2GPUObjects.h @@ -8,31 +8,31 @@ namespace gfx { class GLES2GPUBuffer : public Object { public: - GFXBufferUsage usage = GFXBufferUsage::NONE; - GFXMemoryUsage memUsage = GFXMemoryUsage::NONE; + BufferUsage usage = BufferUsage::NONE; + MemoryUsage memUsage = MemoryUsage::NONE; uint size = 0; uint stride = 0; uint count = 0; GLenum glTarget = 0; GLuint glBuffer = 0; uint8_t *buffer = nullptr; - GFXDrawInfoList indirects; + DrawInfoList indirects; }; typedef vector GLES2GPUBufferList; class GLES2GPUTexture : public Object { public: - GFXTextureType type = GFXTextureType::TEX2D; - GFXFormat format = GFXFormat::UNKNOWN; - GFXTextureUsage usage = GFXTextureUsageBit::NONE; + TextureType type = TextureType::TEX2D; + Format format = Format::UNKNOWN; + TextureUsage usage = TextureUsageBit::NONE; uint width = 0; uint height = 0; uint depth = 1; uint size = 0; uint arrayLayer = 1; uint mipLevel = 1; - GFXSampleCount samples = GFXSampleCount::X1; - GFXTextureFlags flags = GFXTextureFlagBit::NONE; + SampleCount samples = SampleCount::X1; + TextureFlags flags = TextureFlagBit::NONE; bool isPowerOf2 = false; GLenum glTarget = 0; GLenum glInternelFmt = 0; @@ -50,12 +50,12 @@ typedef vector GLES2GPUTextureList; class GLES2GPUSampler : public Object { public: - GFXFilter minFilter = GFXFilter::NONE; - GFXFilter magFilter = GFXFilter::NONE; - GFXFilter mipFilter = GFXFilter::NONE; - GFXAddress addressU = GFXAddress::CLAMP; - GFXAddress addressV = GFXAddress::CLAMP; - GFXAddress addressW = GFXAddress::CLAMP; + Filter minFilter = Filter::NONE; + Filter magFilter = Filter::NONE; + Filter mipFilter = Filter::NONE; + Address addressU = Address::CLAMP; + Address addressV = Address::CLAMP; + Address addressW = Address::CLAMP; uint minLOD = 0; uint maxLOD = 1000; GLenum glMinFilter = 0; @@ -68,7 +68,7 @@ public: struct GLES2GPUInput { uint binding = 0; String name; - GFXType type = GFXType::UNKNOWN; + Type type = Type::UNKNOWN; uint stride = 0; uint count = 0; uint size = 0; @@ -80,7 +80,7 @@ typedef vector GLES2GPUInputList; struct GLES2GPUUniform { uint binding = GFX_INVALID_BINDING; String name; - GFXType type = GFXType::UNKNOWN; + Type type = Type::UNKNOWN; uint stride = 0; uint count = 0; uint size = 0; @@ -134,7 +134,7 @@ typedef vector GLES2GPUUniformBlockList; struct GLES2GPUUniformSampler { uint binding = 0; String name; - GFXType type = GFXType::UNKNOWN; + Type type = Type::UNKNOWN; vector units; GLenum glType = 0; GLint glLoc = -1; @@ -142,11 +142,11 @@ struct GLES2GPUUniformSampler { typedef vector GLES2GPUUniformSamplerList; struct GLES2GPUShaderStage { - GLES2GPUShaderStage(GFXShaderType t, String s, GFXShaderMacroList m, GLuint shader = 0) + GLES2GPUShaderStage(ShaderType t, String s, ShaderMacroList m, GLuint shader = 0) : type(t), source(s), macros(m), glShader(shader) {} - GFXShaderType type; + ShaderType type; String source; - GFXShaderMacroList macros; + ShaderMacroList macros; GLuint glShader = 0; }; typedef vector GLES2GPUShaderStageList; @@ -154,8 +154,8 @@ typedef vector GLES2GPUShaderStageList; class GLES2GPUShader : public Object { public: String name; - GFXUniformBlockList blocks; - GFXUniformSamplerList samplers; + UniformBlockList blocks; + UniformSamplerList samplers; GLuint glProgram = 0; GLES2GPUShaderStageList gpuStages; GLES2GPUInputList glInputs; @@ -179,7 +179,7 @@ typedef vector GLES2GPUAttributeList; class GLES2GPUInputAssembler : public Object { public: - GFXAttributeList attributes; + AttributeList attributes; GLES2GPUBufferList gpuVertexBuffers; GLES2GPUBuffer *gpuIndexBuffer = nullptr; GLES2GPUBuffer *gpuIndirectBuffer = nullptr; @@ -190,8 +190,8 @@ public: class GLES2GPURenderPass : public Object { public: - GFXColorAttachmentList colorAttachments; - GFXDepthStencilAttachment depthStencilAttachment; + ColorAttachmentList colorAttachments; + DepthStencilAttachment depthStencilAttachment; }; class GLES2GPUFramebuffer : public Object { @@ -211,17 +211,17 @@ class GLES2GPUPipelineState : public Object { public: GLenum glPrimitive = GL_TRIANGLES; GLES2GPUShader *gpuShader = nullptr; - GFXRasterizerState rs; - GFXDepthStencilState dss; - GFXBlendState bs; - GFXDynamicStateList dynamicStates; + RasterizerState rs; + DepthStencilState dss; + BlendState bs; + DynamicStateList dynamicStates; GLES2GPUPipelineLayout *gpuLayout = nullptr; GLES2GPURenderPass *gpuRenderPass = nullptr; }; struct GLES2GPUBinding { uint binding = GFX_INVALID_BINDING; - GFXBindingType type = GFXBindingType::UNKNOWN; + BindingType type = BindingType::UNKNOWN; String name; GLES2GPUBuffer *gpuBuffer = nullptr; GLES2GPUTexture *gpuTexture = nullptr; diff --git a/native/cocos/renderer/gfx-gles2/GLES2InputAssembler.cc b/native/cocos/renderer/gfx-gles2/GLES2InputAssembler.cc index 2b124f187d..b3b7bed273 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2InputAssembler.cc +++ b/native/cocos/renderer/gfx-gles2/GLES2InputAssembler.cc @@ -6,14 +6,14 @@ namespace cc { namespace gfx { -GLES2InputAssembler::GLES2InputAssembler(GFXDevice *device) -: GFXInputAssembler(device) { +GLES2InputAssembler::GLES2InputAssembler(Device *device) +: InputAssembler(device) { } GLES2InputAssembler::~GLES2InputAssembler() { } -bool GLES2InputAssembler::initialize(const GFXInputAssemblerInfo &info) { +bool GLES2InputAssembler::initialize(const InputAssemblerInfo &info) { _attributes = info.attributes; _vertexBuffers = info.vertexBuffers; @@ -41,7 +41,7 @@ bool GLES2InputAssembler::initialize(const GFXInputAssemblerInfo &info) { GLES2CmdFuncCreateInputAssembler((GLES2Device *)_device, _gpuInputAssembler); _attributesHash = computeAttributesHash(); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -52,7 +52,7 @@ void GLES2InputAssembler::destroy() { CC_DELETE(_gpuInputAssembler); _gpuInputAssembler = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void GLES2InputAssembler::ExtractCmdDraw(GLES2CmdDraw *cmd) { diff --git a/native/cocos/renderer/gfx-gles2/GLES2InputAssembler.h b/native/cocos/renderer/gfx-gles2/GLES2InputAssembler.h index 54082159c4..13e1a89abc 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2InputAssembler.h +++ b/native/cocos/renderer/gfx-gles2/GLES2InputAssembler.h @@ -7,13 +7,13 @@ namespace gfx { class GLES2GPUInputAssembler; class GLES2CmdDraw; -class CC_GLES2_API GLES2InputAssembler : public GFXInputAssembler { +class CC_GLES2_API GLES2InputAssembler : public InputAssembler { public: - GLES2InputAssembler(GFXDevice *device); + GLES2InputAssembler(Device *device); ~GLES2InputAssembler(); public: - virtual bool initialize(const GFXInputAssemblerInfo &info) override; + virtual bool initialize(const InputAssemblerInfo &info) override; virtual void destroy() override; void ExtractCmdDraw(GLES2CmdDraw *cmd); diff --git a/native/cocos/renderer/gfx-gles2/GLES2PipelineLayout.cc b/native/cocos/renderer/gfx-gles2/GLES2PipelineLayout.cc index bc4fb94055..a1a562a35a 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2PipelineLayout.cc +++ b/native/cocos/renderer/gfx-gles2/GLES2PipelineLayout.cc @@ -5,20 +5,20 @@ namespace cc { namespace gfx { -GLES2PipelineLayout::GLES2PipelineLayout(GFXDevice *device) -: GFXPipelineLayout(device) { +GLES2PipelineLayout::GLES2PipelineLayout(Device *device) +: PipelineLayout(device) { } GLES2PipelineLayout::~GLES2PipelineLayout() { } -bool GLES2PipelineLayout::initialize(const GFXPipelineLayoutInfo &info) { +bool GLES2PipelineLayout::initialize(const PipelineLayoutInfo &info) { _layouts = info.layouts; _pushConstantsRanges = info.pushConstantsRanges; _gpuPipelineLayout = CC_NEW(GLES2GPUPipelineLayout); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -28,7 +28,7 @@ void GLES2PipelineLayout::destroy() { _gpuPipelineLayout = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-gles2/GLES2PipelineLayout.h b/native/cocos/renderer/gfx-gles2/GLES2PipelineLayout.h index ef12925739..54d791b93c 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2PipelineLayout.h +++ b/native/cocos/renderer/gfx-gles2/GLES2PipelineLayout.h @@ -6,13 +6,13 @@ namespace gfx { class GLES2GPUPipelineLayout; -class CC_GLES2_API GLES2PipelineLayout : public GFXPipelineLayout { +class CC_GLES2_API GLES2PipelineLayout : public PipelineLayout { public: - GLES2PipelineLayout(GFXDevice *device); + GLES2PipelineLayout(Device *device); ~GLES2PipelineLayout(); public: - virtual bool initialize(const GFXPipelineLayoutInfo &info) override; + virtual bool initialize(const PipelineLayoutInfo &info) override; virtual void destroy() override; CC_INLINE GLES2GPUPipelineLayout *gpuPipelineLayout() const { return _gpuPipelineLayout; } diff --git a/native/cocos/renderer/gfx-gles2/GLES2PipelineState.cc b/native/cocos/renderer/gfx-gles2/GLES2PipelineState.cc index 79d5fd149e..237e08f10b 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2PipelineState.cc +++ b/native/cocos/renderer/gfx-gles2/GLES2PipelineState.cc @@ -25,14 +25,14 @@ const GLenum GLES2Primitives[] = { GL_NONE, }; -GLES2PipelineState::GLES2PipelineState(GFXDevice *device) -: GFXPipelineState(device) { +GLES2PipelineState::GLES2PipelineState(Device *device) +: PipelineState(device) { } GLES2PipelineState::~GLES2PipelineState() { } -bool GLES2PipelineState::initialize(const GFXPipelineStateInfo &info) { +bool GLES2PipelineState::initialize(const PipelineStateInfo &info) { _primitive = info.primitive; _shader = info.shader; @@ -54,7 +54,7 @@ bool GLES2PipelineState::initialize(const GFXPipelineStateInfo &info) { _gpuPipelineState->gpuLayout = ((GLES2PipelineLayout *)_layout)->gpuPipelineLayout(); _gpuPipelineState->gpuRenderPass = ((GLES2RenderPass *)_renderPass)->gpuRenderPass(); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -65,7 +65,7 @@ void GLES2PipelineState::destroy() { _gpuPipelineState = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-gles2/GLES2PipelineState.h b/native/cocos/renderer/gfx-gles2/GLES2PipelineState.h index ffb53f1b23..e5c29e5a56 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2PipelineState.h +++ b/native/cocos/renderer/gfx-gles2/GLES2PipelineState.h @@ -6,13 +6,13 @@ namespace gfx { class GLES2GPUPipelineState; -class CC_GLES2_API GLES2PipelineState : public GFXPipelineState { +class CC_GLES2_API GLES2PipelineState : public PipelineState { public: - GLES2PipelineState(GFXDevice *device); + GLES2PipelineState(Device *device); ~GLES2PipelineState(); public: - virtual bool initialize(const GFXPipelineStateInfo &info) override; + virtual bool initialize(const PipelineStateInfo &info) override; virtual void destroy() override; CC_INLINE GLES2GPUPipelineState *gpuPipelineState() const { return _gpuPipelineState; } diff --git a/native/cocos/renderer/gfx-gles2/GLES2Queue.cc b/native/cocos/renderer/gfx-gles2/GLES2Queue.cc index a2b090550c..19d81938e6 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Queue.cc +++ b/native/cocos/renderer/gfx-gles2/GLES2Queue.cc @@ -6,25 +6,25 @@ namespace cc { namespace gfx { -GLES2Queue::GLES2Queue(GFXDevice *device) -: GFXQueue(device) { +GLES2Queue::GLES2Queue(Device *device) +: Queue(device) { } GLES2Queue::~GLES2Queue() { } -bool GLES2Queue::initialize(const GFXQueueInfo &info) { +bool GLES2Queue::initialize(const QueueInfo &info) { _type = info.type; - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } void GLES2Queue::destroy() { - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } -void GLES2Queue::submit(const vector &cmdBuffs, GFXFence *fence) { +void GLES2Queue::submit(const vector &cmdBuffs, Fence *fence) { if (!_isAsync) { uint count = static_cast(cmdBuffs.size()); for (uint i = 0; i < count; ++i) { diff --git a/native/cocos/renderer/gfx-gles2/GLES2Queue.h b/native/cocos/renderer/gfx-gles2/GLES2Queue.h index 2634448e3f..ac0b265b35 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Queue.h +++ b/native/cocos/renderer/gfx-gles2/GLES2Queue.h @@ -4,17 +4,17 @@ namespace cc { namespace gfx { -class CC_GLES2_API GLES2Queue : public GFXQueue { +class CC_GLES2_API GLES2Queue : public Queue { public: - GLES2Queue(GFXDevice *device); + GLES2Queue(Device *device); ~GLES2Queue(); friend class GLES2Device; public: - virtual bool initialize(const GFXQueueInfo &info) override; + virtual bool initialize(const QueueInfo &info) override; virtual void destroy() override; - virtual void submit(const vector &cmdBuffs, GFXFence *fence) override; + virtual void submit(const vector &cmdBuffs, Fence *fence) override; private: uint _numDrawCalls = 0; diff --git a/native/cocos/renderer/gfx-gles2/GLES2RenderPass.cc b/native/cocos/renderer/gfx-gles2/GLES2RenderPass.cc index aa1663d6cf..8095028c5d 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2RenderPass.cc +++ b/native/cocos/renderer/gfx-gles2/GLES2RenderPass.cc @@ -5,14 +5,14 @@ namespace cc { namespace gfx { -GLES2RenderPass::GLES2RenderPass(GFXDevice *device) -: GFXRenderPass(device) { +GLES2RenderPass::GLES2RenderPass(Device *device) +: RenderPass(device) { } GLES2RenderPass::~GLES2RenderPass() { } -bool GLES2RenderPass::initialize(const GFXRenderPassInfo &info) { +bool GLES2RenderPass::initialize(const RenderPassInfo &info) { _colorAttachments = info.colorAttachments; _depthStencilAttachment = info.depthStencilAttachment; @@ -22,7 +22,7 @@ bool GLES2RenderPass::initialize(const GFXRenderPassInfo &info) { _gpuRenderPass->depthStencilAttachment = _depthStencilAttachment; _hash = computeHash(); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -33,7 +33,7 @@ void GLES2RenderPass::destroy() { _gpuRenderPass = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-gles2/GLES2RenderPass.h b/native/cocos/renderer/gfx-gles2/GLES2RenderPass.h index 493a3a4f7f..41b1f8d78f 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2RenderPass.h +++ b/native/cocos/renderer/gfx-gles2/GLES2RenderPass.h @@ -6,13 +6,13 @@ namespace gfx { class GLES2GPURenderPass; -class CC_GLES2_API GLES2RenderPass : public GFXRenderPass { +class CC_GLES2_API GLES2RenderPass : public RenderPass { public: - GLES2RenderPass(GFXDevice *device); + GLES2RenderPass(Device *device); ~GLES2RenderPass(); public: - virtual bool initialize(const GFXRenderPassInfo &info) override; + virtual bool initialize(const RenderPassInfo &info) override; virtual void destroy() override; CC_INLINE GLES2GPURenderPass *gpuRenderPass() const { return _gpuRenderPass; } diff --git a/native/cocos/renderer/gfx-gles2/GLES2Sampler.cc b/native/cocos/renderer/gfx-gles2/GLES2Sampler.cc index b8d5284dc9..3e671c0e4b 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Sampler.cc +++ b/native/cocos/renderer/gfx-gles2/GLES2Sampler.cc @@ -5,14 +5,14 @@ namespace cc { namespace gfx { -GLES2Sampler::GLES2Sampler(GFXDevice *device) -: GFXSampler(device) { +GLES2Sampler::GLES2Sampler(Device *device) +: Sampler(device) { } GLES2Sampler::~GLES2Sampler() { } -bool GLES2Sampler::initialize(const GFXSamplerInfo &info) { +bool GLES2Sampler::initialize(const SamplerInfo &info) { _name = info.name; _minFilter = info.minFilter; _magFilter = info.magFilter; @@ -37,7 +37,7 @@ bool GLES2Sampler::initialize(const GFXSamplerInfo &info) { _gpuSampler->minLOD = _minLOD; _gpuSampler->maxLOD = _maxLOD; - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; GLES2CmdFuncCreateSampler((GLES2Device *)_device, _gpuSampler); @@ -50,7 +50,7 @@ void GLES2Sampler::destroy() { CC_DELETE(_gpuSampler); _gpuSampler = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-gles2/GLES2Sampler.h b/native/cocos/renderer/gfx-gles2/GLES2Sampler.h index f8f289c0e2..1e87322160 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Sampler.h +++ b/native/cocos/renderer/gfx-gles2/GLES2Sampler.h @@ -6,13 +6,13 @@ namespace gfx { class GLES2GPUSampler; -class CC_GLES2_API GLES2Sampler : public GFXSampler { +class CC_GLES2_API GLES2Sampler : public Sampler { public: - GLES2Sampler(GFXDevice *device); + GLES2Sampler(Device *device); ~GLES2Sampler(); public: - virtual bool initialize(const GFXSamplerInfo &info) override; + virtual bool initialize(const SamplerInfo &info) override; virtual void destroy() override; CC_INLINE GLES2GPUSampler *gpuSampler() const { return _gpuSampler; } @@ -20,15 +20,15 @@ public: private: GLES2GPUSampler *_gpuSampler = nullptr; String _name; - GFXFilter _minFilter = GFXFilter::LINEAR; - GFXFilter _magFilter = GFXFilter::LINEAR; - GFXFilter _mipFilter = GFXFilter::NONE; - GFXAddress _addressU = GFXAddress::WRAP; - GFXAddress _addressV = GFXAddress::WRAP; - GFXAddress _addressW = GFXAddress::WRAP; + Filter _minFilter = Filter::LINEAR; + Filter _magFilter = Filter::LINEAR; + Filter _mipFilter = Filter::NONE; + Address _addressU = Address::WRAP; + Address _addressV = Address::WRAP; + Address _addressW = Address::WRAP; uint _maxAnisotropy = 16; - GFXComparisonFunc _cmpFunc = GFXComparisonFunc::NEVER; - GFXColor _borderColor; + ComparisonFunc _cmpFunc = ComparisonFunc::NEVER; + Color _borderColor; uint _minLOD = 0; uint _maxLOD = 1000; float _mipLODBias = 0.0f; diff --git a/native/cocos/renderer/gfx-gles2/GLES2Shader.cc b/native/cocos/renderer/gfx-gles2/GLES2Shader.cc index ef18542711..0b2bd68b97 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Shader.cc +++ b/native/cocos/renderer/gfx-gles2/GLES2Shader.cc @@ -5,14 +5,14 @@ namespace cc { namespace gfx { -GLES2Shader::GLES2Shader(GFXDevice *device) -: GFXShader(device) { +GLES2Shader::GLES2Shader(Device *device) +: Shader(device) { } GLES2Shader::~GLES2Shader() { } -bool GLES2Shader::initialize(const GFXShaderInfo &info) { +bool GLES2Shader::initialize(const ShaderInfo &info) { _name = info.name; _stages = info.stages; _attributes = info.attributes; @@ -30,7 +30,7 @@ bool GLES2Shader::initialize(const GFXShaderInfo &info) { GLES2CmdFuncCreateShader((GLES2Device *)_device, _gpuShader); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -41,7 +41,7 @@ void GLES2Shader::destroy() { CC_DELETE(_gpuShader); _gpuShader = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-gles2/GLES2Shader.h b/native/cocos/renderer/gfx-gles2/GLES2Shader.h index 97c79b0d97..ab911fe8e7 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Shader.h +++ b/native/cocos/renderer/gfx-gles2/GLES2Shader.h @@ -6,13 +6,13 @@ namespace gfx { class GLES2GPUShader; -class CC_GLES2_API GLES2Shader : public GFXShader { +class CC_GLES2_API GLES2Shader : public Shader { public: - GLES2Shader(GFXDevice *device); + GLES2Shader(Device *device); ~GLES2Shader(); public: - virtual bool initialize(const GFXShaderInfo &info) override; + virtual bool initialize(const ShaderInfo &info) override; virtual void destroy() override; CC_INLINE GLES2GPUShader *gpuShader() const { return _gpuShader; } diff --git a/native/cocos/renderer/gfx-gles2/GLES2StateCache.h b/native/cocos/renderer/gfx-gles2/GLES2StateCache.h index 80cdebeb27..e95ceb8b5a 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2StateCache.h +++ b/native/cocos/renderer/gfx-gles2/GLES2StateCache.h @@ -21,11 +21,11 @@ public: bool glCurrentAttribLocs[GFX_MAX_VERTEX_ATTRIBUTES] = {false}; GLuint glFramebuffer = 0; GLuint glReadFBO = 0; - GFXViewport viewport; - GFXRect scissor; - GFXRasterizerState rs; - GFXDepthStencilState dss; - GFXBlendState bs; + Viewport viewport; + Rect scissor; + RasterizerState rs; + DepthStencilState dss; + BlendState bs; bool isCullFaceEnabled = true; bool isStencilTestEnabled = false; diff --git a/native/cocos/renderer/gfx-gles2/GLES2Texture.cc b/native/cocos/renderer/gfx-gles2/GLES2Texture.cc index 94cc7bd122..8e5ddce50a 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Texture.cc +++ b/native/cocos/renderer/gfx-gles2/GLES2Texture.cc @@ -6,14 +6,14 @@ namespace cc { namespace gfx { -GLES2Texture::GLES2Texture(GFXDevice *device) -: GFXTexture(device) { +GLES2Texture::GLES2Texture(Device *device) +: Texture(device) { } GLES2Texture::~GLES2Texture() { } -bool GLES2Texture::initialize(const GFXTextureInfo &info) { +bool GLES2Texture::initialize(const TextureInfo &info) { _type = info.type; _usage = info.usage; @@ -25,45 +25,45 @@ bool GLES2Texture::initialize(const GFXTextureInfo &info) { _mipLevel = info.mipLevel; _samples = info.samples; _flags = info.flags; - _size = GFXFormatSize(_format, _width, _height, _depth); + _size = FormatSize(_format, _width, _height, _depth); #if COCOS2D_DEBUG > 0 switch (_format) { // device feature validation - case GFXFormat::D16: - if (_device->hasFeature(GFXFeature::FORMAT_D16)) break; + case Format::D16: + if (_device->hasFeature(Feature::FORMAT_D16)) break; CC_LOG_ERROR("D16 texture format is not supported on this backend"); return false; - case GFXFormat::D16S8: - if (_device->hasFeature(GFXFeature::FORMAT_D16S8)) break; + case Format::D16S8: + if (_device->hasFeature(Feature::FORMAT_D16S8)) break; CC_LOG_WARNING("D16S8 texture format is not supported on this backend"); return false; - case GFXFormat::D24: - if (_device->hasFeature(GFXFeature::FORMAT_D24)) break; + case Format::D24: + if (_device->hasFeature(Feature::FORMAT_D24)) break; CC_LOG_WARNING("D24 texture format is not supported on this backend"); return false; - case GFXFormat::D24S8: - if (_device->hasFeature(GFXFeature::FORMAT_D24S8)) break; + case Format::D24S8: + if (_device->hasFeature(Feature::FORMAT_D24S8)) break; CC_LOG_WARNING("D24S8 texture format is not supported on this backend"); return false; - case GFXFormat::D32F: - if (_device->hasFeature(GFXFeature::FORMAT_D32F)) break; + case Format::D32F: + if (_device->hasFeature(Feature::FORMAT_D32F)) break; CC_LOG_WARNING("D32F texture format is not supported on this backend"); return false; - case GFXFormat::D32F_S8: - if (_device->hasFeature(GFXFeature::FORMAT_D32FS8)) break; + case Format::D32F_S8: + if (_device->hasFeature(Feature::FORMAT_D32FS8)) break; CC_LOG_WARNING("D32FS8 texture format is not supported on this backend"); return false; - case GFXFormat::RGB8: - if (_device->hasFeature(GFXFeature::FORMAT_RGB8)) break; + case Format::RGB8: + if (_device->hasFeature(Feature::FORMAT_RGB8)) break; CC_LOG_WARNING("RGB8 texture format is not supported on this backend"); return false; } #endif - if (_flags & GFXTextureFlags::BAKUP_BUFFER) { + if (_flags & TextureFlags::BAKUP_BUFFER) { _buffer = (uint8_t *)CC_MALLOC(_size); if (!_buffer) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CC_LOG_ERROR("GLES2Texture: CC_MALLOC backup buffer failed."); return false; } @@ -72,7 +72,7 @@ bool GLES2Texture::initialize(const GFXTextureInfo &info) { _gpuTexture = CC_NEW(GLES2GPUTexture); if (!_gpuTexture) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CC_LOG_ERROR("GLES2Texture: CC_NEW GLES2GPUTexture failed."); return false; } @@ -91,13 +91,13 @@ bool GLES2Texture::initialize(const GFXTextureInfo &info) { GLES2CmdFuncCreateTexture((GLES2Device *)_device, _gpuTexture); _device->getMemoryStatus().textureSize += _size; - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } -bool GLES2Texture::initialize(const GFXTextureViewInfo &info) { +bool GLES2Texture::initialize(const TextureViewInfo &info) { CC_LOG_ERROR("GLES2 doesn't support texture view"); - _status = GFXStatus::FAILED; + _status = Status::FAILED; return false; } @@ -115,18 +115,18 @@ void GLES2Texture::destroy() { _buffer = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void GLES2Texture::resize(uint width, uint height) { - uint size = GFXFormatSize(_format, width, height, _depth); + uint size = FormatSize(_format, width, height, _depth); if (_size != size) { const uint oldSize = _size; _width = width; _height = height; _size = size; - GFXMemoryStatus &status = _device->getMemoryStatus(); + MemoryStatus &status = _device->getMemoryStatus(); _gpuTexture->width = _width; _gpuTexture->height = _height; _gpuTexture->size = _size; @@ -138,7 +138,7 @@ void GLES2Texture::resize(uint width, uint height) { const uint8_t *oldBuffer = _buffer; uint8_t *buffer = (uint8_t *)CC_MALLOC(_size); if (!buffer) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CC_LOG_ERROR("GLES2Texture: CC_MALLOC backup buffer failed when resize the texture."); return; } @@ -148,7 +148,7 @@ void GLES2Texture::resize(uint width, uint height) { status.bufferSize -= oldSize; status.bufferSize += _size; } - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; } } diff --git a/native/cocos/renderer/gfx-gles2/GLES2Texture.h b/native/cocos/renderer/gfx-gles2/GLES2Texture.h index c2543a0ef7..79eb780576 100644 --- a/native/cocos/renderer/gfx-gles2/GLES2Texture.h +++ b/native/cocos/renderer/gfx-gles2/GLES2Texture.h @@ -6,14 +6,14 @@ namespace gfx { class GLES2GPUTexture; -class CC_GLES2_API GLES2Texture : public GFXTexture { +class CC_GLES2_API GLES2Texture : public Texture { public: - GLES2Texture(GFXDevice *device); + GLES2Texture(Device *device); ~GLES2Texture(); public: - virtual bool initialize(const GFXTextureInfo &info) override; - virtual bool initialize(const GFXTextureViewInfo &info) override; + virtual bool initialize(const TextureInfo &info) override; + virtual bool initialize(const TextureViewInfo &info) override; virtual void destroy() override; virtual void resize(uint width, uint height) override; diff --git a/native/cocos/renderer/gfx-gles3/GLES3BindingLayout.cc b/native/cocos/renderer/gfx-gles3/GLES3BindingLayout.cc index adc9d199b5..0e2d440fab 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3BindingLayout.cc +++ b/native/cocos/renderer/gfx-gles3/GLES3BindingLayout.cc @@ -8,20 +8,20 @@ namespace cc { namespace gfx { -GLES3BindingLayout::GLES3BindingLayout(GFXDevice *device) -: GFXBindingLayout(device) { +GLES3BindingLayout::GLES3BindingLayout(Device *device) +: BindingLayout(device) { } GLES3BindingLayout::~GLES3BindingLayout() { } -bool GLES3BindingLayout::initialize(const GFXBindingLayoutInfo &info) { +bool GLES3BindingLayout::initialize(const BindingLayoutInfo &info) { if (info.bindings.size()) { _bindingUnits.resize(info.bindings.size()); for (size_t i = 0; i < _bindingUnits.size(); ++i) { - GFXBindingUnit &bindingUnit = _bindingUnits[i]; - const GFXBinding &binding = info.bindings[i]; + BindingUnit &bindingUnit = _bindingUnits[i]; + const Binding &binding = info.bindings[i]; bindingUnit.shaderStages = binding.shaderStages; bindingUnit.binding = binding.binding; bindingUnit.type = binding.type; @@ -33,13 +33,13 @@ bool GLES3BindingLayout::initialize(const GFXBindingLayoutInfo &info) { _gpuBindingLayout->gpuBindings.resize(_bindingUnits.size()); for (size_t i = 0; i < _gpuBindingLayout->gpuBindings.size(); ++i) { GLES3GPUBinding &gpuBinding = _gpuBindingLayout->gpuBindings[i]; - const GFXBindingUnit &bindingUnit = _bindingUnits[i]; + const BindingUnit &bindingUnit = _bindingUnits[i]; gpuBinding.binding = bindingUnit.binding; gpuBinding.type = bindingUnit.type; gpuBinding.name = bindingUnit.name; } - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -50,21 +50,21 @@ void GLES3BindingLayout::destroy() { _gpuBindingLayout = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void GLES3BindingLayout::update() { if (_isDirty && _gpuBindingLayout) { for (size_t i = 0; i < _bindingUnits.size(); ++i) { - GFXBindingUnit &bindingUnit = _bindingUnits[i]; + BindingUnit &bindingUnit = _bindingUnits[i]; switch (bindingUnit.type) { - case GFXBindingType::UNIFORM_BUFFER: { + case BindingType::UNIFORM_BUFFER: { if (bindingUnit.buffer) { _gpuBindingLayout->gpuBindings[i].gpuBuffer = ((GLES3Buffer *)bindingUnit.buffer)->gpuBuffer(); } break; } - case GFXBindingType::SAMPLER: { + case BindingType::SAMPLER: { if (bindingUnit.texture) { _gpuBindingLayout->gpuBindings[i].gpuTexture = ((GLES3Texture *)bindingUnit.texture)->gpuTexture(); } diff --git a/native/cocos/renderer/gfx-gles3/GLES3BindingLayout.h b/native/cocos/renderer/gfx-gles3/GLES3BindingLayout.h index 3707ef8d84..a5f56c2351 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3BindingLayout.h +++ b/native/cocos/renderer/gfx-gles3/GLES3BindingLayout.h @@ -6,13 +6,13 @@ namespace gfx { class GLES3GPUBindingLayout; -class CC_GLES3_API GLES3BindingLayout : public GFXBindingLayout { +class CC_GLES3_API GLES3BindingLayout : public BindingLayout { public: - GLES3BindingLayout(GFXDevice *device); + GLES3BindingLayout(Device *device); ~GLES3BindingLayout(); public: - virtual bool initialize(const GFXBindingLayoutInfo &info) override; + virtual bool initialize(const BindingLayoutInfo &info) override; virtual void destroy() override; virtual void update() override; diff --git a/native/cocos/renderer/gfx-gles3/GLES3Buffer.cc b/native/cocos/renderer/gfx-gles3/GLES3Buffer.cc index bd301c3eca..cd9ee7e618 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Buffer.cc +++ b/native/cocos/renderer/gfx-gles3/GLES3Buffer.cc @@ -5,14 +5,14 @@ namespace cc { namespace gfx { -GLES3Buffer::GLES3Buffer(GFXDevice *device) -: GFXBuffer(device) { +GLES3Buffer::GLES3Buffer(Device *device) +: Buffer(device) { } GLES3Buffer::~GLES3Buffer() { } -bool GLES3Buffer::initialize(const GFXBufferInfo &info) { +bool GLES3Buffer::initialize(const BufferInfo &info) { _usage = info.usage; _memUsage = info.memUsage; _size = info.size; @@ -20,10 +20,10 @@ bool GLES3Buffer::initialize(const GFXBufferInfo &info) { _count = _size / _stride; _flags = info.flags; - if ((_flags & GFXBufferFlagBit::BAKUP_BUFFER) && _size > 0) { + if ((_flags & BufferFlagBit::BAKUP_BUFFER) && _size > 0) { _buffer = (uint8_t *)CC_MALLOC(_size); if (!_buffer) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CC_LOG_ERROR("GLES3Buffer: CC_MALLOC backup buffer failed."); return false; } @@ -32,7 +32,7 @@ bool GLES3Buffer::initialize(const GFXBufferInfo &info) { _gpuBuffer = CC_NEW(GLES3GPUBuffer); if (!_gpuBuffer) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CC_LOG_ERROR("GLES3Buffer: CC_NEW GLES3GPUBuffer failed."); return false; } @@ -42,7 +42,7 @@ bool GLES3Buffer::initialize(const GFXBufferInfo &info) { _gpuBuffer->stride = _stride; _gpuBuffer->count = _count; - if (_usage & GFXBufferUsageBit::INDIRECT) { + if (_usage & BufferUsageBit::INDIRECT) { _gpuBuffer->indirects.resize(_count); } else { _gpuBuffer->buffer = _buffer; @@ -50,7 +50,7 @@ bool GLES3Buffer::initialize(const GFXBufferInfo &info) { GLES3CmdFuncCreateBuffer((GLES3Device *)_device, _gpuBuffer); _device->getMemoryStatus().bufferSize += _size; - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -67,7 +67,7 @@ void GLES3Buffer::destroy() { _device->getMemoryStatus().bufferSize -= _size; _buffer = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void GLES3Buffer::resize(uint size) { @@ -76,7 +76,7 @@ void GLES3Buffer::resize(uint size) { _size = size; _count = _size / _stride; - GFXMemoryStatus &status = _device->getMemoryStatus(); + MemoryStatus &status = _device->getMemoryStatus(); _gpuBuffer->size = _size; _gpuBuffer->count = _count; GLES3CmdFuncResizeBuffer((GLES3Device *)_device, _gpuBuffer); @@ -87,7 +87,7 @@ void GLES3Buffer::resize(uint size) { const uint8_t *oldBuffer = _buffer; uint8_t *buffer = (uint8_t *)CC_MALLOC(_size); if (!buffer) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CC_LOG_ERROR("GLES3Buffer: CC_MALLOC resize backup buffer failed."); return; } @@ -97,7 +97,7 @@ void GLES3Buffer::resize(uint size) { status.bufferSize -= oldSize; status.bufferSize += _size; } - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; } } diff --git a/native/cocos/renderer/gfx-gles3/GLES3Buffer.h b/native/cocos/renderer/gfx-gles3/GLES3Buffer.h index bee3693d0d..53adb9f979 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Buffer.h +++ b/native/cocos/renderer/gfx-gles3/GLES3Buffer.h @@ -6,13 +6,13 @@ namespace gfx { class GLES3GPUBuffer; -class CC_GLES3_API GLES3Buffer : public GFXBuffer { +class CC_GLES3_API GLES3Buffer : public Buffer { public: - GLES3Buffer(GFXDevice *device); + GLES3Buffer(Device *device); ~GLES3Buffer(); public: - virtual bool initialize(const GFXBufferInfo &info) override; + virtual bool initialize(const BufferInfo &info) override; virtual void destroy() override; virtual void resize(uint size) override; virtual void update(void *buffer, uint offset, uint size) override; diff --git a/native/cocos/renderer/gfx-gles3/GLES3CommandAllocator.cc b/native/cocos/renderer/gfx-gles3/GLES3CommandAllocator.cc index 023d269cae..b577117cb0 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3CommandAllocator.cc +++ b/native/cocos/renderer/gfx-gles3/GLES3CommandAllocator.cc @@ -4,20 +4,20 @@ namespace cc { namespace gfx { -GLES3CommandAllocator::GLES3CommandAllocator(GFXDevice *device) -: GFXCommandAllocator(device) { +GLES3CommandAllocator::GLES3CommandAllocator(Device *device) +: CommandAllocator(device) { } GLES3CommandAllocator::~GLES3CommandAllocator() { } -bool GLES3CommandAllocator::initialize(const GFXCommandAllocatorInfo &info) { - _status = GFXStatus::SUCCESS; +bool GLES3CommandAllocator::initialize(const CommandAllocatorInfo &info) { + _status = Status::SUCCESS; return true; } void GLES3CommandAllocator::destroy() { - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void GLES3CommandAllocator::clearCmds(GLES3CmdPackage *cmd_package) { diff --git a/native/cocos/renderer/gfx-gles3/GLES3CommandAllocator.h b/native/cocos/renderer/gfx-gles3/GLES3CommandAllocator.h index 1448db6302..a879c5b460 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3CommandAllocator.h +++ b/native/cocos/renderer/gfx-gles3/GLES3CommandAllocator.h @@ -7,19 +7,19 @@ namespace cc { namespace gfx { -class CC_GLES3_API GLES3CommandAllocator : public GFXCommandAllocator { +class CC_GLES3_API GLES3CommandAllocator : public CommandAllocator { public: - GLES3CommandAllocator(GFXDevice *device); + GLES3CommandAllocator(Device *device); ~GLES3CommandAllocator(); - GFXCommandPool beginRenderPassCmdPool; - GFXCommandPool bindStatesCmdPool; - GFXCommandPool drawCmdPool; - GFXCommandPool updateBufferCmdPool; - GFXCommandPool copyBufferToTextureCmdPool; + CommandPool beginRenderPassCmdPool; + CommandPool bindStatesCmdPool; + CommandPool drawCmdPool; + CommandPool updateBufferCmdPool; + CommandPool copyBufferToTextureCmdPool; public: - virtual bool initialize(const GFXCommandAllocatorInfo &info) override; + virtual bool initialize(const CommandAllocatorInfo &info) override; virtual void destroy() override; void clearCmds(GLES3CmdPackage *cmd_package); diff --git a/native/cocos/renderer/gfx-gles3/GLES3CommandBuffer.cc b/native/cocos/renderer/gfx-gles3/GLES3CommandBuffer.cc index 37cd278d79..2b39b90a04 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3CommandBuffer.cc +++ b/native/cocos/renderer/gfx-gles3/GLES3CommandBuffer.cc @@ -11,14 +11,14 @@ namespace cc { namespace gfx { -GLES3CommandBuffer::GLES3CommandBuffer(GFXDevice *device) -: GFXCommandBuffer(device) { +GLES3CommandBuffer::GLES3CommandBuffer(Device *device) +: CommandBuffer(device) { } GLES3CommandBuffer::~GLES3CommandBuffer() { } -bool GLES3CommandBuffer::initialize(const GFXCommandBufferInfo &info) { +bool GLES3CommandBuffer::initialize(const CommandBufferInfo &info) { if (!info.allocator) { return false; } @@ -28,7 +28,7 @@ bool GLES3CommandBuffer::initialize(const GFXCommandBufferInfo &info) { _type = info.type; _cmdPackage = CC_NEW(GLES3CmdPackage); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -39,12 +39,12 @@ void GLES3CommandBuffer::destroy() { _gles3Allocator = nullptr; } _allocator = nullptr; - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; CC_SAFE_DELETE(_cmdPackage); } -void GLES3CommandBuffer::begin(GFXRenderPass *renderPass, uint subpass, GFXFramebuffer *frameBuffer) { +void GLES3CommandBuffer::begin(RenderPass *renderPass, uint subpass, Framebuffer *frameBuffer) { _gles3Allocator->clearCmds(_cmdPackage); _curGPUPipelineState = nullptr; _curGPUBlendLayout = nullptr; @@ -61,7 +61,7 @@ void GLES3CommandBuffer::end() { _isInRenderPass = false; } -void GLES3CommandBuffer::beginRenderPass(GFXFramebuffer *fbo, const GFXRect &render_area, GFXClearFlags clear_flags, const std::vector &colors, float depth, int stencil) { +void GLES3CommandBuffer::beginRenderPass(Framebuffer *fbo, const Rect &render_area, ClearFlags clear_flags, const std::vector &colors, float depth, int stencil) { _isInRenderPass = true; GLES3CmdBeginRenderPass *cmd = _gles3Allocator->beginRenderPassCmdPool.alloc(); @@ -83,22 +83,22 @@ void GLES3CommandBuffer::endRenderPass() { _cmdPackage->cmds.push(GFXCmdType::END_RENDER_PASS); } -void GLES3CommandBuffer::bindPipelineState(GFXPipelineState *pso) { +void GLES3CommandBuffer::bindPipelineState(PipelineState *pso) { _curGPUPipelineState = ((GLES3PipelineState *)pso)->gpuPipelineState(); _isStateInvalid = true; } -void GLES3CommandBuffer::bindBindingLayout(GFXBindingLayout *layout) { +void GLES3CommandBuffer::bindBindingLayout(BindingLayout *layout) { _curGPUBlendLayout = ((GLES3BindingLayout *)layout)->gpuBindingLayout(); _isStateInvalid = true; } -void GLES3CommandBuffer::bindInputAssembler(GFXInputAssembler *ia) { +void GLES3CommandBuffer::bindInputAssembler(InputAssembler *ia) { _curGPUInputAssember = ((GLES3InputAssembler *)ia)->gpuInputAssembler(); _isStateInvalid = true; } -void GLES3CommandBuffer::setViewport(const GFXViewport &vp) { +void GLES3CommandBuffer::setViewport(const Viewport &vp) { if ((_curViewport.left != vp.left) || (_curViewport.top != vp.top) || @@ -112,7 +112,7 @@ void GLES3CommandBuffer::setViewport(const GFXViewport &vp) { } } -void GLES3CommandBuffer::setScissor(const GFXRect &rect) { +void GLES3CommandBuffer::setScissor(const Rect &rect) { if ((_curScissor.x != rect.x) || (_curScissor.y != rect.y) || (_curScissor.width != rect.width) || @@ -142,7 +142,7 @@ void GLES3CommandBuffer::setDepthBias(float constant, float clamp, float slope) } } -void GLES3CommandBuffer::setBlendConstants(const GFXColor &constants) { +void GLES3CommandBuffer::setBlendConstants(const Color &constants) { if (math::IsNotEqualF(_curBlendConstants.r, constants.r) || math::IsNotEqualF(_curBlendConstants.g, constants.g) || math::IsNotEqualF(_curBlendConstants.b, constants.b) || @@ -166,7 +166,7 @@ void GLES3CommandBuffer::setDepthBound(float min_bounds, float max_bounds) { } } -void GLES3CommandBuffer::setStencilWriteMask(GFXStencilFace face, uint mask) { +void GLES3CommandBuffer::setStencilWriteMask(StencilFace face, uint mask) { if ((_curStencilWriteMask.face != face) || (_curStencilWriteMask.write_mask != mask)) { @@ -176,7 +176,7 @@ void GLES3CommandBuffer::setStencilWriteMask(GFXStencilFace face, uint mask) { } } -void GLES3CommandBuffer::setStencilCompareMask(GFXStencilFace face, int ref, uint mask) { +void GLES3CommandBuffer::setStencilCompareMask(StencilFace face, int ref, uint mask) { if ((_curStencilCompareMask.face != face) || (_curStencilCompareMask.refrence != ref) || (_curStencilCompareMask.compare_mask != mask)) { @@ -188,9 +188,9 @@ void GLES3CommandBuffer::setStencilCompareMask(GFXStencilFace face, int ref, uin } } -void GLES3CommandBuffer::draw(GFXInputAssembler *ia) { - if ((_type == GFXCommandBufferType::PRIMARY && _isInRenderPass) || - (_type == GFXCommandBufferType::SECONDARY)) { +void GLES3CommandBuffer::draw(InputAssembler *ia) { + if ((_type == CommandBufferType::PRIMARY && _isInRenderPass) || + (_type == CommandBufferType::SECONDARY)) { if (_isStateInvalid) { BindStates(); @@ -223,9 +223,9 @@ void GLES3CommandBuffer::draw(GFXInputAssembler *ia) { } } -void GLES3CommandBuffer::updateBuffer(GFXBuffer *buff, void *data, uint size, uint offset) { - if ((_type == GFXCommandBufferType::PRIMARY && !_isInRenderPass) || - (_type == GFXCommandBufferType::SECONDARY)) { +void GLES3CommandBuffer::updateBuffer(Buffer *buff, void *data, uint size, uint offset) { + if ((_type == CommandBufferType::PRIMARY && !_isInRenderPass) || + (_type == CommandBufferType::SECONDARY)) { GLES3GPUBuffer *gpuBuffer = ((GLES3Buffer *)buff)->gpuBuffer(); if (gpuBuffer) { @@ -243,9 +243,9 @@ void GLES3CommandBuffer::updateBuffer(GFXBuffer *buff, void *data, uint size, ui } } -void GLES3CommandBuffer::copyBufferToTexture(GFXBuffer *src, GFXTexture *dst, GFXTextureLayout layout, const GFXBufferTextureCopyList ®ions) { - if ((_type == GFXCommandBufferType::PRIMARY && !_isInRenderPass) || - (_type == GFXCommandBufferType::SECONDARY)) { +void GLES3CommandBuffer::copyBufferToTexture(Buffer *src, Texture *dst, TextureLayout layout, const BufferTextureCopyList ®ions) { + if ((_type == CommandBufferType::PRIMARY && !_isInRenderPass) || + (_type == CommandBufferType::SECONDARY)) { GLES3GPUBuffer *gpuBuffer = ((GLES3Buffer *)src)->gpuBuffer(); GLES3GPUTexture *gpuTexture = ((GLES3Texture *)dst)->gpuTexture(); @@ -267,7 +267,7 @@ void GLES3CommandBuffer::copyBufferToTexture(GFXBuffer *src, GFXTexture *dst, GF } } -void GLES3CommandBuffer::execute(const std::vector &cmd_buffs, uint32_t count) { +void GLES3CommandBuffer::execute(const std::vector &cmd_buffs, uint32_t count) { for (uint i = 0; i < count; ++i) { GLES3CommandBuffer *cmd_buff = (GLES3CommandBuffer *)cmd_buffs[i]; diff --git a/native/cocos/renderer/gfx-gles3/GLES3CommandBuffer.h b/native/cocos/renderer/gfx-gles3/GLES3CommandBuffer.h index 9ed2a3820e..f08b8988bf 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3CommandBuffer.h +++ b/native/cocos/renderer/gfx-gles3/GLES3CommandBuffer.h @@ -8,36 +8,36 @@ namespace gfx { class GLES3CommandAllocator; -class CC_GLES3_API GLES3CommandBuffer : public GFXCommandBuffer { +class CC_GLES3_API GLES3CommandBuffer : public CommandBuffer { friend class GLES3Queue; public: - GLES3CommandBuffer(GFXDevice *device); + GLES3CommandBuffer(Device *device); ~GLES3CommandBuffer(); public: - virtual bool initialize(const GFXCommandBufferInfo &info) override; + virtual bool initialize(const CommandBufferInfo &info) override; virtual void destroy() override; - virtual void begin(GFXRenderPass *renderPass = nullptr, uint subpass = 0, GFXFramebuffer *frameBuffer = nullptr) override; + virtual void begin(RenderPass *renderPass = nullptr, uint subpass = 0, Framebuffer *frameBuffer = nullptr) override; virtual void end() override; - virtual void beginRenderPass(GFXFramebuffer *fbo, const GFXRect &render_area, GFXClearFlags clear_flags, const std::vector &colors, float depth, int stencil) override; + virtual void beginRenderPass(Framebuffer *fbo, const Rect &render_area, ClearFlags clear_flags, const std::vector &colors, float depth, int stencil) override; virtual void endRenderPass() override; - virtual void bindPipelineState(GFXPipelineState *pso) override; - virtual void bindBindingLayout(GFXBindingLayout *layout) override; - virtual void bindInputAssembler(GFXInputAssembler *ia) override; - virtual void setViewport(const GFXViewport &vp) override; - virtual void setScissor(const GFXRect &rect) override; + virtual void bindPipelineState(PipelineState *pso) override; + virtual void bindBindingLayout(BindingLayout *layout) override; + virtual void bindInputAssembler(InputAssembler *ia) override; + virtual void setViewport(const Viewport &vp) override; + virtual void setScissor(const Rect &rect) override; virtual void setLineWidth(const float width) override; virtual void setDepthBias(float constant, float clamp, float slope) override; - virtual void setBlendConstants(const GFXColor &constants) override; + virtual void setBlendConstants(const Color &constants) override; virtual void setDepthBound(float min_bounds, float max_bounds) override; - virtual void setStencilWriteMask(GFXStencilFace face, uint mask) override; - virtual void setStencilCompareMask(GFXStencilFace face, int ref, uint mask) override; - virtual void draw(GFXInputAssembler *ia) override; - virtual void updateBuffer(GFXBuffer *buff, void *data, uint size, uint offset) override; - virtual void copyBufferToTexture(GFXBuffer *src, GFXTexture *dst, GFXTextureLayout layout, const GFXBufferTextureCopyList ®ions) override; - virtual void execute(const std::vector &cmd_buffs, uint32_t count) override; + virtual void setStencilWriteMask(StencilFace face, uint mask) override; + virtual void setStencilCompareMask(StencilFace face, int ref, uint mask) override; + virtual void draw(InputAssembler *ia) override; + virtual void updateBuffer(Buffer *buff, void *data, uint size, uint offset) override; + virtual void copyBufferToTexture(Buffer *src, Texture *dst, TextureLayout layout, const BufferTextureCopyList ®ions) override; + virtual void execute(const std::vector &cmd_buffs, uint32_t count) override; private: void BindStates(); @@ -49,11 +49,11 @@ private: GLES3GPUPipelineState *_curGPUPipelineState = nullptr; GLES3GPUBindingLayout *_curGPUBlendLayout = nullptr; GLES3GPUInputAssembler *_curGPUInputAssember = nullptr; - GFXViewport _curViewport; - GFXRect _curScissor; + Viewport _curViewport; + Rect _curScissor; float _curLineWidth = 1.0f; GLES3DepthBias _curDepthBias; - GFXColor _curBlendConstants; + Color _curBlendConstants; GLES3DepthBounds _curDepthBounds; GLES3StencilWriteMask _curStencilWriteMask; GLES3StencilCompareMask _curStencilCompareMask; diff --git a/native/cocos/renderer/gfx-gles3/GLES3Commands.cc b/native/cocos/renderer/gfx-gles3/GLES3Commands.cc index 5788c29a75..fafaf4b45c 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Commands.cc +++ b/native/cocos/renderer/gfx-gles3/GLES3Commands.cc @@ -9,205 +9,205 @@ namespace cc { namespace gfx { namespace { -GLenum MapGLInternalFormat(GFXFormat format) { +GLenum MapGLInternalFormat(Format format) { switch (format) { - case GFXFormat::A8: return GL_ALPHA; - case GFXFormat::L8: return GL_LUMINANCE; - case GFXFormat::LA8: return GL_LUMINANCE_ALPHA; - case GFXFormat::R8: return GL_R8; - case GFXFormat::R8SN: return GL_R8_SNORM; - case GFXFormat::R8UI: return GL_R8UI; - case GFXFormat::R8I: return GL_R8I; - case GFXFormat::RG8: return GL_RG8; - case GFXFormat::RG8SN: return GL_RG8_SNORM; - case GFXFormat::RG8UI: return GL_RG8UI; - case GFXFormat::RG8I: return GL_RG8I; - case GFXFormat::RGB8: return GL_RGB8; - case GFXFormat::RGB8SN: return GL_RGB8_SNORM; - case GFXFormat::RGB8UI: return GL_RGB8UI; - case GFXFormat::RGB8I: return GL_RGB8I; - case GFXFormat::RGBA8: return GL_RGBA8; - case GFXFormat::RGBA8SN: return GL_RGBA8_SNORM; - case GFXFormat::RGBA8UI: return GL_RGBA8UI; - case GFXFormat::RGBA8I: return GL_RGBA8I; - case GFXFormat::R16I: return GL_R16I; - case GFXFormat::R16UI: return GL_R16UI; - case GFXFormat::R16F: return GL_R16F; - case GFXFormat::RG16I: return GL_RG16I; - case GFXFormat::RG16UI: return GL_RG16UI; - case GFXFormat::RG16F: return GL_RG16F; - case GFXFormat::RGB16I: return GL_RGB16I; - case GFXFormat::RGB16UI: return GL_RGB16UI; - case GFXFormat::RGB16F: return GL_RGB16F; - case GFXFormat::RGBA16I: return GL_RGBA16I; - case GFXFormat::RGBA16UI: return GL_RGBA16UI; - case GFXFormat::RGBA16F: return GL_RGBA16F; - case GFXFormat::R32I: return GL_R32I; - case GFXFormat::R32UI: return GL_R32UI; - case GFXFormat::R32F: return GL_R32F; - case GFXFormat::RG32I: return GL_RG32I; - case GFXFormat::RG32UI: return GL_RG32UI; - case GFXFormat::RG32F: return GL_RG32F; - case GFXFormat::RGB32I: return GL_RGB32I; - case GFXFormat::RGB32UI: return GL_RGB32UI; - case GFXFormat::RGB32F: return GL_RGB32F; - case GFXFormat::RGBA32I: return GL_RGBA32I; - case GFXFormat::RGBA32UI: return GL_RGBA32UI; - case GFXFormat::RGBA32F: return GL_RGBA32F; - case GFXFormat::R5G6B5: return GL_RGB565; - case GFXFormat::RGB5A1: return GL_RGB5_A1; - case GFXFormat::RGBA4: return GL_RGBA4; - case GFXFormat::RGB10A2: return GL_RGB10_A2; - case GFXFormat::RGB10A2UI: return GL_RGB10_A2UI; - case GFXFormat::R11G11B10F: return GL_R11F_G11F_B10F; - case GFXFormat::D16: return GL_DEPTH_COMPONENT16; - case GFXFormat::D16S8: return GL_DEPTH_STENCIL; - case GFXFormat::D24: return GL_DEPTH_COMPONENT24; - case GFXFormat::D24S8: return GL_DEPTH24_STENCIL8; - case GFXFormat::D32F: return GL_DEPTH_COMPONENT32F; - case GFXFormat::D32F_S8: return GL_DEPTH32F_STENCIL8; + case Format::A8: return GL_ALPHA; + case Format::L8: return GL_LUMINANCE; + case Format::LA8: return GL_LUMINANCE_ALPHA; + case Format::R8: return GL_R8; + case Format::R8SN: return GL_R8_SNORM; + case Format::R8UI: return GL_R8UI; + case Format::R8I: return GL_R8I; + case Format::RG8: return GL_RG8; + case Format::RG8SN: return GL_RG8_SNORM; + case Format::RG8UI: return GL_RG8UI; + case Format::RG8I: return GL_RG8I; + case Format::RGB8: return GL_RGB8; + case Format::RGB8SN: return GL_RGB8_SNORM; + case Format::RGB8UI: return GL_RGB8UI; + case Format::RGB8I: return GL_RGB8I; + case Format::RGBA8: return GL_RGBA8; + case Format::RGBA8SN: return GL_RGBA8_SNORM; + case Format::RGBA8UI: return GL_RGBA8UI; + case Format::RGBA8I: return GL_RGBA8I; + case Format::R16I: return GL_R16I; + case Format::R16UI: return GL_R16UI; + case Format::R16F: return GL_R16F; + case Format::RG16I: return GL_RG16I; + case Format::RG16UI: return GL_RG16UI; + case Format::RG16F: return GL_RG16F; + case Format::RGB16I: return GL_RGB16I; + case Format::RGB16UI: return GL_RGB16UI; + case Format::RGB16F: return GL_RGB16F; + case Format::RGBA16I: return GL_RGBA16I; + case Format::RGBA16UI: return GL_RGBA16UI; + case Format::RGBA16F: return GL_RGBA16F; + case Format::R32I: return GL_R32I; + case Format::R32UI: return GL_R32UI; + case Format::R32F: return GL_R32F; + case Format::RG32I: return GL_RG32I; + case Format::RG32UI: return GL_RG32UI; + case Format::RG32F: return GL_RG32F; + case Format::RGB32I: return GL_RGB32I; + case Format::RGB32UI: return GL_RGB32UI; + case Format::RGB32F: return GL_RGB32F; + case Format::RGBA32I: return GL_RGBA32I; + case Format::RGBA32UI: return GL_RGBA32UI; + case Format::RGBA32F: return GL_RGBA32F; + case Format::R5G6B5: return GL_RGB565; + case Format::RGB5A1: return GL_RGB5_A1; + case Format::RGBA4: return GL_RGBA4; + case Format::RGB10A2: return GL_RGB10_A2; + case Format::RGB10A2UI: return GL_RGB10_A2UI; + case Format::R11G11B10F: return GL_R11F_G11F_B10F; + case Format::D16: return GL_DEPTH_COMPONENT16; + case Format::D16S8: return GL_DEPTH_STENCIL; + case Format::D24: return GL_DEPTH_COMPONENT24; + case Format::D24S8: return GL_DEPTH24_STENCIL8; + case Format::D32F: return GL_DEPTH_COMPONENT32F; + case Format::D32F_S8: return GL_DEPTH32F_STENCIL8; - case GFXFormat::BC1: return GL_COMPRESSED_RGB_S3TC_DXT1_EXT; - case GFXFormat::BC1_ALPHA: return GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; - case GFXFormat::BC1_SRGB: return GL_COMPRESSED_SRGB_S3TC_DXT1_EXT; - case GFXFormat::BC1_SRGB_ALPHA: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT; - case GFXFormat::BC2: return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; - case GFXFormat::BC2_SRGB: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT; - case GFXFormat::BC3: return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; - case GFXFormat::BC3_SRGB: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT; + case Format::BC1: return GL_COMPRESSED_RGB_S3TC_DXT1_EXT; + case Format::BC1_ALPHA: return GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; + case Format::BC1_SRGB: return GL_COMPRESSED_SRGB_S3TC_DXT1_EXT; + case Format::BC1_SRGB_ALPHA: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT; + case Format::BC2: return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; + case Format::BC2_SRGB: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT; + case Format::BC3: return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; + case Format::BC3_SRGB: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT; - case GFXFormat::ETC_RGB8: return GL_ETC1_RGB8_OES; - case GFXFormat::ETC2_RGB8: return GL_COMPRESSED_RGB8_ETC2; - case GFXFormat::ETC2_SRGB8: return GL_COMPRESSED_SRGB8_ETC2; - case GFXFormat::ETC2_RGB8_A1: return GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2; - case GFXFormat::ETC2_SRGB8_A1: return GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2; - case GFXFormat::ETC2_RGBA8: return GL_COMPRESSED_RGBA8_ETC2_EAC; - case GFXFormat::ETC2_SRGB8_A8: return GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC; - case GFXFormat::EAC_R11: return GL_COMPRESSED_R11_EAC; - case GFXFormat::EAC_R11SN: return GL_COMPRESSED_SIGNED_R11_EAC; - case GFXFormat::EAC_RG11: return GL_COMPRESSED_RG11_EAC; - case GFXFormat::EAC_RG11SN: return GL_COMPRESSED_SIGNED_RG11_EAC; + case Format::ETC_RGB8: return GL_ETC1_RGB8_OES; + case Format::ETC2_RGB8: return GL_COMPRESSED_RGB8_ETC2; + case Format::ETC2_SRGB8: return GL_COMPRESSED_SRGB8_ETC2; + case Format::ETC2_RGB8_A1: return GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2; + case Format::ETC2_SRGB8_A1: return GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2; + case Format::ETC2_RGBA8: return GL_COMPRESSED_RGBA8_ETC2_EAC; + case Format::ETC2_SRGB8_A8: return GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC; + case Format::EAC_R11: return GL_COMPRESSED_R11_EAC; + case Format::EAC_R11SN: return GL_COMPRESSED_SIGNED_R11_EAC; + case Format::EAC_RG11: return GL_COMPRESSED_RG11_EAC; + case Format::EAC_RG11SN: return GL_COMPRESSED_SIGNED_RG11_EAC; - case GFXFormat::PVRTC_RGB2: return GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG; - case GFXFormat::PVRTC_RGBA2: return GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG; - case GFXFormat::PVRTC_RGB4: return GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; - case GFXFormat::PVRTC_RGBA4: return GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; + case Format::PVRTC_RGB2: return GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG; + case Format::PVRTC_RGBA2: return GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG; + case Format::PVRTC_RGB4: return GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; + case Format::PVRTC_RGBA4: return GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; default: { - CCASSERT(false, "Unsupported GFXFormat, convert to GL internal format failed."); + CCASSERT(false, "Unsupported Format, convert to GL internal format failed."); return GL_RGBA; } } } -GLenum MapGLFormat(GFXFormat format) { +GLenum MapGLFormat(Format format) { switch (format) { - case GFXFormat::A8: return GL_ALPHA; - case GFXFormat::L8: return GL_LUMINANCE; - case GFXFormat::LA8: return GL_LUMINANCE_ALPHA; - case GFXFormat::R8: - case GFXFormat::R8SN: - case GFXFormat::R8UI: - case GFXFormat::R8I: return GL_RED; - case GFXFormat::RG8: - case GFXFormat::RG8SN: - case GFXFormat::RG8UI: - case GFXFormat::RG8I: return GL_RG; - case GFXFormat::RGB8: - case GFXFormat::RGB8SN: - case GFXFormat::RGB8UI: - case GFXFormat::RGB8I: return GL_RGB; - case GFXFormat::RGBA8: - case GFXFormat::RGBA8SN: - case GFXFormat::RGBA8UI: - case GFXFormat::RGBA8I: return GL_RGBA; - case GFXFormat::R16UI: - case GFXFormat::R16I: - case GFXFormat::R16F: return GL_RED; - case GFXFormat::RG16UI: - case GFXFormat::RG16I: - case GFXFormat::RG16F: return GL_RG; - case GFXFormat::RGB16UI: - case GFXFormat::RGB16I: - case GFXFormat::RGB16F: return GL_RGB; - case GFXFormat::RGBA16UI: - case GFXFormat::RGBA16I: - case GFXFormat::RGBA16F: return GL_RGBA; - case GFXFormat::R32UI: - case GFXFormat::R32I: - case GFXFormat::R32F: return GL_RED; - case GFXFormat::RG32UI: - case GFXFormat::RG32I: - case GFXFormat::RG32F: return GL_RG; - case GFXFormat::RGB32UI: - case GFXFormat::RGB32I: - case GFXFormat::RGB32F: return GL_RGB; - case GFXFormat::RGBA32UI: - case GFXFormat::RGBA32I: - case GFXFormat::RGBA32F: return GL_RGBA; - case GFXFormat::RGB10A2: return GL_RGBA; - case GFXFormat::R11G11B10F: return GL_RGB; - case GFXFormat::R5G6B5: return GL_RGB; - case GFXFormat::RGB5A1: return GL_RGBA; - case GFXFormat::RGBA4: return GL_RGBA; - case GFXFormat::D16: return GL_DEPTH_COMPONENT; - case GFXFormat::D16S8: return GL_DEPTH_STENCIL; - case GFXFormat::D24: return GL_DEPTH_COMPONENT; - case GFXFormat::D24S8: return GL_DEPTH_STENCIL; - case GFXFormat::D32F: return GL_DEPTH_COMPONENT; - case GFXFormat::D32F_S8: return GL_DEPTH_STENCIL; + case Format::A8: return GL_ALPHA; + case Format::L8: return GL_LUMINANCE; + case Format::LA8: return GL_LUMINANCE_ALPHA; + case Format::R8: + case Format::R8SN: + case Format::R8UI: + case Format::R8I: return GL_RED; + case Format::RG8: + case Format::RG8SN: + case Format::RG8UI: + case Format::RG8I: return GL_RG; + case Format::RGB8: + case Format::RGB8SN: + case Format::RGB8UI: + case Format::RGB8I: return GL_RGB; + case Format::RGBA8: + case Format::RGBA8SN: + case Format::RGBA8UI: + case Format::RGBA8I: return GL_RGBA; + case Format::R16UI: + case Format::R16I: + case Format::R16F: return GL_RED; + case Format::RG16UI: + case Format::RG16I: + case Format::RG16F: return GL_RG; + case Format::RGB16UI: + case Format::RGB16I: + case Format::RGB16F: return GL_RGB; + case Format::RGBA16UI: + case Format::RGBA16I: + case Format::RGBA16F: return GL_RGBA; + case Format::R32UI: + case Format::R32I: + case Format::R32F: return GL_RED; + case Format::RG32UI: + case Format::RG32I: + case Format::RG32F: return GL_RG; + case Format::RGB32UI: + case Format::RGB32I: + case Format::RGB32F: return GL_RGB; + case Format::RGBA32UI: + case Format::RGBA32I: + case Format::RGBA32F: return GL_RGBA; + case Format::RGB10A2: return GL_RGBA; + case Format::R11G11B10F: return GL_RGB; + case Format::R5G6B5: return GL_RGB; + case Format::RGB5A1: return GL_RGBA; + case Format::RGBA4: return GL_RGBA; + case Format::D16: return GL_DEPTH_COMPONENT; + case Format::D16S8: return GL_DEPTH_STENCIL; + case Format::D24: return GL_DEPTH_COMPONENT; + case Format::D24S8: return GL_DEPTH_STENCIL; + case Format::D32F: return GL_DEPTH_COMPONENT; + case Format::D32F_S8: return GL_DEPTH_STENCIL; - case GFXFormat::BC1: return GL_COMPRESSED_RGB_S3TC_DXT1_EXT; - case GFXFormat::BC1_ALPHA: return GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; - case GFXFormat::BC1_SRGB: return GL_COMPRESSED_SRGB_S3TC_DXT1_EXT; - case GFXFormat::BC1_SRGB_ALPHA: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT; - case GFXFormat::BC2: return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; - case GFXFormat::BC2_SRGB: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT; - case GFXFormat::BC3: return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; - case GFXFormat::BC3_SRGB: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT; + case Format::BC1: return GL_COMPRESSED_RGB_S3TC_DXT1_EXT; + case Format::BC1_ALPHA: return GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; + case Format::BC1_SRGB: return GL_COMPRESSED_SRGB_S3TC_DXT1_EXT; + case Format::BC1_SRGB_ALPHA: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT; + case Format::BC2: return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; + case Format::BC2_SRGB: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT; + case Format::BC3: return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; + case Format::BC3_SRGB: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT; - case GFXFormat::ETC_RGB8: return GL_ETC1_RGB8_OES; + case Format::ETC_RGB8: return GL_ETC1_RGB8_OES; - case GFXFormat::PVRTC_RGB2: return GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG; - case GFXFormat::PVRTC_RGBA2: return GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG; - case GFXFormat::PVRTC_RGB4: return GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; - case GFXFormat::PVRTC_RGBA4: return GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; + case Format::PVRTC_RGB2: return GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG; + case Format::PVRTC_RGBA2: return GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG; + case Format::PVRTC_RGB4: return GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; + case Format::PVRTC_RGBA4: return GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; default: { - CCASSERT(false, "Unsupported GFXFormat, convert to WebGL format failed."); + CCASSERT(false, "Unsupported Format, convert to WebGL format failed."); return GL_RGBA; } } } -GLenum MapGLType(GFXType type) { +GLenum MapGLType(Type type) { switch (type) { - case GFXType::BOOL: return GL_BOOL; - case GFXType::BOOL2: return GL_BOOL_VEC2; - case GFXType::BOOL3: return GL_BOOL_VEC3; - case GFXType::BOOL4: return GL_BOOL_VEC4; - case GFXType::INT: return GL_INT; - case GFXType::INT2: return GL_INT_VEC2; - case GFXType::INT3: return GL_INT_VEC3; - case GFXType::INT4: return GL_INT_VEC4; - case GFXType::UINT: return GL_UNSIGNED_INT; - case GFXType::FLOAT: return GL_FLOAT; - case GFXType::FLOAT2: return GL_FLOAT_VEC2; - case GFXType::FLOAT3: return GL_FLOAT_VEC3; - case GFXType::FLOAT4: return GL_FLOAT_VEC4; - case GFXType::MAT2: return GL_FLOAT_MAT2; - case GFXType::MAT2X3: return GL_FLOAT_MAT2x3; - case GFXType::MAT2X4: return GL_FLOAT_MAT2x4; - case GFXType::MAT3X2: return GL_FLOAT_MAT3x2; - case GFXType::MAT3: return GL_FLOAT_MAT3; - case GFXType::MAT3X4: return GL_FLOAT_MAT3x4; - case GFXType::MAT4X2: return GL_FLOAT_MAT4x2; - case GFXType::MAT4X3: return GL_FLOAT_MAT4x3; - case GFXType::MAT4: return GL_FLOAT_MAT4; - case GFXType::SAMPLER2D: return GL_SAMPLER_2D; - case GFXType::SAMPLER2D_ARRAY: return GL_SAMPLER_2D_ARRAY; - case GFXType::SAMPLER3D: return GL_SAMPLER_3D; - case GFXType::SAMPLER_CUBE: return GL_SAMPLER_CUBE; + case Type::BOOL: return GL_BOOL; + case Type::BOOL2: return GL_BOOL_VEC2; + case Type::BOOL3: return GL_BOOL_VEC3; + case Type::BOOL4: return GL_BOOL_VEC4; + case Type::INT: return GL_INT; + case Type::INT2: return GL_INT_VEC2; + case Type::INT3: return GL_INT_VEC3; + case Type::INT4: return GL_INT_VEC4; + case Type::UINT: return GL_UNSIGNED_INT; + case Type::FLOAT: return GL_FLOAT; + case Type::FLOAT2: return GL_FLOAT_VEC2; + case Type::FLOAT3: return GL_FLOAT_VEC3; + case Type::FLOAT4: return GL_FLOAT_VEC4; + case Type::MAT2: return GL_FLOAT_MAT2; + case Type::MAT2X3: return GL_FLOAT_MAT2x3; + case Type::MAT2X4: return GL_FLOAT_MAT2x4; + case Type::MAT3X2: return GL_FLOAT_MAT3x2; + case Type::MAT3: return GL_FLOAT_MAT3; + case Type::MAT3X4: return GL_FLOAT_MAT3x4; + case Type::MAT4X2: return GL_FLOAT_MAT4x2; + case Type::MAT4X3: return GL_FLOAT_MAT4x3; + case Type::MAT4: return GL_FLOAT_MAT4; + case Type::SAMPLER2D: return GL_SAMPLER_2D; + case Type::SAMPLER2D_ARRAY: return GL_SAMPLER_2D_ARRAY; + case Type::SAMPLER3D: return GL_SAMPLER_3D; + case Type::SAMPLER_CUBE: return GL_SAMPLER_CUBE; default: { CCASSERT(false, "Unsupported GLType, convert to GL type failed."); return GL_NONE; @@ -215,138 +215,138 @@ GLenum MapGLType(GFXType type) { } } -GFXType MapGFXType(GLenum glType) { +Type MapType(GLenum glType) { switch (glType) { - case GL_BOOL: return GFXType::BOOL; - case GL_BOOL_VEC2: return GFXType::BOOL2; - case GL_BOOL_VEC3: return GFXType::BOOL3; - case GL_BOOL_VEC4: return GFXType::BOOL4; - case GL_INT: return GFXType::INT; - case GL_INT_VEC2: return GFXType::INT2; - case GL_INT_VEC3: return GFXType::INT3; - case GL_INT_VEC4: return GFXType::INT4; - case GL_UNSIGNED_INT: return GFXType::UINT; - case GL_UNSIGNED_INT_VEC2: return GFXType::UINT2; - case GL_UNSIGNED_INT_VEC3: return GFXType::UINT3; - case GL_UNSIGNED_INT_VEC4: return GFXType::UINT4; - case GL_FLOAT: return GFXType::FLOAT; - case GL_FLOAT_VEC2: return GFXType::FLOAT2; - case GL_FLOAT_VEC3: return GFXType::FLOAT3; - case GL_FLOAT_VEC4: return GFXType::FLOAT4; - case GL_FLOAT_MAT2: return GFXType::MAT2; - case GL_FLOAT_MAT2x3: return GFXType::MAT2X3; - case GL_FLOAT_MAT2x4: return GFXType::MAT2X4; - case GL_FLOAT_MAT3x2: return GFXType::MAT3X2; - case GL_FLOAT_MAT3: return GFXType::MAT3; - case GL_FLOAT_MAT3x4: return GFXType::MAT3X4; - case GL_FLOAT_MAT4x2: return GFXType::MAT4X2; - case GL_FLOAT_MAT4x3: return GFXType::MAT4X3; - case GL_FLOAT_MAT4: return GFXType::MAT4; - case GL_SAMPLER_2D: return GFXType::SAMPLER2D; - case GL_SAMPLER_2D_ARRAY: return GFXType::SAMPLER2D_ARRAY; - case GL_SAMPLER_3D: return GFXType::SAMPLER3D; - case GL_SAMPLER_CUBE: return GFXType::SAMPLER_CUBE; + case GL_BOOL: return Type::BOOL; + case GL_BOOL_VEC2: return Type::BOOL2; + case GL_BOOL_VEC3: return Type::BOOL3; + case GL_BOOL_VEC4: return Type::BOOL4; + case GL_INT: return Type::INT; + case GL_INT_VEC2: return Type::INT2; + case GL_INT_VEC3: return Type::INT3; + case GL_INT_VEC4: return Type::INT4; + case GL_UNSIGNED_INT: return Type::UINT; + case GL_UNSIGNED_INT_VEC2: return Type::UINT2; + case GL_UNSIGNED_INT_VEC3: return Type::UINT3; + case GL_UNSIGNED_INT_VEC4: return Type::UINT4; + case GL_FLOAT: return Type::FLOAT; + case GL_FLOAT_VEC2: return Type::FLOAT2; + case GL_FLOAT_VEC3: return Type::FLOAT3; + case GL_FLOAT_VEC4: return Type::FLOAT4; + case GL_FLOAT_MAT2: return Type::MAT2; + case GL_FLOAT_MAT2x3: return Type::MAT2X3; + case GL_FLOAT_MAT2x4: return Type::MAT2X4; + case GL_FLOAT_MAT3x2: return Type::MAT3X2; + case GL_FLOAT_MAT3: return Type::MAT3; + case GL_FLOAT_MAT3x4: return Type::MAT3X4; + case GL_FLOAT_MAT4x2: return Type::MAT4X2; + case GL_FLOAT_MAT4x3: return Type::MAT4X3; + case GL_FLOAT_MAT4: return Type::MAT4; + case GL_SAMPLER_2D: return Type::SAMPLER2D; + case GL_SAMPLER_2D_ARRAY: return Type::SAMPLER2D_ARRAY; + case GL_SAMPLER_3D: return Type::SAMPLER3D; + case GL_SAMPLER_CUBE: return Type::SAMPLER_CUBE; default: { - CCASSERT(false, "Unsupported GLType, convert to GFXType failed."); - return GFXType::UNKNOWN; + CCASSERT(false, "Unsupported GLType, convert to Type failed."); + return Type::UNKNOWN; } } } -GLenum GFXFormatToGLType(GFXFormat format) { +GLenum FormatToGLType(Format format) { switch (format) { - case GFXFormat::R8: return GL_UNSIGNED_BYTE; - case GFXFormat::R8SN: return GL_BYTE; - case GFXFormat::R8UI: return GL_UNSIGNED_BYTE; - case GFXFormat::R8I: return GL_BYTE; - case GFXFormat::R16F: return GL_HALF_FLOAT; - case GFXFormat::R16UI: return GL_UNSIGNED_SHORT; - case GFXFormat::R16I: return GL_SHORT; - case GFXFormat::R32F: return GL_FLOAT; - case GFXFormat::R32UI: return GL_UNSIGNED_INT; - case GFXFormat::R32I: return GL_INT; + case Format::R8: return GL_UNSIGNED_BYTE; + case Format::R8SN: return GL_BYTE; + case Format::R8UI: return GL_UNSIGNED_BYTE; + case Format::R8I: return GL_BYTE; + case Format::R16F: return GL_HALF_FLOAT; + case Format::R16UI: return GL_UNSIGNED_SHORT; + case Format::R16I: return GL_SHORT; + case Format::R32F: return GL_FLOAT; + case Format::R32UI: return GL_UNSIGNED_INT; + case Format::R32I: return GL_INT; - case GFXFormat::RG8: return GL_UNSIGNED_BYTE; - case GFXFormat::RG8SN: return GL_BYTE; - case GFXFormat::RG8UI: return GL_UNSIGNED_BYTE; - case GFXFormat::RG8I: return GL_BYTE; - case GFXFormat::RG16F: return GL_HALF_FLOAT; - case GFXFormat::RG16UI: return GL_UNSIGNED_SHORT; - case GFXFormat::RG16I: return GL_SHORT; - case GFXFormat::RG32F: return GL_FLOAT; - case GFXFormat::RG32UI: return GL_UNSIGNED_INT; - case GFXFormat::RG32I: return GL_INT; + case Format::RG8: return GL_UNSIGNED_BYTE; + case Format::RG8SN: return GL_BYTE; + case Format::RG8UI: return GL_UNSIGNED_BYTE; + case Format::RG8I: return GL_BYTE; + case Format::RG16F: return GL_HALF_FLOAT; + case Format::RG16UI: return GL_UNSIGNED_SHORT; + case Format::RG16I: return GL_SHORT; + case Format::RG32F: return GL_FLOAT; + case Format::RG32UI: return GL_UNSIGNED_INT; + case Format::RG32I: return GL_INT; - case GFXFormat::RGB8: return GL_UNSIGNED_BYTE; - case GFXFormat::SRGB8: return GL_UNSIGNED_BYTE; - case GFXFormat::RGB8SN: return GL_BYTE; - case GFXFormat::RGB8UI: return GL_UNSIGNED_BYTE; - case GFXFormat::RGB8I: return GL_BYTE; - case GFXFormat::RGB16F: return GL_HALF_FLOAT; - case GFXFormat::RGB16UI: return GL_UNSIGNED_SHORT; - case GFXFormat::RGB16I: return GL_SHORT; - case GFXFormat::RGB32F: return GL_FLOAT; - case GFXFormat::RGB32UI: return GL_UNSIGNED_INT; - case GFXFormat::RGB32I: return GL_INT; + case Format::RGB8: return GL_UNSIGNED_BYTE; + case Format::SRGB8: return GL_UNSIGNED_BYTE; + case Format::RGB8SN: return GL_BYTE; + case Format::RGB8UI: return GL_UNSIGNED_BYTE; + case Format::RGB8I: return GL_BYTE; + case Format::RGB16F: return GL_HALF_FLOAT; + case Format::RGB16UI: return GL_UNSIGNED_SHORT; + case Format::RGB16I: return GL_SHORT; + case Format::RGB32F: return GL_FLOAT; + case Format::RGB32UI: return GL_UNSIGNED_INT; + case Format::RGB32I: return GL_INT; - case GFXFormat::RGBA8: return GL_UNSIGNED_BYTE; - case GFXFormat::SRGB8_A8: return GL_UNSIGNED_BYTE; - case GFXFormat::RGBA8SN: return GL_BYTE; - case GFXFormat::RGBA8UI: return GL_UNSIGNED_BYTE; - case GFXFormat::RGBA8I: return GL_BYTE; - case GFXFormat::RGBA16F: return GL_HALF_FLOAT; - case GFXFormat::RGBA16UI: return GL_UNSIGNED_SHORT; - case GFXFormat::RGBA16I: return GL_SHORT; - case GFXFormat::RGBA32F: return GL_FLOAT; - case GFXFormat::RGBA32UI: return GL_UNSIGNED_INT; - case GFXFormat::RGBA32I: return GL_INT; + case Format::RGBA8: return GL_UNSIGNED_BYTE; + case Format::SRGB8_A8: return GL_UNSIGNED_BYTE; + case Format::RGBA8SN: return GL_BYTE; + case Format::RGBA8UI: return GL_UNSIGNED_BYTE; + case Format::RGBA8I: return GL_BYTE; + case Format::RGBA16F: return GL_HALF_FLOAT; + case Format::RGBA16UI: return GL_UNSIGNED_SHORT; + case Format::RGBA16I: return GL_SHORT; + case Format::RGBA32F: return GL_FLOAT; + case Format::RGBA32UI: return GL_UNSIGNED_INT; + case Format::RGBA32I: return GL_INT; - case GFXFormat::R5G6B5: return GL_UNSIGNED_SHORT_5_6_5; - case GFXFormat::R11G11B10F: return GL_UNSIGNED_INT_10F_11F_11F_REV; - case GFXFormat::RGB5A1: return GL_UNSIGNED_SHORT_5_5_5_1; - case GFXFormat::RGBA4: return GL_UNSIGNED_SHORT_4_4_4_4; - case GFXFormat::RGB10A2: return GL_UNSIGNED_INT_2_10_10_10_REV; - case GFXFormat::RGB10A2UI: return GL_UNSIGNED_INT_2_10_10_10_REV; - case GFXFormat::RGB9E5: return GL_FLOAT; + case Format::R5G6B5: return GL_UNSIGNED_SHORT_5_6_5; + case Format::R11G11B10F: return GL_UNSIGNED_INT_10F_11F_11F_REV; + case Format::RGB5A1: return GL_UNSIGNED_SHORT_5_5_5_1; + case Format::RGBA4: return GL_UNSIGNED_SHORT_4_4_4_4; + case Format::RGB10A2: return GL_UNSIGNED_INT_2_10_10_10_REV; + case Format::RGB10A2UI: return GL_UNSIGNED_INT_2_10_10_10_REV; + case Format::RGB9E5: return GL_FLOAT; - case GFXFormat::D16: return GL_UNSIGNED_SHORT; - case GFXFormat::D16S8: return GL_UNSIGNED_INT_24_8; // no D16S8 support - case GFXFormat::D24: return GL_UNSIGNED_INT; - case GFXFormat::D24S8: return GL_UNSIGNED_INT_24_8; - case GFXFormat::D32F: return GL_FLOAT; - case GFXFormat::D32F_S8: return GL_FLOAT_32_UNSIGNED_INT_24_8_REV; + case Format::D16: return GL_UNSIGNED_SHORT; + case Format::D16S8: return GL_UNSIGNED_INT_24_8; // no D16S8 support + case Format::D24: return GL_UNSIGNED_INT; + case Format::D24S8: return GL_UNSIGNED_INT_24_8; + case Format::D32F: return GL_FLOAT; + case Format::D32F_S8: return GL_FLOAT_32_UNSIGNED_INT_24_8_REV; - case GFXFormat::BC1: return GL_UNSIGNED_BYTE; - case GFXFormat::BC1_SRGB: return GL_UNSIGNED_BYTE; - case GFXFormat::BC2: return GL_UNSIGNED_BYTE; - case GFXFormat::BC2_SRGB: return GL_UNSIGNED_BYTE; - case GFXFormat::BC3: return GL_UNSIGNED_BYTE; - case GFXFormat::BC3_SRGB: return GL_UNSIGNED_BYTE; - case GFXFormat::BC4: return GL_UNSIGNED_BYTE; - case GFXFormat::BC4_SNORM: return GL_BYTE; - case GFXFormat::BC5: return GL_UNSIGNED_BYTE; - case GFXFormat::BC5_SNORM: return GL_BYTE; - case GFXFormat::BC6H_SF16: return GL_FLOAT; - case GFXFormat::BC6H_UF16: return GL_FLOAT; - case GFXFormat::BC7: return GL_UNSIGNED_BYTE; - case GFXFormat::BC7_SRGB: return GL_UNSIGNED_BYTE; + case Format::BC1: return GL_UNSIGNED_BYTE; + case Format::BC1_SRGB: return GL_UNSIGNED_BYTE; + case Format::BC2: return GL_UNSIGNED_BYTE; + case Format::BC2_SRGB: return GL_UNSIGNED_BYTE; + case Format::BC3: return GL_UNSIGNED_BYTE; + case Format::BC3_SRGB: return GL_UNSIGNED_BYTE; + case Format::BC4: return GL_UNSIGNED_BYTE; + case Format::BC4_SNORM: return GL_BYTE; + case Format::BC5: return GL_UNSIGNED_BYTE; + case Format::BC5_SNORM: return GL_BYTE; + case Format::BC6H_SF16: return GL_FLOAT; + case Format::BC6H_UF16: return GL_FLOAT; + case Format::BC7: return GL_UNSIGNED_BYTE; + case Format::BC7_SRGB: return GL_UNSIGNED_BYTE; - case GFXFormat::ETC_RGB8: return GL_UNSIGNED_BYTE; - case GFXFormat::ETC2_RGB8: return GL_UNSIGNED_BYTE; - case GFXFormat::ETC2_SRGB8: return GL_UNSIGNED_BYTE; - case GFXFormat::ETC2_RGB8_A1: return GL_UNSIGNED_BYTE; - case GFXFormat::ETC2_SRGB8_A1: return GL_UNSIGNED_BYTE; - case GFXFormat::EAC_R11: return GL_UNSIGNED_BYTE; - case GFXFormat::EAC_R11SN: return GL_BYTE; - case GFXFormat::EAC_RG11: return GL_UNSIGNED_BYTE; - case GFXFormat::EAC_RG11SN: return GL_BYTE; + case Format::ETC_RGB8: return GL_UNSIGNED_BYTE; + case Format::ETC2_RGB8: return GL_UNSIGNED_BYTE; + case Format::ETC2_SRGB8: return GL_UNSIGNED_BYTE; + case Format::ETC2_RGB8_A1: return GL_UNSIGNED_BYTE; + case Format::ETC2_SRGB8_A1: return GL_UNSIGNED_BYTE; + case Format::EAC_R11: return GL_UNSIGNED_BYTE; + case Format::EAC_R11SN: return GL_BYTE; + case Format::EAC_RG11: return GL_UNSIGNED_BYTE; + case Format::EAC_RG11SN: return GL_BYTE; - case GFXFormat::PVRTC_RGB2: return GL_UNSIGNED_BYTE; - case GFXFormat::PVRTC_RGBA2: return GL_UNSIGNED_BYTE; - case GFXFormat::PVRTC_RGB4: return GL_UNSIGNED_BYTE; - case GFXFormat::PVRTC_RGBA4: return GL_UNSIGNED_BYTE; - case GFXFormat::PVRTC2_2BPP: return GL_UNSIGNED_BYTE; - case GFXFormat::PVRTC2_4BPP: return GL_UNSIGNED_BYTE; + case Format::PVRTC_RGB2: return GL_UNSIGNED_BYTE; + case Format::PVRTC_RGBA2: return GL_UNSIGNED_BYTE; + case Format::PVRTC_RGB4: return GL_UNSIGNED_BYTE; + case Format::PVRTC_RGBA4: return GL_UNSIGNED_BYTE; + case Format::PVRTC2_2BPP: return GL_UNSIGNED_BYTE; + case Format::PVRTC2_4BPP: return GL_UNSIGNED_BYTE; default: { return GL_UNSIGNED_BYTE; @@ -475,9 +475,9 @@ const GLenum GLES3_BLEND_FACTORS[] = { } // namespace void GLES3CmdFuncCreateBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer) { - GLenum glUsage = (gpuBuffer->memUsage & GFXMemoryUsageBit::HOST ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); + GLenum glUsage = (gpuBuffer->memUsage & MemoryUsageBit::HOST ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); - if (gpuBuffer->usage & GFXBufferUsageBit::VERTEX) { + if (gpuBuffer->usage & BufferUsageBit::VERTEX) { gpuBuffer->glTarget = GL_ARRAY_BUFFER; glGenBuffers(1, &gpuBuffer->glBuffer); if (gpuBuffer->size) { @@ -496,7 +496,7 @@ void GLES3CmdFuncCreateBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer) { glBindBuffer(GL_ARRAY_BUFFER, 0); device->stateCache->glArrayBuffer = 0; } - } else if (gpuBuffer->usage & GFXBufferUsageBit::INDEX) { + } else if (gpuBuffer->usage & BufferUsageBit::INDEX) { gpuBuffer->glTarget = GL_ELEMENT_ARRAY_BUFFER; glGenBuffers(1, &gpuBuffer->glBuffer); if (gpuBuffer->size) { @@ -515,7 +515,7 @@ void GLES3CmdFuncCreateBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer) { glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); device->stateCache->glElementArrayBuffer = 0; } - } else if (gpuBuffer->usage & GFXBufferUsageBit::UNIFORM) { + } else if (gpuBuffer->usage & BufferUsageBit::UNIFORM) { gpuBuffer->glTarget = GL_UNIFORM_BUFFER; glGenBuffers(1, &gpuBuffer->glBuffer); if (gpuBuffer->size) { @@ -527,31 +527,31 @@ void GLES3CmdFuncCreateBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer) { glBindBuffer(GL_UNIFORM_BUFFER, 0); device->stateCache->glUniformBuffer = 0; } - } else if (gpuBuffer->usage & GFXBufferUsageBit::INDIRECT) { + } else if (gpuBuffer->usage & BufferUsageBit::INDIRECT) { gpuBuffer->glTarget = GL_NONE; - } else if ((gpuBuffer->usage & GFXBufferUsageBit::TRANSFER_DST) || - (gpuBuffer->usage & GFXBufferUsageBit::TRANSFER_SRC)) { + } else if ((gpuBuffer->usage & BufferUsageBit::TRANSFER_DST) || + (gpuBuffer->usage & BufferUsageBit::TRANSFER_SRC)) { gpuBuffer->buffer = (uint8_t *)CC_MALLOC(gpuBuffer->size); gpuBuffer->glTarget = GL_NONE; } else { - CCASSERT(false, "Unsupported GFXBufferType, create buffer failed."); + CCASSERT(false, "Unsupported BufferType, create buffer failed."); gpuBuffer->glTarget = GL_NONE; } } void GLES3CmdFuncDestroyBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer) { if (gpuBuffer->glBuffer) { - if (gpuBuffer->usage & GFXBufferUsageBit::VERTEX) { + if (gpuBuffer->usage & BufferUsageBit::VERTEX) { if (device->stateCache->glArrayBuffer == gpuBuffer->glBuffer) { glBindBuffer(GL_ARRAY_BUFFER, 0); device->stateCache->glArrayBuffer = 0; } - } else if (gpuBuffer->usage & GFXBufferUsageBit::INDEX) { + } else if (gpuBuffer->usage & BufferUsageBit::INDEX) { if (device->stateCache->glElementArrayBuffer == gpuBuffer->glBuffer) { glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); device->stateCache->glElementArrayBuffer = 0; } - } else if (gpuBuffer->usage & GFXBufferUsageBit::UNIFORM) { + } else if (gpuBuffer->usage & BufferUsageBit::UNIFORM) { auto *ubo = device->stateCache->glBindUBOs; for (auto i = 0; i < GFX_MAX_BUFFER_BINDINGS; i++) { if (ubo[i] == gpuBuffer->glBuffer) { @@ -572,9 +572,9 @@ void GLES3CmdFuncDestroyBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer) { } void GLES3CmdFuncResizeBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer) { - GLenum glUsage = (gpuBuffer->memUsage & GFXMemoryUsageBit::HOST ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); + GLenum glUsage = (gpuBuffer->memUsage & MemoryUsageBit::HOST ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); - if (gpuBuffer->usage & GFXBufferUsageBit::VERTEX) { + if (gpuBuffer->usage & BufferUsageBit::VERTEX) { gpuBuffer->glTarget = GL_ARRAY_BUFFER; if (gpuBuffer->size) { if (device->useVAO()) { @@ -592,7 +592,7 @@ void GLES3CmdFuncResizeBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer) { glBindBuffer(GL_ARRAY_BUFFER, 0); device->stateCache->glArrayBuffer = 0; } - } else if (gpuBuffer->usage & GFXBufferUsageBit::INDEX) { + } else if (gpuBuffer->usage & BufferUsageBit::INDEX) { gpuBuffer->glTarget = GL_ELEMENT_ARRAY_BUFFER; if (gpuBuffer->size) { if (device->useVAO()) { @@ -610,7 +610,7 @@ void GLES3CmdFuncResizeBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer) { glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); device->stateCache->glElementArrayBuffer = 0; } - } else if (gpuBuffer->usage & GFXBufferUsageBit::UNIFORM) { + } else if (gpuBuffer->usage & BufferUsageBit::UNIFORM) { gpuBuffer->glTarget = GL_UNIFORM_BUFFER; if (gpuBuffer->size) { if (device->stateCache->glUniformBuffer != gpuBuffer->glBuffer) { @@ -621,26 +621,26 @@ void GLES3CmdFuncResizeBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer) { glBindBuffer(GL_UNIFORM_BUFFER, 0); device->stateCache->glUniformBuffer = 0; } - } else if (gpuBuffer->usage & GFXBufferUsageBit::INDIRECT) { + } else if (gpuBuffer->usage & BufferUsageBit::INDIRECT) { gpuBuffer->indirects.resize(gpuBuffer->count); gpuBuffer->glTarget = GL_NONE; - } else if ((gpuBuffer->usage & GFXBufferUsageBit::TRANSFER_DST) || - (gpuBuffer->usage & GFXBufferUsageBit::TRANSFER_SRC)) { + } else if ((gpuBuffer->usage & BufferUsageBit::TRANSFER_DST) || + (gpuBuffer->usage & BufferUsageBit::TRANSFER_SRC)) { if (gpuBuffer->buffer) { CC_FREE(gpuBuffer->buffer); } gpuBuffer->buffer = (uint8_t *)CC_MALLOC(gpuBuffer->size); gpuBuffer->glTarget = GL_NONE; } else { - CCASSERT(false, "Unsupported GFXBufferType, resize buffer failed."); + CCASSERT(false, "Unsupported BufferType, resize buffer failed."); gpuBuffer->glTarget = GL_NONE; } } void GLES3CmdFuncUpdateBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer, void *buffer, uint offset, uint size) { - if (gpuBuffer->usage & GFXBufferUsageBit::INDIRECT) { + if (gpuBuffer->usage & BufferUsageBit::INDIRECT) { memcpy((uint8_t *)gpuBuffer->indirects.data() + offset, buffer, size); - } else if (gpuBuffer->usage & GFXBufferUsageBit::TRANSFER_SRC) { + } else if (gpuBuffer->usage & BufferUsageBit::TRANSFER_SRC) { memcpy((uint8_t *)gpuBuffer->buffer + offset, buffer, size); } else { switch (gpuBuffer->glTarget) { @@ -677,7 +677,7 @@ void GLES3CmdFuncUpdateBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer, vo break; } default: - CCASSERT(false, "Unsupported GFXBufferType, update buffer failed."); + CCASSERT(false, "Unsupported BufferType, update buffer failed."); break; } } @@ -686,10 +686,10 @@ void GLES3CmdFuncUpdateBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer, vo void GLES3CmdFuncCreateTexture(GLES3Device *device, GLES3GPUTexture *gpuTexture) { gpuTexture->glInternelFmt = MapGLInternalFormat(gpuTexture->format); gpuTexture->glFormat = MapGLFormat(gpuTexture->format); - gpuTexture->glType = GFXFormatToGLType(gpuTexture->format); + gpuTexture->glType = FormatToGLType(gpuTexture->format); switch (gpuTexture->type) { - case GFXTextureType::TEX2D: { + case TextureType::TEX2D: { gpuTexture->glTarget = GL_TEXTURE_2D; glGenTextures(1, &gpuTexture->glTexture); if (gpuTexture->size > 0) { @@ -708,7 +708,7 @@ void GLES3CmdFuncCreateTexture(GLES3Device *device, GLES3GPUTexture *gpuTexture) } } else { for (uint i = 0; i < gpuTexture->mipLevel; ++i) { - uint img_size = GFXFormatSize(gpuTexture->format, w, h, 1); + uint img_size = FormatSize(gpuTexture->format, w, h, 1); glCompressedTexImage2D(GL_TEXTURE_2D, i, gpuTexture->glInternelFmt, w, h, 0, img_size, nullptr); w = std::max(1U, w >> 1); h = std::max(1U, h >> 1); @@ -717,7 +717,7 @@ void GLES3CmdFuncCreateTexture(GLES3Device *device, GLES3GPUTexture *gpuTexture) } break; } - case GFXTextureType::CUBE: { + case TextureType::CUBE: { gpuTexture->glTarget = GL_TEXTURE_CUBE_MAP; glGenTextures(1, &gpuTexture->glTexture); if (gpuTexture->size > 0) { @@ -741,7 +741,7 @@ void GLES3CmdFuncCreateTexture(GLES3Device *device, GLES3GPUTexture *gpuTexture) uint w = gpuTexture->width; uint h = gpuTexture->height; for (uint i = 0; i < gpuTexture->mipLevel; ++i) { - uint img_size = GFXFormatSize(gpuTexture->format, w, h, 1); + uint img_size = FormatSize(gpuTexture->format, w, h, 1); glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + f, i, gpuTexture->glInternelFmt, w, h, 0, img_size, nullptr); w = std::max(1U, w >> 1); h = std::max(1U, h >> 1); @@ -752,7 +752,7 @@ void GLES3CmdFuncCreateTexture(GLES3Device *device, GLES3GPUTexture *gpuTexture) break; } default: - CCASSERT(false, "Unsupported GFXTextureType, create texture failed."); + CCASSERT(false, "Unsupported TextureType, create texture failed."); break; } } @@ -762,11 +762,11 @@ void GLES3CmdFuncDestroyTexture(GLES3Device *device, GLES3GPUTexture *gpuTexture GLuint &glTexture = device->stateCache->glTextures[device->stateCache->texUint]; if (glTexture == gpuTexture->glTexture) { switch (gpuTexture->type) { - case GFXTextureType::TEX2D: { + case TextureType::TEX2D: { glBindTexture(GL_TEXTURE_2D, 0); break; } - case GFXTextureType::CUBE: { + case TextureType::CUBE: { glBindTexture(GL_TEXTURE_CUBE_MAP, 0); break; } @@ -781,10 +781,10 @@ void GLES3CmdFuncDestroyTexture(GLES3Device *device, GLES3GPUTexture *gpuTexture void GLES3CmdFuncResizeTexture(GLES3Device *device, GLES3GPUTexture *gpuTexture) { gpuTexture->glInternelFmt = MapGLInternalFormat(gpuTexture->format); gpuTexture->glFormat = MapGLFormat(gpuTexture->format); - gpuTexture->glType = GFXFormatToGLType(gpuTexture->format); + gpuTexture->glType = FormatToGLType(gpuTexture->format); switch (gpuTexture->type) { - case GFXTextureType::TEX2D: { + case TextureType::TEX2D: { gpuTexture->glTarget = GL_TEXTURE_2D; if (gpuTexture->size > 0) { GLuint &glTexture = device->stateCache->glTextures[device->stateCache->texUint]; @@ -802,7 +802,7 @@ void GLES3CmdFuncResizeTexture(GLES3Device *device, GLES3GPUTexture *gpuTexture) } } else { for (uint i = 0; i < gpuTexture->mipLevel; ++i) { - uint img_size = GFXFormatSize(gpuTexture->format, w, h, 1); + uint img_size = FormatSize(gpuTexture->format, w, h, 1); glCompressedTexImage2D(GL_TEXTURE_2D, i, gpuTexture->glInternelFmt, w, h, 0, img_size, nullptr); w = std::max(1U, w >> 1); h = std::max(1U, h >> 1); @@ -811,7 +811,7 @@ void GLES3CmdFuncResizeTexture(GLES3Device *device, GLES3GPUTexture *gpuTexture) } break; } - case GFXTextureType::CUBE: { + case TextureType::CUBE: { gpuTexture->glTarget = GL_TEXTURE_CUBE_MAP; if (gpuTexture->size > 0) { GLuint &glTexture = device->stateCache->glTextures[device->stateCache->texUint]; @@ -834,7 +834,7 @@ void GLES3CmdFuncResizeTexture(GLES3Device *device, GLES3GPUTexture *gpuTexture) uint w = gpuTexture->width; uint h = gpuTexture->height; for (uint i = 0; i < gpuTexture->mipLevel; ++i) { - uint img_size = GFXFormatSize(gpuTexture->format, w, h, 1); + uint img_size = FormatSize(gpuTexture->format, w, h, 1); glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + f, i, gpuTexture->glInternelFmt, w, h, 0, img_size, nullptr); w = std::max(1U, w >> 1); h = std::max(1U, h >> 1); @@ -845,32 +845,32 @@ void GLES3CmdFuncResizeTexture(GLES3Device *device, GLES3GPUTexture *gpuTexture) break; } default: - CCASSERT(false, "Unsupported GFXTextureType, resize texture failed."); + CCASSERT(false, "Unsupported TextureType, resize texture failed."); break; } } void GLES3CmdFuncCreateSampler(GLES3Device *device, GLES3GPUSampler *gpuSampler) { glGenSamplers(1, &gpuSampler->gl_sampler); - if (gpuSampler->minFilter == GFXFilter::LINEAR || gpuSampler->minFilter == GFXFilter::ANISOTROPIC) { - if (gpuSampler->mipFilter == GFXFilter::LINEAR || gpuSampler->mipFilter == GFXFilter::ANISOTROPIC) { + if (gpuSampler->minFilter == Filter::LINEAR || gpuSampler->minFilter == Filter::ANISOTROPIC) { + if (gpuSampler->mipFilter == Filter::LINEAR || gpuSampler->mipFilter == Filter::ANISOTROPIC) { gpuSampler->glMinFilter = GL_LINEAR_MIPMAP_LINEAR; - } else if (gpuSampler->mipFilter == GFXFilter::POINT) { + } else if (gpuSampler->mipFilter == Filter::POINT) { gpuSampler->glMinFilter = GL_LINEAR_MIPMAP_NEAREST; } else { gpuSampler->glMinFilter = GL_LINEAR; } } else { - if (gpuSampler->mipFilter == GFXFilter::LINEAR || gpuSampler->mipFilter == GFXFilter::ANISOTROPIC) { + if (gpuSampler->mipFilter == Filter::LINEAR || gpuSampler->mipFilter == Filter::ANISOTROPIC) { gpuSampler->glMinFilter = GL_NEAREST_MIPMAP_LINEAR; - } else if (gpuSampler->mipFilter == GFXFilter::POINT) { + } else if (gpuSampler->mipFilter == Filter::POINT) { gpuSampler->glMinFilter = GL_NEAREST_MIPMAP_NEAREST; } else { gpuSampler->glMinFilter = GL_NEAREST; } } - if (gpuSampler->magFilter == GFXFilter::LINEAR || gpuSampler->magFilter == GFXFilter::ANISOTROPIC) { + if (gpuSampler->magFilter == Filter::LINEAR || gpuSampler->magFilter == Filter::ANISOTROPIC) { gpuSampler->glMagFilter = GL_LINEAR; } else { gpuSampler->glMagFilter = GL_NEAREST; @@ -910,18 +910,18 @@ void GLES3CmdFuncCreateShader(GLES3Device *device, GLES3GPUShader *gpuShader) { GLES3GPUShaderStage &gpu_stage = gpuShader->gpuStages[i]; switch (gpu_stage.type) { - case GFXShaderType::VERTEX: { + case ShaderType::VERTEX: { gl_shader_type = GL_VERTEX_SHADER; shader_type_str = "Vertex Shader"; break; } - case GFXShaderType::FRAGMENT: { + case ShaderType::FRAGMENT: { gl_shader_type = GL_FRAGMENT_SHADER; shader_type_str = "Fragment Shader"; break; } default: { - CCASSERT(false, "Unsupported GFXShaderType"); + CCASSERT(false, "Unsupported ShaderType"); return; } } @@ -1014,7 +1014,7 @@ void GLES3CmdFuncCreateShader(GLES3Device *device, GLES3GPUShader *gpuShader) { gpuInput.glLoc = glGetAttribLocation(gpuShader->glProgram, gl_name); gpuInput.binding = gpuInput.glLoc; gpuInput.name = gl_name; - gpuInput.type = MapGFXType(glType); + gpuInput.type = MapType(glType); gpuInput.stride = GLTypeSize(glType); gpuInput.count = gl_size; gpuInput.size = gpuInput.stride * gpuInput.count; @@ -1043,7 +1043,7 @@ void GLES3CmdFuncCreateShader(GLES3Device *device, GLES3GPUShader *gpuShader) { gpuBlock.name = gl_name; gpuBlock.binding = GFX_INVALID_BINDING; for (size_t b = 0; b < gpuShader->blocks.size(); ++b) { - GFXUniformBlock &block = gpuShader->blocks[b]; + UniformBlock &block = gpuShader->blocks[b]; if (block.name == gpuBlock.name) { gpuBlock.binding = block.binding; break; @@ -1082,7 +1082,7 @@ void GLES3CmdFuncCreateShader(GLES3Device *device, GLES3GPUShader *gpuShader) { uniform.binding = GFX_INVALID_BINDING; uniform.name = gl_name; - uniform.type = MapGFXType(glType); + uniform.type = MapType(glType); uniform.stride = GFX_TYPE_SIZES[(int)uniform.type]; uniform.count = gl_size; uniform.size = uniform.stride * uniform.count; @@ -1099,7 +1099,7 @@ void GLES3CmdFuncCreateShader(GLES3Device *device, GLES3GPUShader *gpuShader) { gpuShader->glSamplers.resize(gpuShader->samplers.size()); for (size_t i = 0; i < gpuShader->glSamplers.size(); ++i) { - GFXUniformSampler &sampler = gpuShader->samplers[i]; + UniformSampler &sampler = gpuShader->samplers[i]; GLES3GPUUniformSampler &gpuSampler = gpuShader->glSamplers[i]; gpuSampler.binding = sampler.binding; gpuSampler.name = sampler.name; @@ -1193,12 +1193,12 @@ void GLES3CmdFuncCreateInputAssembler(GLES3Device *device, GLES3GPUInputAssemble gpuInputAssembler->glAttribs.resize(gpuInputAssembler->attributes.size()); for (size_t i = 0; i < gpuInputAssembler->glAttribs.size(); ++i) { GLES3GPUAttribute &gpuAttribute = gpuInputAssembler->glAttribs[i]; - const GFXAttribute &attrib = gpuInputAssembler->attributes[i]; + const Attribute &attrib = gpuInputAssembler->attributes[i]; GLES3GPUBuffer *gpu_vb = (GLES3GPUBuffer *)gpuInputAssembler->gpuVertexBuffers[attrib.stream]; gpuAttribute.name = attrib.name; - gpuAttribute.glType = GFXFormatToGLType(attrib.format); + gpuAttribute.glType = FormatToGLType(attrib.format); gpuAttribute.size = GFX_FORMAT_INFOS[(int)attrib.format].size; gpuAttribute.count = GFX_FORMAT_INFOS[(int)attrib.format].count; gpuAttribute.componentCount = GLComponentCount(gpuAttribute.glType); @@ -1349,13 +1349,13 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) gpuRenderPass = cmd->gpuFBO->gpuRenderPass; for (uint j = 0; j < cmd->num_clear_colors; ++j) { - const GFXColorAttachment &colorAttachment = gpuRenderPass->colorAttachments[j]; - if (colorAttachment.format != GFXFormat::UNKNOWN) { + const ColorAttachment &colorAttachment = gpuRenderPass->colorAttachments[j]; + if (colorAttachment.format != Format::UNKNOWN) { switch (colorAttachment.loadOp) { - case GFXLoadOp::LOAD: break; // GL default behaviour - case GFXLoadOp::CLEAR: { - if (cmd->clear_flags & GFXClearFlagBit::COLOR) { - if (cache->bs.targets[0].blendColorMask != GFXColorMask::ALL) { + case LoadOp::LOAD: break; // GL default behaviour + case LoadOp::CLEAR: { + if (cmd->clear_flags & ClearFlagBit::COLOR) { + if (cache->bs.targets[0].blendColorMask != ColorMask::ALL) { glColorMask(true, true, true, true); } @@ -1367,14 +1367,14 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) f_colors[3] = cmd->clear_colors[j].a; glClearBufferfv(GL_COLOR, j, f_colors); } else { - const GFXColor &color = cmd->clear_colors[j]; + const Color &color = cmd->clear_colors[j]; glClearColor(color.r, color.g, color.b, color.a); gl_clears |= GL_COLOR_BUFFER_BIT; } } break; } - case GFXLoadOp::DISCARD: { + case LoadOp::DISCARD: { // invalidate fbo gl_attachments[num_attachments++] = (cmd->gpuFBO->isOffscreen ? GL_COLOR_ATTACHMENT0 + j : GL_COLOR); break; @@ -1384,19 +1384,19 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) } } // for - if (gpuRenderPass->depthStencilAttachment.format != GFXFormat::UNKNOWN) { + if (gpuRenderPass->depthStencilAttachment.format != Format::UNKNOWN) { bool hasDepth = GFX_FORMAT_INFOS[(int)gpuRenderPass->depthStencilAttachment.format].hasDepth; if (hasDepth) { switch (gpuRenderPass->depthStencilAttachment.depthLoadOp) { - case GFXLoadOp::LOAD: break; // GL default behaviour - case GFXLoadOp::CLEAR: { + case LoadOp::LOAD: break; // GL default behaviour + case LoadOp::CLEAR: { glDepthMask(true); cache->dss.depthWrite = true; glClearDepthf(cmd->clear_depth); gl_clears |= GL_DEPTH_BUFFER_BIT; break; } - case GFXLoadOp::DISCARD: { + case LoadOp::DISCARD: { // invalidate fbo gl_attachments[num_attachments++] = (cmd->gpuFBO->isOffscreen ? GL_DEPTH_ATTACHMENT : GL_DEPTH); break; @@ -1407,8 +1407,8 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) bool has_stencils = GFX_FORMAT_INFOS[(int)gpuRenderPass->depthStencilAttachment.format].hasStencil; if (has_stencils) { switch (gpuRenderPass->depthStencilAttachment.depthLoadOp) { - case GFXLoadOp::LOAD: break; // GL default behaviour - case GFXLoadOp::CLEAR: { + case LoadOp::LOAD: break; // GL default behaviour + case LoadOp::CLEAR: { if (!cache->dss.stencilWriteMaskFront) { glStencilMaskSeparate(GL_FRONT, 0xffffffff); } @@ -1419,7 +1419,7 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) gl_clears |= GL_STENCIL_BUFFER_BIT; break; } - case GFXLoadOp::DISCARD: { + case LoadOp::DISCARD: { // invalidate fbo gl_attachments[num_attachments++] = (cmd->gpuFBO->isOffscreen ? GL_STENCIL_ATTACHMENT : GL_STENCIL); break; @@ -1439,12 +1439,12 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) // restore states if (gl_clears & GL_COLOR_BUFFER_BIT) { - GFXColorMask color_mask = cache->bs.targets[0].blendColorMask; - if (color_mask != GFXColorMask::ALL) { - glColorMask((GLboolean)(color_mask & GFXColorMask::R), - (GLboolean)(color_mask & GFXColorMask::G), - (GLboolean)(color_mask & GFXColorMask::B), - (GLboolean)(color_mask & GFXColorMask::A)); + ColorMask color_mask = cache->bs.targets[0].blendColorMask; + if (color_mask != ColorMask::ALL) { + glColorMask((GLboolean)(color_mask & ColorMask::R), + (GLboolean)(color_mask & ColorMask::G), + (GLboolean)(color_mask & ColorMask::B), + (GLboolean)(color_mask & ColorMask::A)); } } @@ -1467,12 +1467,12 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) GLES3CmdBeginRenderPass *cmd = cmdBeginRenderPass; uint num_attachments = 0; for (uint j = 0; j < cmd->num_clear_colors; ++j) { - const GFXColorAttachment &colorAttachment = gpuRenderPass->colorAttachments[j]; - if (colorAttachment.format != GFXFormat::UNKNOWN) { + const ColorAttachment &colorAttachment = gpuRenderPass->colorAttachments[j]; + if (colorAttachment.format != Format::UNKNOWN) { switch (colorAttachment.loadOp) { - case GFXLoadOp::LOAD: break; // GL default behaviour - case GFXLoadOp::CLEAR: break; - case GFXLoadOp::DISCARD: { + case LoadOp::LOAD: break; // GL default behaviour + case LoadOp::CLEAR: break; + case LoadOp::DISCARD: { // invalidate fbo gl_attachments[num_attachments++] = (cmd->gpuFBO->isOffscreen ? GL_COLOR_ATTACHMENT0 + j : GL_COLOR); break; @@ -1482,13 +1482,13 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) } } // for - if (gpuRenderPass->depthStencilAttachment.format != GFXFormat::UNKNOWN) { + if (gpuRenderPass->depthStencilAttachment.format != Format::UNKNOWN) { bool hasDepth = GFX_FORMAT_INFOS[(int)gpuRenderPass->depthStencilAttachment.format].hasDepth; if (hasDepth) { switch (gpuRenderPass->depthStencilAttachment.depthLoadOp) { - case GFXLoadOp::LOAD: break; // GL default behaviour - case GFXLoadOp::CLEAR: break; - case GFXLoadOp::DISCARD: { + case LoadOp::LOAD: break; // GL default behaviour + case LoadOp::CLEAR: break; + case LoadOp::DISCARD: { // invalidate fbo gl_attachments[num_attachments++] = (cmd->gpuFBO->isOffscreen ? GL_DEPTH_ATTACHMENT : GL_DEPTH); break; @@ -1499,9 +1499,9 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) bool has_stencils = GFX_FORMAT_INFOS[(int)gpuRenderPass->depthStencilAttachment.format].hasStencil; if (has_stencils) { switch (gpuRenderPass->depthStencilAttachment.depthLoadOp) { - case GFXLoadOp::LOAD: break; // GL default behaviour - case GFXLoadOp::CLEAR: break; - case GFXLoadOp::DISCARD: { + case LoadOp::LOAD: break; // GL default behaviour + case LoadOp::CLEAR: break; + case LoadOp::DISCARD: { // invalidate fbo gl_attachments[num_attachments++] = (cmd->gpuFBO->isOffscreen ? GL_STENCIL_ATTACHMENT : GL_STENCIL); break; @@ -1535,20 +1535,20 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) // bind rasterizer state if (cache->rs.cullMode != gpuPipelineState->rs.cullMode) { switch (gpuPipelineState->rs.cullMode) { - case GFXCullMode::NONE: { + case CullMode::NONE: { if (cache->isCullFaceEnabled) { glDisable(GL_CULL_FACE); cache->isCullFaceEnabled = false; } } break; - case GFXCullMode::FRONT: { + case CullMode::FRONT: { if (!cache->isCullFaceEnabled) { glEnable(GL_CULL_FACE); cache->isCullFaceEnabled = true; } glCullFace(GL_FRONT); } break; - case GFXCullMode::BACK: { + case CullMode::BACK: { if (!cache->isCullFaceEnabled) { glEnable(GL_CULL_FACE); cache->isCullFaceEnabled = true; @@ -1681,8 +1681,8 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) cache->bs.blendColor = gpuPipelineState->bs.blendColor; } - GFXBlendTarget &cache_target = cache->bs.targets[0]; - const GFXBlendTarget &target = gpuPipelineState->bs.targets[0]; + BlendTarget &cache_target = cache->bs.targets[0]; + const BlendTarget &target = gpuPipelineState->bs.targets[0]; if (cache_target.blend != target.blend) { if (!cache_target.blend) { glEnable(GL_BLEND); @@ -1712,10 +1712,10 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) cache_target.blendDstAlpha = target.blendDstAlpha; } if (cache_target.blendColorMask != target.blendColorMask) { - glColorMask((GLboolean)(target.blendColorMask & GFXColorMask::R), - (GLboolean)(target.blendColorMask & GFXColorMask::G), - (GLboolean)(target.blendColorMask & GFXColorMask::B), - (GLboolean)(target.blendColorMask & GFXColorMask::A)); + glColorMask((GLboolean)(target.blendColorMask & ColorMask::R), + (GLboolean)(target.blendColorMask & ColorMask::G), + (GLboolean)(target.blendColorMask & ColorMask::B), + (GLboolean)(target.blendColorMask & ColorMask::A)); cache_target.blendColorMask = target.blendColorMask; } @@ -1724,7 +1724,7 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) for (size_t j = 0; j < cmd->gpuBindingLayout->gpuBindings.size(); ++j) { const GLES3GPUBinding &gpuBinding = cmd->gpuBindingLayout->gpuBindings[j]; switch (gpuBinding.type) { - case GFXBindingType::UNIFORM_BUFFER: { + case BindingType::UNIFORM_BUFFER: { if (gpuBinding.gpuBuffer) { for (size_t k = 0; k < gpuPipelineState->gpuShader->glBlocks.size(); ++k) { const GLES3GPUUniformBlock &gpuBlock = gpuPipelineState->gpuShader->glBlocks[k]; @@ -1737,7 +1737,7 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) } break; } - case GFXBindingType::SAMPLER: { + case BindingType::SAMPLER: { if (gpuBinding.gpuSampler) { for (size_t k = 0; k < gpuPipelineState->gpuShader->glSamplers.size(); ++k) { const GLES3GPUUniformSampler &gpuSampler = gpuPipelineState->gpuShader->glSamplers[k]; @@ -1872,25 +1872,25 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) if (gpuPipelineState) { for (auto dynamicState : gpuPipelineState->dynamicStates) { switch (dynamicState) { - case GFXDynamicState::VIEWPORT: + case DynamicState::VIEWPORT: if (cache->viewport != cmd->viewport) { glViewport(cmd->viewport.left, cmd->viewport.top, cmd->viewport.width, cmd->viewport.height); cache->viewport = cmd->viewport; } break; - case GFXDynamicState::SCISSOR: + case DynamicState::SCISSOR: if (cache->scissor != cmd->scissor) { glScissor(cmd->scissor.x, cmd->scissor.y, cmd->scissor.width, cmd->scissor.height); cache->scissor = cmd->scissor; } break; - case GFXDynamicState::LINE_WIDTH: + case DynamicState::LINE_WIDTH: if (cache->rs.lineWidth != cmd->lineWidth) { glLineWidth(cmd->lineWidth); cache->rs.lineWidth = cmd->lineWidth; } break; - case GFXDynamicState::DEPTH_BIAS: + case DynamicState::DEPTH_BIAS: if (cache->rs.depthBiasEnabled != cmd->depthBiasEnabled) { if (cmd->depthBiasEnabled) glEnable(GL_POLYGON_OFFSET_FILL); @@ -1906,7 +1906,7 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) cache->rs.depthBiasSlop = cmd->depthBias.slope; } break; - case GFXDynamicState::BLEND_CONSTANTS: + case DynamicState::BLEND_CONSTANTS: if ((cache->bs.blendColor.r != gpuPipelineState->bs.blendColor.r) || (cache->bs.blendColor.g != gpuPipelineState->bs.blendColor.g) || (cache->bs.blendColor.b != gpuPipelineState->bs.blendColor.b) || @@ -1918,21 +1918,21 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) cache->bs.blendColor = gpuPipelineState->bs.blendColor; } break; - case GFXDynamicState::STENCIL_WRITE_MASK: + case DynamicState::STENCIL_WRITE_MASK: switch (cmd->stencilWriteMask.face) { - case GFXStencilFace::FRONT: + case StencilFace::FRONT: if (cache->dss.stencilWriteMaskFront != cmd->stencilWriteMask.write_mask) { glStencilMaskSeparate(GL_FRONT, cmd->stencilWriteMask.write_mask); cache->dss.stencilWriteMaskFront = cmd->stencilWriteMask.write_mask; } break; - case GFXStencilFace::BACK: + case StencilFace::BACK: if (cache->dss.stencilWriteMaskBack != cmd->stencilWriteMask.write_mask) { glStencilMaskSeparate(GL_BACK, cmd->stencilWriteMask.write_mask); cache->dss.stencilWriteMaskBack = cmd->stencilWriteMask.write_mask; } break; - case GFXStencilFace::ALL: + case StencilFace::ALL: if ((cache->dss.stencilWriteMaskFront != cmd->stencilWriteMask.write_mask) || (cache->dss.stencilWriteMaskBack != cmd->stencilWriteMask.write_mask)) { glStencilMask(cmd->stencilWriteMask.write_mask); @@ -1942,9 +1942,9 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) break; } break; - case GFXDynamicState::STENCIL_COMPARE_MASK: + case DynamicState::STENCIL_COMPARE_MASK: switch (cmd->stencilCompareMask.face) { - case GFXStencilFace::FRONT: + case StencilFace::FRONT: if ((cache->dss.stencilRefFront != (uint)cmd->stencilCompareMask.refrence) || (cache->dss.stencilReadMaskFront != cmd->stencilCompareMask.compare_mask)) { glStencilFuncSeparate(GL_FRONT, @@ -1955,7 +1955,7 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) cache->dss.stencilReadMaskFront = cmd->stencilCompareMask.compare_mask; } break; - case GFXStencilFace::BACK: + case StencilFace::BACK: if ((cache->dss.stencilRefBack != (uint)cmd->stencilCompareMask.refrence) || (cache->dss.stencilReadMaskBack != cmd->stencilCompareMask.compare_mask)) { glStencilFuncSeparate(GL_BACK, @@ -1966,7 +1966,7 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) cache->dss.stencilReadMaskBack = cmd->stencilCompareMask.compare_mask; } break; - case GFXStencilFace::ALL: + case StencilFace::ALL: if ((cache->dss.stencilRefFront != (uint)cmd->stencilCompareMask.refrence) || (cache->dss.stencilReadMaskFront != cmd->stencilCompareMask.compare_mask) || (cache->dss.stencilRefBack != (uint)cmd->stencilCompareMask.refrence) || @@ -2016,7 +2016,7 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) } } else { for (size_t j = 0; j < gpuInputAssembler->gpuIndirectBuffer->indirects.size(); ++j) { - const GFXDrawInfo &draw = gpuInputAssembler->gpuIndirectBuffer->indirects[j]; + const DrawInfo &draw = gpuInputAssembler->gpuIndirectBuffer->indirects[j]; if (gpuInputAssembler->gpuIndexBuffer && draw.indexCount >= 0) { uint8_t *offset = 0; offset += draw.firstIndex * gpuInputAssembler->gpuIndexBuffer->stride; @@ -2054,7 +2054,7 @@ void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package) } } -void GLES3CmdFuncCopyBuffersToTexture(GLES3Device *device, uint8_t *const *buffers, GLES3GPUTexture *gpuTexture, const GFXBufferTextureCopyList ®ions) { +void GLES3CmdFuncCopyBuffersToTexture(GLES3Device *device, uint8_t *const *buffers, GLES3GPUTexture *gpuTexture, const BufferTextureCopyList ®ions) { GLuint &glTexture = device->stateCache->glTextures[device->stateCache->texUint]; if (glTexture != gpuTexture->glTexture) { glBindTexture(gpuTexture->glTarget, gpuTexture->glTexture); @@ -2069,12 +2069,12 @@ void GLES3CmdFuncCopyBuffersToTexture(GLES3Device *device, uint8_t *const *buffe uint w; uint h; for (size_t i = 0; i < regions.size(); ++i) { - const GFXBufferTextureCopy ®ion = regions[i]; + const BufferTextureCopy ®ion = regions[i]; w = region.texExtent.width; h = region.texExtent.height; uint8_t *buff = buffers[n++]; if (isCompressed) { - GLsizei memSize = (GLsizei)GFXFormatSize(gpuTexture->format, w, h, 1); + GLsizei memSize = (GLsizei)FormatSize(gpuTexture->format, w, h, 1); glCompressedTexSubImage2D(GL_TEXTURE_2D, region.texSubres.mipLevel, region.texOffset.x, @@ -2100,7 +2100,7 @@ void GLES3CmdFuncCopyBuffersToTexture(GLES3Device *device, uint8_t *const *buffe uint w; uint h; for (size_t i = 0; i < regions.size(); ++i) { - const GFXBufferTextureCopy ®ion = regions[i]; + const BufferTextureCopy ®ion = regions[i]; uint d = region.texSubres.layerCount; uint layerCount = d + region.texSubres.baseArrayLayer; @@ -2109,7 +2109,7 @@ void GLES3CmdFuncCopyBuffersToTexture(GLES3Device *device, uint8_t *const *buffe h = region.texExtent.height; uint8_t *buff = buffers[n++]; if (isCompressed) { - GLsizei memSize = (GLsizei)GFXFormatSize(gpuTexture->format, w, h, 1); + GLsizei memSize = (GLsizei)FormatSize(gpuTexture->format, w, h, 1); glCompressedTexSubImage3D(GL_TEXTURE_2D_ARRAY, region.texSubres.mipLevel, region.texOffset.x, @@ -2139,13 +2139,13 @@ void GLES3CmdFuncCopyBuffersToTexture(GLES3Device *device, uint8_t *const *buffe uint h; uint d; for (size_t i = 0; i < regions.size(); ++i) { - const GFXBufferTextureCopy ®ion = regions[i]; + const BufferTextureCopy ®ion = regions[i]; w = region.texExtent.width; h = region.texExtent.height; d = region.texExtent.depth; uint8_t *buff = buffers[n++]; if (isCompressed) { - GLsizei memSize = (GLsizei)GFXFormatSize(gpuTexture->format, w, h, 1); + GLsizei memSize = (GLsizei)FormatSize(gpuTexture->format, w, h, 1); glCompressedTexSubImage3D(GL_TEXTURE_3D, region.texSubres.mipLevel, region.texOffset.x, @@ -2174,14 +2174,14 @@ void GLES3CmdFuncCopyBuffersToTexture(GLES3Device *device, uint8_t *const *buffe uint h; uint f; for (size_t i = 0; i < regions.size(); ++i) { - const GFXBufferTextureCopy ®ion = regions[i]; + const BufferTextureCopy ®ion = regions[i]; uint face_count = region.texSubres.baseArrayLayer + region.texSubres.layerCount; for (f = region.texSubres.baseArrayLayer; f < face_count; ++f) { w = region.texExtent.width; h = region.texExtent.height; uint8_t *buff = buffers[n++]; if (isCompressed) { - GLsizei memSize = (GLsizei)GFXFormatSize(gpuTexture->format, w, h, 1); + GLsizei memSize = (GLsizei)FormatSize(gpuTexture->format, w, h, 1); glCompressedTexSubImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + f, region.texSubres.mipLevel, region.texOffset.x, @@ -2206,11 +2206,11 @@ void GLES3CmdFuncCopyBuffersToTexture(GLES3Device *device, uint8_t *const *buffe break; } default: - CCASSERT(false, "Unsupported GFXTextureType, copy buffers to texture failed."); + CCASSERT(false, "Unsupported TextureType, copy buffers to texture failed."); break; } - if (!isCompressed && gpuTexture->flags & GFXTextureFlagBit::GEN_MIPMAP) { + if (!isCompressed && gpuTexture->flags & TextureFlagBit::GEN_MIPMAP) { glBindTexture(gpuTexture->glTarget, gpuTexture->glTexture); glGenerateMipmap(gpuTexture->glTarget); } diff --git a/native/cocos/renderer/gfx-gles3/GLES3Commands.h b/native/cocos/renderer/gfx-gles3/GLES3Commands.h index b4f14eac07..746272dee3 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Commands.h +++ b/native/cocos/renderer/gfx-gles3/GLES3Commands.h @@ -20,12 +20,12 @@ struct GLES3DepthBounds { }; struct GLES3StencilWriteMask { - GFXStencilFace face = GFXStencilFace::FRONT; + StencilFace face = StencilFace::FRONT; uint write_mask = 0; }; struct GLES3StencilCompareMask { - GFXStencilFace face = GFXStencilFace::FRONT; + StencilFace face = StencilFace::FRONT; int refrence = 0; uint compare_mask = 0; }; @@ -49,10 +49,10 @@ struct GLES3BufferTextureCopy { class GLES3CmdBeginRenderPass : public GFXCmd { public: GLES3GPUFramebuffer *gpuFBO = nullptr; - GFXRect render_area; - GFXClearFlags clear_flags = GFXClearFlagBit::NONE; + Rect render_area; + ClearFlags clear_flags = ClearFlagBit::NONE; uint num_clear_colors = 0; - GFXColor clear_colors[GFX_MAX_ATTACHMENTS]; + Color clear_colors[GFX_MAX_ATTACHMENTS]; float clear_depth = 1.0f; int clear_stencil = 0; @@ -82,12 +82,12 @@ public: GLES3GPUBindingLayout *gpuBindingLayout = nullptr; GLES3GPUInputAssembler *gpuInputAssembler = nullptr; uint8_t state_flags[(int)GLES3State::COUNT] = {0}; - GFXViewport viewport; - GFXRect scissor; + Viewport viewport; + Rect scissor; float lineWidth = 1.0f; bool depthBiasEnabled = false; GLES3DepthBias depthBias; - GFXColor blendConstants; + Color blendConstants; GLES3DepthBounds depthBounds; GLES3StencilWriteMask stencilWriteMask; GLES3StencilCompareMask stencilCompareMask; @@ -104,7 +104,7 @@ public: class GLES3CmdDraw : public GFXCmd { public: - GFXDrawInfo draw_info; + DrawInfo draw_info; GLES3CmdDraw() : GFXCmd(GFXCmdType::DRAW) {} virtual void clear() override {} @@ -129,8 +129,8 @@ class GLES3CmdCopyBufferToTexture : public GFXCmd { public: GLES3GPUBuffer *gpuBuffer = nullptr; GLES3GPUTexture *gpuTexture = nullptr; - GFXTextureLayout dst_layout; - GFXBufferTextureCopyList regions; + TextureLayout dst_layout; + BufferTextureCopyList regions; GLES3CmdCopyBufferToTexture() : GFXCmd(GFXCmdType::COPY_BUFFER_TO_TEXTURE) {} @@ -167,7 +167,7 @@ CC_GLES3_API void GLES3CmdFuncDestroyInputAssembler(GLES3Device *device, GLES3GP CC_GLES3_API void GLES3CmdFuncCreateFramebuffer(GLES3Device *device, GLES3GPUFramebuffer *gpuFBO); CC_GLES3_API void GLES3CmdFuncDestroyFramebuffer(GLES3Device *device, GLES3GPUFramebuffer *gpuFBO); CC_GLES3_API void GLES3CmdFuncExecuteCmds(GLES3Device *device, GLES3CmdPackage *cmd_package); -CC_GLES3_API void GLES3CmdFuncCopyBuffersToTexture(GLES3Device *device, uint8_t *const *buffers, GLES3GPUTexture *gpuTexture, const GFXBufferTextureCopyList ®ions); +CC_GLES3_API void GLES3CmdFuncCopyBuffersToTexture(GLES3Device *device, uint8_t *const *buffers, GLES3GPUTexture *gpuTexture, const BufferTextureCopyList ®ions); } // namespace gfx } // namespace cc diff --git a/native/cocos/renderer/gfx-gles3/GLES3Context.cc b/native/cocos/renderer/gfx-gles3/GLES3Context.cc index a3741c426e..24804e3480 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Context.cc +++ b/native/cocos/renderer/gfx-gles3/GLES3Context.cc @@ -64,8 +64,8 @@ void APIENTRY GLES3EGLDebugProc(GLenum source, GLenum type, GLuint id, GLenum se #endif -GLES3Context::GLES3Context(GFXDevice *device) -: GFXContext(device) { +GLES3Context::GLES3Context(Device *device) +: Context(device) { } GLES3Context::~GLES3Context() { @@ -73,7 +73,7 @@ GLES3Context::~GLES3Context() { #if (CC_PLATFORM == CC_PLATFORM_WINDOWS || CC_PLATFORM == CC_PLATFORM_ANDROID || CC_PLATFORM == CC_PLATFORM_MAC_OSX) -bool GLES3Context::initialize(const GFXContextInfo &info) { +bool GLES3Context::initialize(const ContextInfo &info) { _vsyncMode = info.vsyncMode; _windowHandle = info.windowHandle; @@ -119,8 +119,8 @@ bool GLES3Context::initialize(const GFXContextInfo &info) { return false; } - _colorFmt = GFXFormat::RGBA8; - _depthStencilFmt = GFXFormat::D24S8; + _colorFmt = Format::RGBA8; + _depthStencilFmt = Format::D24S8; const EGLint attribs[] = { EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_PBUFFER_BIT, @@ -154,17 +154,17 @@ bool GLES3Context::initialize(const GFXContextInfo &info) { CC_LOG_INFO("Setup EGLConfig: depth [%d] stencil [%d]", depth, stencil); if (depth == 16 && stencil == 0) { - _depthStencilFmt = GFXFormat::D16; + _depthStencilFmt = Format::D16; } else if (depth == 16 && stencil == 8) { - _depthStencilFmt = GFXFormat::D16S8; + _depthStencilFmt = Format::D16S8; } else if (depth == 24 && stencil == 0) { - _depthStencilFmt = GFXFormat::D24; + _depthStencilFmt = Format::D24; } else if (depth == 24 && stencil == 8) { - _depthStencilFmt = GFXFormat::D24S8; + _depthStencilFmt = Format::D24S8; } else if (depth == 32 && stencil == 0) { - _depthStencilFmt = GFXFormat::D32F; + _depthStencilFmt = Format::D32F; } else if (depth == 32 && stencil == 8) { - _depthStencilFmt = GFXFormat::D32F_S8; + _depthStencilFmt = Format::D32F_S8; } else { CC_LOG_ERROR("Unknown depth stencil format."); return false; @@ -363,7 +363,7 @@ void GLES3Context::destroy() { _isPrimaryContex = false; _windowHandle = 0; _nativeDisplay = 0; - _vsyncMode = GFXVsyncMode::OFF; + _vsyncMode = VsyncMode::OFF; _isInitialized = false; } @@ -384,11 +384,11 @@ bool GLES3Context::MakeCurrent() { // Turn on or off the vertical sync depending on the input bool value. int interval = 1; switch (_vsyncMode) { - case GFXVsyncMode::OFF: interval = 0; break; - case GFXVsyncMode::ON: interval = 1; break; - case GFXVsyncMode::RELAXED: interval = -1; break; - case GFXVsyncMode::MAILBOX: interval = 0; break; - case GFXVsyncMode::HALF: interval = 2; break; + case VsyncMode::OFF: interval = 0; break; + case VsyncMode::ON: interval = 1; break; + case VsyncMode::RELAXED: interval = -1; break; + case VsyncMode::MAILBOX: interval = 0; break; + case VsyncMode::HALF: interval = 2; break; default: break; } diff --git a/native/cocos/renderer/gfx-gles3/GLES3Context.h b/native/cocos/renderer/gfx-gles3/GLES3Context.h index 622038e376..1a53457f8a 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Context.h +++ b/native/cocos/renderer/gfx-gles3/GLES3Context.h @@ -31,13 +31,13 @@ namespace cc { namespace gfx { -class CC_GLES3_API GLES3Context : public GFXContext { +class CC_GLES3_API GLES3Context : public Context { public: - GLES3Context(GFXDevice *device); + GLES3Context(Device *device); ~GLES3Context(); public: - virtual bool initialize(const GFXContextInfo &info) override; + virtual bool initialize(const ContextInfo &info) override; virtual void destroy() override; virtual void present() override; diff --git a/native/cocos/renderer/gfx-gles3/GLES3Context.mm b/native/cocos/renderer/gfx-gles3/GLES3Context.mm index c7498bbed6..ffabde6f22 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Context.mm +++ b/native/cocos/renderer/gfx-gles3/GLES3Context.mm @@ -9,7 +9,7 @@ namespace cc { namespace gfx { -bool GLES3Context::initialize(const GFXContextInfo &info) +bool GLES3Context::initialize(const ContextInfo &info) { _vsyncMode = info.vsyncMode; @@ -55,8 +55,8 @@ bool GLES3Context::initialize(const GFXContextInfo &info) return false; } } - _colorFmt = GFXFormat::RGBA8; - _depthStencilFmt = GFXFormat::D24S8; + _colorFmt = Format::RGBA8; + _depthStencilFmt = Format::D24S8; if (!MakeCurrent()) return false; @@ -176,7 +176,7 @@ void GLES3Context::destroy() _isPrimaryContex = false; _windowHandle = 0; - _vsyncMode = GFXVsyncMode::OFF; + _vsyncMode = VsyncMode::OFF; _isInitialized = false; } diff --git a/native/cocos/renderer/gfx-gles3/GLES3Device.cc b/native/cocos/renderer/gfx-gles3/GLES3Device.cc index 2b7c3927c3..032f7020fb 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Device.cc +++ b/native/cocos/renderer/gfx-gles3/GLES3Device.cc @@ -27,8 +27,8 @@ GLES3Device::GLES3Device() { GLES3Device::~GLES3Device() { } -bool GLES3Device::initialize(const GFXDeviceInfo &info) { - _gfxAPI = GFXAPI::GLES3; +bool GLES3Device::initialize(const DeviceInfo &info) { + _API = API::GLES3; _deviceName = "GLES3"; _width = info.width; _height = info.height; @@ -38,7 +38,7 @@ bool GLES3Device::initialize(const GFXDeviceInfo &info) { stateCache = CC_NEW(GLES3StateCache); - GFXContextInfo ctx_info; + ContextInfo ctx_info; ctx_info.windowHandle = _windowHandle; ctx_info.sharedCtx = info.sharedCtx; @@ -51,54 +51,54 @@ bool GLES3Device::initialize(const GFXDeviceInfo &info) { String extStr = (const char *)glGetString(GL_EXTENSIONS); _extensions = StringUtil::Split(extStr, " "); - _features[(int)GFXFeature::TEXTURE_FLOAT] = true; - _features[(int)GFXFeature::TEXTURE_HALF_FLOAT] = true; - _features[(int)GFXFeature::FORMAT_R11G11B10F] = true; - _features[(int)GFXFeature::FORMAT_D24S8] = true; - _features[(int)GFXFeature::MSAA] = true; - _features[(int)GFXFeature::INSTANCED_ARRAYS] = true; + _features[(int)Feature::TEXTURE_FLOAT] = true; + _features[(int)Feature::TEXTURE_HALF_FLOAT] = true; + _features[(int)Feature::FORMAT_R11G11B10F] = true; + _features[(int)Feature::FORMAT_D24S8] = true; + _features[(int)Feature::MSAA] = true; + _features[(int)Feature::INSTANCED_ARRAYS] = true; if (checkExtension("color_buffer_float")) - _features[(int)GFXFeature::COLOR_FLOAT] = true; + _features[(int)Feature::COLOR_FLOAT] = true; if (checkExtension("color_buffer_half_float")) - _features[(int)GFXFeature::COLOR_HALF_FLOAT] = true; + _features[(int)Feature::COLOR_HALF_FLOAT] = true; if (checkExtension("texture_float_linear")) - _features[(int)GFXFeature::TEXTURE_FLOAT_LINEAR] = true; + _features[(int)Feature::TEXTURE_FLOAT_LINEAR] = true; if (checkExtension("texture_half_float_linear")) - _features[(int)GFXFeature::TEXTURE_HALF_FLOAT_LINEAR] = true; + _features[(int)Feature::TEXTURE_HALF_FLOAT_LINEAR] = true; String compressed_fmts; if (checkExtension("compressed_ETC1")) { - _features[(int)GFXFeature::FORMAT_ETC1] = true; + _features[(int)Feature::FORMAT_ETC1] = true; compressed_fmts += "etc1 "; } - _features[(int)GFXFeature::FORMAT_ETC2] = true; + _features[(int)Feature::FORMAT_ETC2] = true; compressed_fmts += "etc2 "; if (checkExtension("texture_compression_pvrtc")) { - _features[(int)GFXFeature::FORMAT_PVRTC] = true; + _features[(int)Feature::FORMAT_PVRTC] = true; compressed_fmts += "pvrtc "; } if (checkExtension("texture_compression_astc")) { - _features[(int)GFXFeature::FORMAT_ASTC] = true; + _features[(int)Feature::FORMAT_ASTC] = true; compressed_fmts += "astc "; } - _features[static_cast(GFXFeature::DEPTH_BOUNDS)] = true; - _features[static_cast(GFXFeature::LINE_WIDTH)] = true; - _features[static_cast(GFXFeature::STENCIL_COMPARE_MASK)] = true; - _features[static_cast(GFXFeature::STENCIL_WRITE_MASK)] = true; - _features[static_cast(GFXFeature::FORMAT_RGB8)] = true; - _features[static_cast(GFXFeature::FORMAT_D16)] = true; - _features[static_cast(GFXFeature::FORMAT_D24)] = true; - _features[static_cast(GFXFeature::FORMAT_D32F)] = true; - _features[static_cast(GFXFeature::FORMAT_D24S8)] = true; - _features[static_cast(GFXFeature::FORMAT_D32FS8)] = true; + _features[static_cast(Feature::DEPTH_BOUNDS)] = true; + _features[static_cast(Feature::LINE_WIDTH)] = true; + _features[static_cast(Feature::STENCIL_COMPARE_MASK)] = true; + _features[static_cast(Feature::STENCIL_WRITE_MASK)] = true; + _features[static_cast(Feature::FORMAT_RGB8)] = true; + _features[static_cast(Feature::FORMAT_D16)] = true; + _features[static_cast(Feature::FORMAT_D24)] = true; + _features[static_cast(Feature::FORMAT_D32F)] = true; + _features[static_cast(Feature::FORMAT_D24S8)] = true; + _features[static_cast(Feature::FORMAT_D32FS8)] = true; _renderer = (const char *)glGetString(GL_RENDERER); _vendor = (const char *)glGetString(GL_VENDOR); @@ -113,11 +113,11 @@ bool GLES3Device::initialize(const GFXDeviceInfo &info) { CC_LOG_INFO("USE_VAO: %s", _useVAO ? "true" : "false"); CC_LOG_INFO("COMPRESSED_FORMATS: %s", compressed_fmts.c_str()); - GFXQueueInfo queue_info; - queue_info.type = GFXQueueType::GRAPHICS; + QueueInfo queue_info; + queue_info.type = QueueType::GRAPHICS; _queue = createQueue(queue_info); - GFXCommandAllocatorInfo cmd_alloc_info; + CommandAllocatorInfo cmd_alloc_info; _cmdAllocator = createCommandAllocator(cmd_alloc_info); glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, (GLint *)&_maxVertexAttributes); @@ -162,8 +162,8 @@ void GLES3Device::present() { queue->_numTriangles = 0; } -GFXFence *GLES3Device::createFence(const GFXFenceInfo &info) { - GFXFence *fence = CC_NEW(GLES3Fence(this)); +Fence *GLES3Device::createFence(const FenceInfo &info) { + Fence *fence = CC_NEW(GLES3Fence(this)); if (fence->initialize(info)) return fence; @@ -171,8 +171,8 @@ GFXFence *GLES3Device::createFence(const GFXFenceInfo &info) { return nullptr; } -GFXQueue *GLES3Device::createQueue(const GFXQueueInfo &info) { - GFXQueue *queue = CC_NEW(GLES3Queue(this)); +Queue *GLES3Device::createQueue(const QueueInfo &info) { + Queue *queue = CC_NEW(GLES3Queue(this)); if (queue->initialize(info)) return queue; @@ -180,8 +180,8 @@ GFXQueue *GLES3Device::createQueue(const GFXQueueInfo &info) { return nullptr; } -GFXCommandAllocator *GLES3Device::createCommandAllocator(const GFXCommandAllocatorInfo &info) { - GFXCommandAllocator *cmdAllocator = CC_NEW(GLES3CommandAllocator(this)); +CommandAllocator *GLES3Device::createCommandAllocator(const CommandAllocatorInfo &info) { + CommandAllocator *cmdAllocator = CC_NEW(GLES3CommandAllocator(this)); if (cmdAllocator->initialize(info)) return cmdAllocator; @@ -189,8 +189,8 @@ GFXCommandAllocator *GLES3Device::createCommandAllocator(const GFXCommandAllocat return nullptr; } -GFXCommandBuffer *GLES3Device::createCommandBuffer(const GFXCommandBufferInfo &info) { - GFXCommandBuffer *cmd_buff = CC_NEW(GLES3CommandBuffer(this)); +CommandBuffer *GLES3Device::createCommandBuffer(const CommandBufferInfo &info) { + CommandBuffer *cmd_buff = CC_NEW(GLES3CommandBuffer(this)); if (cmd_buff->initialize(info)) return cmd_buff; @@ -198,8 +198,8 @@ GFXCommandBuffer *GLES3Device::createCommandBuffer(const GFXCommandBufferInfo &i return nullptr; } -GFXBuffer *GLES3Device::createBuffer(const GFXBufferInfo &info) { - GFXBuffer *buffer = CC_NEW(GLES3Buffer(this)); +Buffer *GLES3Device::createBuffer(const BufferInfo &info) { + Buffer *buffer = CC_NEW(GLES3Buffer(this)); if (buffer->initialize(info)) return buffer; @@ -207,8 +207,8 @@ GFXBuffer *GLES3Device::createBuffer(const GFXBufferInfo &info) { return nullptr; } -GFXTexture *GLES3Device::createTexture(const GFXTextureInfo &info) { - GFXTexture *texture = CC_NEW(GLES3Texture(this)); +Texture *GLES3Device::createTexture(const TextureInfo &info) { + Texture *texture = CC_NEW(GLES3Texture(this)); if (texture->initialize(info)) return texture; @@ -216,8 +216,8 @@ GFXTexture *GLES3Device::createTexture(const GFXTextureInfo &info) { return nullptr; } -GFXTexture *GLES3Device::createTexture(const GFXTextureViewInfo &info) { - GFXTexture *texture = CC_NEW(GLES3Texture(this)); +Texture *GLES3Device::createTexture(const TextureViewInfo &info) { + Texture *texture = CC_NEW(GLES3Texture(this)); if (texture->initialize(info)) return texture; @@ -225,8 +225,8 @@ GFXTexture *GLES3Device::createTexture(const GFXTextureViewInfo &info) { return nullptr; } -GFXSampler *GLES3Device::createSampler(const GFXSamplerInfo &info) { - GFXSampler *sampler = CC_NEW(GLES3Sampler(this)); +Sampler *GLES3Device::createSampler(const SamplerInfo &info) { + Sampler *sampler = CC_NEW(GLES3Sampler(this)); if (sampler->initialize(info)) return sampler; @@ -234,8 +234,8 @@ GFXSampler *GLES3Device::createSampler(const GFXSamplerInfo &info) { return nullptr; } -GFXShader *GLES3Device::createShader(const GFXShaderInfo &info) { - GFXShader *shader = CC_NEW(GLES3Shader(this)); +Shader *GLES3Device::createShader(const ShaderInfo &info) { + Shader *shader = CC_NEW(GLES3Shader(this)); if (shader->initialize(info)) return shader; @@ -243,8 +243,8 @@ GFXShader *GLES3Device::createShader(const GFXShaderInfo &info) { return nullptr; } -GFXInputAssembler *GLES3Device::createInputAssembler(const GFXInputAssemblerInfo &info) { - GFXInputAssembler *inputAssembler = CC_NEW(GLES3InputAssembler(this)); +InputAssembler *GLES3Device::createInputAssembler(const InputAssemblerInfo &info) { + InputAssembler *inputAssembler = CC_NEW(GLES3InputAssembler(this)); if (inputAssembler->initialize(info)) return inputAssembler; @@ -252,8 +252,8 @@ GFXInputAssembler *GLES3Device::createInputAssembler(const GFXInputAssemblerInfo return nullptr; } -GFXRenderPass *GLES3Device::createRenderPass(const GFXRenderPassInfo &info) { - GFXRenderPass *renderPass = CC_NEW(GLES3RenderPass(this)); +RenderPass *GLES3Device::createRenderPass(const RenderPassInfo &info) { + RenderPass *renderPass = CC_NEW(GLES3RenderPass(this)); if (renderPass->initialize(info)) return renderPass; @@ -261,8 +261,8 @@ GFXRenderPass *GLES3Device::createRenderPass(const GFXRenderPassInfo &info) { return nullptr; } -GFXFramebuffer *GLES3Device::createFramebuffer(const GFXFramebufferInfo &info) { - GFXFramebuffer *framebuffer = CC_NEW(GLES3Framebuffer(this)); +Framebuffer *GLES3Device::createFramebuffer(const FramebufferInfo &info) { + Framebuffer *framebuffer = CC_NEW(GLES3Framebuffer(this)); if (framebuffer->initialize(info)) return framebuffer; @@ -270,8 +270,8 @@ GFXFramebuffer *GLES3Device::createFramebuffer(const GFXFramebufferInfo &info) { return nullptr; } -GFXBindingLayout *GLES3Device::createBindingLayout(const GFXBindingLayoutInfo &info) { - GFXBindingLayout *bindingLayout = CC_NEW(GLES3BindingLayout(this)); +BindingLayout *GLES3Device::createBindingLayout(const BindingLayoutInfo &info) { + BindingLayout *bindingLayout = CC_NEW(GLES3BindingLayout(this)); if (bindingLayout->initialize(info)) return bindingLayout; @@ -279,8 +279,8 @@ GFXBindingLayout *GLES3Device::createBindingLayout(const GFXBindingLayoutInfo &i return nullptr; } -GFXPipelineState *GLES3Device::createPipelineState(const GFXPipelineStateInfo &info) { - GFXPipelineState *pipelineState = CC_NEW(GLES3PipelineState(this)); +PipelineState *GLES3Device::createPipelineState(const PipelineStateInfo &info) { + PipelineState *pipelineState = CC_NEW(GLES3PipelineState(this)); if (pipelineState->initialize(info)) return pipelineState; @@ -288,8 +288,8 @@ GFXPipelineState *GLES3Device::createPipelineState(const GFXPipelineStateInfo &i return nullptr; } -GFXPipelineLayout *GLES3Device::createPipelineLayout(const GFXPipelineLayoutInfo &info) { - GFXPipelineLayout *layout = CC_NEW(GLES3PipelineLayout(this)); +PipelineLayout *GLES3Device::createPipelineLayout(const PipelineLayoutInfo &info) { + PipelineLayout *layout = CC_NEW(GLES3PipelineLayout(this)); if (layout->initialize(info)) return layout; @@ -297,7 +297,7 @@ GFXPipelineLayout *GLES3Device::createPipelineLayout(const GFXPipelineLayoutInfo return nullptr; } -void GLES3Device::copyBuffersToTexture(const GFXDataArray &buffers, GFXTexture *dst, const GFXBufferTextureCopyList ®ions) { +void GLES3Device::copyBuffersToTexture(const DataArray &buffers, Texture *dst, const BufferTextureCopyList ®ions) { GLES3CmdFuncCopyBuffersToTexture(this, buffers.datas.data(), ((GLES3Texture *)dst)->gpuTexture(), regions); } diff --git a/native/cocos/renderer/gfx-gles3/GLES3Device.h b/native/cocos/renderer/gfx-gles3/GLES3Device.h index 60ce73385a..a6b61f64c6 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Device.h +++ b/native/cocos/renderer/gfx-gles3/GLES3Device.h @@ -6,7 +6,7 @@ namespace gfx { class GLES3StateCache; -class CC_GLES3_API GLES3Device : public GFXDevice { +class CC_GLES3_API GLES3Device : public Device { public: GLES3Device(); ~GLES3Device(); @@ -14,27 +14,27 @@ public: GLES3StateCache *stateCache = nullptr; public: - virtual bool initialize(const GFXDeviceInfo &info) override; + virtual bool initialize(const DeviceInfo &info) override; virtual void destroy() override; virtual void resize(uint width, uint height) override; virtual void acquire() override {} virtual void present() override; - virtual GFXFence *createFence(const GFXFenceInfo &info) override; - virtual GFXQueue *createQueue(const GFXQueueInfo &info) override; - virtual GFXCommandAllocator *createCommandAllocator(const GFXCommandAllocatorInfo &info) override; - virtual GFXCommandBuffer *createCommandBuffer(const GFXCommandBufferInfo &info) override; - virtual GFXBuffer *createBuffer(const GFXBufferInfo &info) override; - virtual GFXTexture *createTexture(const GFXTextureInfo &info) override; - virtual GFXTexture *createTexture(const GFXTextureViewInfo &info) override; - virtual GFXSampler *createSampler(const GFXSamplerInfo &info) override; - virtual GFXShader *createShader(const GFXShaderInfo &info) override; - virtual GFXInputAssembler *createInputAssembler(const GFXInputAssemblerInfo &info) override; - virtual GFXRenderPass *createRenderPass(const GFXRenderPassInfo &info) override; - virtual GFXFramebuffer *createFramebuffer(const GFXFramebufferInfo &info) override; - virtual GFXBindingLayout *createBindingLayout(const GFXBindingLayoutInfo &info) override; - virtual GFXPipelineState *createPipelineState(const GFXPipelineStateInfo &info) override; - virtual GFXPipelineLayout *createPipelineLayout(const GFXPipelineLayoutInfo &info) override; - virtual void copyBuffersToTexture(const GFXDataArray &buffers, GFXTexture *dst, const GFXBufferTextureCopyList ®ions) override; + virtual Fence *createFence(const FenceInfo &info) override; + virtual Queue *createQueue(const QueueInfo &info) override; + virtual CommandAllocator *createCommandAllocator(const CommandAllocatorInfo &info) override; + virtual CommandBuffer *createCommandBuffer(const CommandBufferInfo &info) override; + virtual Buffer *createBuffer(const BufferInfo &info) override; + virtual Texture *createTexture(const TextureInfo &info) override; + virtual Texture *createTexture(const TextureViewInfo &info) override; + virtual Sampler *createSampler(const SamplerInfo &info) override; + virtual Shader *createShader(const ShaderInfo &info) override; + virtual InputAssembler *createInputAssembler(const InputAssemblerInfo &info) override; + virtual RenderPass *createRenderPass(const RenderPassInfo &info) override; + virtual Framebuffer *createFramebuffer(const FramebufferInfo &info) override; + virtual BindingLayout *createBindingLayout(const BindingLayoutInfo &info) override; + virtual PipelineState *createPipelineState(const PipelineStateInfo &info) override; + virtual PipelineLayout *createPipelineLayout(const PipelineLayoutInfo &info) override; + virtual void copyBuffersToTexture(const DataArray &buffers, Texture *dst, const BufferTextureCopyList ®ions) override; CC_INLINE bool useVAO() const { return _useVAO; } diff --git a/native/cocos/renderer/gfx-gles3/GLES3Fence.cc b/native/cocos/renderer/gfx-gles3/GLES3Fence.cc index 841484121f..5661855c96 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Fence.cc +++ b/native/cocos/renderer/gfx-gles3/GLES3Fence.cc @@ -6,14 +6,14 @@ namespace cc { namespace gfx { -GLES3Fence::GLES3Fence(GFXDevice *device) -: GFXFence(device) { +GLES3Fence::GLES3Fence(Device *device) +: Fence(device) { } GLES3Fence::~GLES3Fence() { } -bool GLES3Fence::initialize(const GFXFenceInfo &info) { +bool GLES3Fence::initialize(const FenceInfo &info) { _gpuFence = CC_NEW(GLES3GPUFence); if (!_gpuFence) { CC_LOG_ERROR("GLES2Fence: CC_NEW GLES3GPUFence failed."); @@ -22,7 +22,7 @@ bool GLES3Fence::initialize(const GFXFenceInfo &info) { // TODO - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -33,7 +33,7 @@ void GLES3Fence::destroy() { CC_DELETE(_gpuFence); _gpuFence = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void GLES3Fence::wait() { diff --git a/native/cocos/renderer/gfx-gles3/GLES3Fence.h b/native/cocos/renderer/gfx-gles3/GLES3Fence.h index 5835997eff..657203e2d6 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Fence.h +++ b/native/cocos/renderer/gfx-gles3/GLES3Fence.h @@ -6,13 +6,13 @@ namespace gfx { class GLES3GPUFence; -class CC_GLES3_API GLES3Fence : public GFXFence { +class CC_GLES3_API GLES3Fence : public Fence { public: - GLES3Fence(GFXDevice *device); + GLES3Fence(Device *device); ~GLES3Fence(); public: - virtual bool initialize(const GFXFenceInfo &info) override; + virtual bool initialize(const FenceInfo &info) override; virtual void destroy() override; virtual void wait() override; virtual void reset() override; diff --git a/native/cocos/renderer/gfx-gles3/GLES3Framebuffer.cc b/native/cocos/renderer/gfx-gles3/GLES3Framebuffer.cc index 95672f6508..c9f1f07a7b 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Framebuffer.cc +++ b/native/cocos/renderer/gfx-gles3/GLES3Framebuffer.cc @@ -8,14 +8,14 @@ namespace cc { namespace gfx { -GLES3Framebuffer::GLES3Framebuffer(GFXDevice *device) -: GFXFramebuffer(device) { +GLES3Framebuffer::GLES3Framebuffer(Device *device) +: Framebuffer(device) { } GLES3Framebuffer::~GLES3Framebuffer() { } -bool GLES3Framebuffer::initialize(const GFXFramebufferInfo &info) { +bool GLES3Framebuffer::initialize(const FramebufferInfo &info) { _renderPass = info.renderPass; _colorTextures = info.colorTextures; @@ -48,7 +48,7 @@ bool GLES3Framebuffer::initialize(const GFXFramebufferInfo &info) { } #endif - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -60,7 +60,7 @@ void GLES3Framebuffer::destroy() { CC_DELETE(_gpuFBO); _gpuFBO = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-gles3/GLES3Framebuffer.h b/native/cocos/renderer/gfx-gles3/GLES3Framebuffer.h index e01215fcf8..19acac4070 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Framebuffer.h +++ b/native/cocos/renderer/gfx-gles3/GLES3Framebuffer.h @@ -6,13 +6,13 @@ namespace gfx { class GLES3GPUFramebuffer; -class CC_GLES3_API GLES3Framebuffer : public GFXFramebuffer { +class CC_GLES3_API GLES3Framebuffer : public Framebuffer { public: - GLES3Framebuffer(GFXDevice *device); + GLES3Framebuffer(Device *device); ~GLES3Framebuffer(); public: - virtual bool initialize(const GFXFramebufferInfo &info) override; + virtual bool initialize(const FramebufferInfo &info) override; virtual void destroy() override; CC_INLINE GLES3GPUFramebuffer *gpuFBO() const { return _gpuFBO; } diff --git a/native/cocos/renderer/gfx-gles3/GLES3GPUObjects.h b/native/cocos/renderer/gfx-gles3/GLES3GPUObjects.h index 407822a1df..1bf9bef853 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3GPUObjects.h +++ b/native/cocos/renderer/gfx-gles3/GLES3GPUObjects.h @@ -8,31 +8,31 @@ namespace gfx { class GLES3GPUBuffer : public Object { public: - GFXBufferUsage usage = GFXBufferUsage::NONE; - GFXMemoryUsage memUsage = GFXMemoryUsage::NONE; + BufferUsage usage = BufferUsage::NONE; + MemoryUsage memUsage = MemoryUsage::NONE; uint size = 0; uint stride = 0; uint count = 0; GLenum glTarget = 0; GLuint glBuffer = 0; uint8_t *buffer = nullptr; - GFXDrawInfoList indirects; + DrawInfoList indirects; }; typedef vector GLES3GPUBufferList; class GLES3GPUTexture : public Object { public: - GFXTextureType type = GFXTextureType::TEX2D; - GFXFormat format = GFXFormat::UNKNOWN; - GFXTextureUsage usage = GFXTextureUsageBit::NONE; + TextureType type = TextureType::TEX2D; + Format format = Format::UNKNOWN; + TextureUsage usage = TextureUsageBit::NONE; uint width = 0; uint height = 0; uint depth = 1; uint size = 0; uint arrayLayer = 1; uint mipLevel = 1; - GFXSampleCount samples = GFXSampleCount::X1; - GFXTextureFlags flags = GFXTextureFlagBit::NONE; + SampleCount samples = SampleCount::X1; + TextureFlags flags = TextureFlagBit::NONE; bool isPowerOf2 = false; GLenum glTarget = 0; GLenum glInternelFmt = 0; @@ -50,12 +50,12 @@ typedef vector GLES3GPUTextureList; class GLES3GPUSampler : public Object { public: - GFXFilter minFilter = GFXFilter::NONE; - GFXFilter magFilter = GFXFilter::NONE; - GFXFilter mipFilter = GFXFilter::NONE; - GFXAddress addressU = GFXAddress::CLAMP; - GFXAddress addressV = GFXAddress::CLAMP; - GFXAddress addressW = GFXAddress::CLAMP; + Filter minFilter = Filter::NONE; + Filter magFilter = Filter::NONE; + Filter mipFilter = Filter::NONE; + Address addressU = Address::CLAMP; + Address addressV = Address::CLAMP; + Address addressW = Address::CLAMP; uint minLOD = 0; uint maxLOD = 1000; GLuint gl_sampler = 0; @@ -69,7 +69,7 @@ public: struct GLES3GPUInput { uint binding = 0; String name; - GFXType type = GFXType::UNKNOWN; + Type type = Type::UNKNOWN; uint stride = 0; uint count = 0; uint size = 0; @@ -81,7 +81,7 @@ typedef vector GLES3GPUInputList; struct GLES3GPUUniform { uint binding = GFX_INVALID_BINDING; String name; - GFXType type = GFXType::UNKNOWN; + Type type = Type::UNKNOWN; uint stride = 0; uint count = 0; uint size = 0; @@ -104,7 +104,7 @@ typedef vector GLES3GPUUniformBlockList; struct GLES3GPUUniformSampler { uint binding = 0; String name; - GFXType type = GFXType::UNKNOWN; + Type type = Type::UNKNOWN; vector units; GLenum glType = 0; GLint glLoc = -1; @@ -112,11 +112,11 @@ struct GLES3GPUUniformSampler { typedef vector GLES3GPUUniformSamplerList; struct GLES3GPUShaderStage { - GLES3GPUShaderStage(GFXShaderType t, String s, GFXShaderMacroList m, GLuint shader = 0) + GLES3GPUShaderStage(ShaderType t, String s, ShaderMacroList m, GLuint shader = 0) : type(t), source(s), macros(m), glShader(shader) {} - GFXShaderType type; + ShaderType type; String source; - GFXShaderMacroList macros; + ShaderMacroList macros; GLuint glShader = 0; }; typedef vector GLES3GPUShaderStageList; @@ -124,8 +124,8 @@ typedef vector GLES3GPUShaderStageList; class GLES3GPUShader : public Object { public: String name; - GFXUniformBlockList blocks; - GFXUniformSamplerList samplers; + UniformBlockList blocks; + UniformSamplerList samplers; GLuint glProgram = 0; GLES3GPUShaderStageList gpuStages; GLES3GPUInputList glInputs; @@ -149,7 +149,7 @@ typedef vector GLES3GPUAttributeList; class GLES3GPUInputAssembler : public Object { public: - GFXAttributeList attributes; + AttributeList attributes; GLES3GPUBufferList gpuVertexBuffers; GLES3GPUBuffer *gpuIndexBuffer = nullptr; GLES3GPUBuffer *gpuIndirectBuffer = nullptr; @@ -160,8 +160,8 @@ public: class GLES3GPURenderPass : public Object { public: - GFXColorAttachmentList colorAttachments; - GFXDepthStencilAttachment depthStencilAttachment; + ColorAttachmentList colorAttachments; + DepthStencilAttachment depthStencilAttachment; }; class GLES3GPUFramebuffer : public Object { @@ -183,17 +183,17 @@ class GLES3GPUPipelineState : public Object { public: GLenum glPrimitive = GL_TRIANGLES; GLES3GPUShader *gpuShader = nullptr; - GFXRasterizerState rs; - GFXDepthStencilState dss; - GFXBlendState bs; - GFXDynamicStateList dynamicStates; + RasterizerState rs; + DepthStencilState dss; + BlendState bs; + DynamicStateList dynamicStates; GLES3GPUPipelineLayout *gpuLayout = nullptr; GLES3GPURenderPass *gpuRenderPass = nullptr; }; struct GLES3GPUBinding { uint binding = GFX_INVALID_BINDING; - GFXBindingType type = GFXBindingType::UNKNOWN; + BindingType type = BindingType::UNKNOWN; String name; GLES3GPUBuffer *gpuBuffer = nullptr; GLES3GPUTexture *gpuTexture = nullptr; diff --git a/native/cocos/renderer/gfx-gles3/GLES3InputAssembler.cc b/native/cocos/renderer/gfx-gles3/GLES3InputAssembler.cc index 5dae441a9d..267b628107 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3InputAssembler.cc +++ b/native/cocos/renderer/gfx-gles3/GLES3InputAssembler.cc @@ -6,14 +6,14 @@ namespace cc { namespace gfx { -GLES3InputAssembler::GLES3InputAssembler(GFXDevice *device) -: GFXInputAssembler(device) { +GLES3InputAssembler::GLES3InputAssembler(Device *device) +: InputAssembler(device) { } GLES3InputAssembler::~GLES3InputAssembler() { } -bool GLES3InputAssembler::initialize(const GFXInputAssemblerInfo &info) { +bool GLES3InputAssembler::initialize(const InputAssemblerInfo &info) { _attributes = info.attributes; _vertexBuffers = info.vertexBuffers; @@ -41,7 +41,7 @@ bool GLES3InputAssembler::initialize(const GFXInputAssemblerInfo &info) { GLES3CmdFuncCreateInputAssembler((GLES3Device *)_device, _gpuInputAssembler); _attributesHash = computeAttributesHash(); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -52,7 +52,7 @@ void GLES3InputAssembler::destroy() { CC_DELETE(_gpuInputAssembler); _gpuInputAssembler = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void GLES3InputAssembler::ExtractCmdDraw(GLES3CmdDraw *cmd) { diff --git a/native/cocos/renderer/gfx-gles3/GLES3InputAssembler.h b/native/cocos/renderer/gfx-gles3/GLES3InputAssembler.h index 950c62df20..4b52b3648e 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3InputAssembler.h +++ b/native/cocos/renderer/gfx-gles3/GLES3InputAssembler.h @@ -7,13 +7,13 @@ namespace gfx { class GLES3GPUInputAssembler; class GLES3CmdDraw; -class CC_GLES3_API GLES3InputAssembler : public GFXInputAssembler { +class CC_GLES3_API GLES3InputAssembler : public InputAssembler { public: - GLES3InputAssembler(GFXDevice *device); + GLES3InputAssembler(Device *device); ~GLES3InputAssembler(); public: - virtual bool initialize(const GFXInputAssemblerInfo &info) override; + virtual bool initialize(const InputAssemblerInfo &info) override; virtual void destroy() override; void ExtractCmdDraw(GLES3CmdDraw *cmd); diff --git a/native/cocos/renderer/gfx-gles3/GLES3PipelineLayout.cc b/native/cocos/renderer/gfx-gles3/GLES3PipelineLayout.cc index 7b6c47482b..3e0c68c266 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3PipelineLayout.cc +++ b/native/cocos/renderer/gfx-gles3/GLES3PipelineLayout.cc @@ -5,20 +5,20 @@ namespace cc { namespace gfx { -GLES3PipelineLayout::GLES3PipelineLayout(GFXDevice *device) -: GFXPipelineLayout(device) { +GLES3PipelineLayout::GLES3PipelineLayout(Device *device) +: PipelineLayout(device) { } GLES3PipelineLayout::~GLES3PipelineLayout() { } -bool GLES3PipelineLayout::initialize(const GFXPipelineLayoutInfo &info) { +bool GLES3PipelineLayout::initialize(const PipelineLayoutInfo &info) { _layouts = info.layouts; _pushConstantsRanges = info.pushConstantsRanges; _gpuPipelineLayout = CC_NEW(GLES3GPUPipelineLayout); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -27,7 +27,7 @@ void GLES3PipelineLayout::destroy() { CC_DELETE(_gpuPipelineLayout); _gpuPipelineLayout = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-gles3/GLES3PipelineLayout.h b/native/cocos/renderer/gfx-gles3/GLES3PipelineLayout.h index ec1232f682..ad223a016f 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3PipelineLayout.h +++ b/native/cocos/renderer/gfx-gles3/GLES3PipelineLayout.h @@ -6,13 +6,13 @@ namespace gfx { class GLES3GPUPipelineLayout; -class CC_GLES3_API GLES3PipelineLayout : public GFXPipelineLayout { +class CC_GLES3_API GLES3PipelineLayout : public PipelineLayout { public: - GLES3PipelineLayout(GFXDevice *device); + GLES3PipelineLayout(Device *device); ~GLES3PipelineLayout(); public: - virtual bool initialize(const GFXPipelineLayoutInfo &info) override; + virtual bool initialize(const PipelineLayoutInfo &info) override; virtual void destroy() override; CC_INLINE GLES3GPUPipelineLayout *gpuPipelineLayout() const { return _gpuPipelineLayout; } diff --git a/native/cocos/renderer/gfx-gles3/GLES3PipelineState.cc b/native/cocos/renderer/gfx-gles3/GLES3PipelineState.cc index 391abb1be6..64dfe7f470 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3PipelineState.cc +++ b/native/cocos/renderer/gfx-gles3/GLES3PipelineState.cc @@ -25,14 +25,14 @@ const GLenum GLES3Primitives[] = { GL_NONE, }; -GLES3PipelineState::GLES3PipelineState(GFXDevice *device) -: GFXPipelineState(device) { +GLES3PipelineState::GLES3PipelineState(Device *device) +: PipelineState(device) { } GLES3PipelineState::~GLES3PipelineState() { } -bool GLES3PipelineState::initialize(const GFXPipelineStateInfo &info) { +bool GLES3PipelineState::initialize(const PipelineStateInfo &info) { _primitive = info.primitive; _shader = info.shader; @@ -54,7 +54,7 @@ bool GLES3PipelineState::initialize(const GFXPipelineStateInfo &info) { _gpuPipelineState->gpuLayout = ((GLES3PipelineLayout *)_layout)->gpuPipelineLayout(); _gpuPipelineState->gpuRenderPass = ((GLES3RenderPass *)_renderPass)->gpuRenderPass(); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -64,7 +64,7 @@ void GLES3PipelineState::destroy() { CC_DELETE(_gpuPipelineState); _gpuPipelineState = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-gles3/GLES3PipelineState.h b/native/cocos/renderer/gfx-gles3/GLES3PipelineState.h index cdce8cc1d9..45a7812b54 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3PipelineState.h +++ b/native/cocos/renderer/gfx-gles3/GLES3PipelineState.h @@ -6,13 +6,13 @@ namespace gfx { class GLES3GPUPipelineState; -class CC_GLES3_API GLES3PipelineState : public GFXPipelineState { +class CC_GLES3_API GLES3PipelineState : public PipelineState { public: - GLES3PipelineState(GFXDevice *device); + GLES3PipelineState(Device *device); ~GLES3PipelineState(); public: - virtual bool initialize(const GFXPipelineStateInfo &info) override; + virtual bool initialize(const PipelineStateInfo &info) override; virtual void destroy() override; CC_INLINE GLES3GPUPipelineState *gpuPipelineState() const { return _gpuPipelineState; } diff --git a/native/cocos/renderer/gfx-gles3/GLES3Queue.cc b/native/cocos/renderer/gfx-gles3/GLES3Queue.cc index 0440360536..077c5634fa 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Queue.cc +++ b/native/cocos/renderer/gfx-gles3/GLES3Queue.cc @@ -6,25 +6,25 @@ namespace cc { namespace gfx { -GLES3Queue::GLES3Queue(GFXDevice *device) -: GFXQueue(device) { +GLES3Queue::GLES3Queue(Device *device) +: Queue(device) { } GLES3Queue::~GLES3Queue() { } -bool GLES3Queue::initialize(const GFXQueueInfo &info) { +bool GLES3Queue::initialize(const QueueInfo &info) { _type = info.type; - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } void GLES3Queue::destroy() { - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } -void GLES3Queue::submit(const vector &cmdBuffs, GFXFence *fence) { +void GLES3Queue::submit(const vector &cmdBuffs, Fence *fence) { if (!_isAsync) { uint count = static_cast(cmdBuffs.size()); for (uint i = 0; i < count; ++i) { diff --git a/native/cocos/renderer/gfx-gles3/GLES3Queue.h b/native/cocos/renderer/gfx-gles3/GLES3Queue.h index 68112c27f8..b2c8cdd14d 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Queue.h +++ b/native/cocos/renderer/gfx-gles3/GLES3Queue.h @@ -4,17 +4,17 @@ namespace cc { namespace gfx { -class CC_GLES3_API GLES3Queue : public GFXQueue { +class CC_GLES3_API GLES3Queue : public Queue { public: - GLES3Queue(GFXDevice *device); + GLES3Queue(Device *device); ~GLES3Queue(); friend class GLES3Device; public: - virtual bool initialize(const GFXQueueInfo &info) override; + virtual bool initialize(const QueueInfo &info) override; virtual void destroy() override; - virtual void submit(const vector &cmdBuffs, GFXFence *fence) override; + virtual void submit(const vector &cmdBuffs, Fence *fence) override; private: uint _numDrawCalls = 0; diff --git a/native/cocos/renderer/gfx-gles3/GLES3RenderPass.cc b/native/cocos/renderer/gfx-gles3/GLES3RenderPass.cc index ba7b9f9494..814fe5bcdc 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3RenderPass.cc +++ b/native/cocos/renderer/gfx-gles3/GLES3RenderPass.cc @@ -5,14 +5,14 @@ namespace cc { namespace gfx { -GLES3RenderPass::GLES3RenderPass(GFXDevice *device) -: GFXRenderPass(device) { +GLES3RenderPass::GLES3RenderPass(Device *device) +: RenderPass(device) { } GLES3RenderPass::~GLES3RenderPass() { } -bool GLES3RenderPass::initialize(const GFXRenderPassInfo &info) { +bool GLES3RenderPass::initialize(const RenderPassInfo &info) { _colorAttachments = info.colorAttachments; _depthStencilAttachment = info.depthStencilAttachment; @@ -22,7 +22,7 @@ bool GLES3RenderPass::initialize(const GFXRenderPassInfo &info) { _gpuRenderPass->depthStencilAttachment = _depthStencilAttachment; _hash = computeHash(); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -33,7 +33,7 @@ void GLES3RenderPass::destroy() { _gpuRenderPass = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-gles3/GLES3RenderPass.h b/native/cocos/renderer/gfx-gles3/GLES3RenderPass.h index 84279c63a0..108b999392 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3RenderPass.h +++ b/native/cocos/renderer/gfx-gles3/GLES3RenderPass.h @@ -6,13 +6,13 @@ namespace gfx { class GLES3GPURenderPass; -class CC_GLES3_API GLES3RenderPass : public GFXRenderPass { +class CC_GLES3_API GLES3RenderPass : public RenderPass { public: - GLES3RenderPass(GFXDevice *device); + GLES3RenderPass(Device *device); ~GLES3RenderPass(); public: - virtual bool initialize(const GFXRenderPassInfo &info) override; + virtual bool initialize(const RenderPassInfo &info) override; virtual void destroy() override; CC_INLINE GLES3GPURenderPass *gpuRenderPass() const { return _gpuRenderPass; } diff --git a/native/cocos/renderer/gfx-gles3/GLES3Sampler.cc b/native/cocos/renderer/gfx-gles3/GLES3Sampler.cc index 5742874b9f..efc0b3a4d0 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Sampler.cc +++ b/native/cocos/renderer/gfx-gles3/GLES3Sampler.cc @@ -5,14 +5,14 @@ namespace cc { namespace gfx { -GLES3Sampler::GLES3Sampler(GFXDevice *device) -: GFXSampler(device) { +GLES3Sampler::GLES3Sampler(Device *device) +: Sampler(device) { } GLES3Sampler::~GLES3Sampler() { } -bool GLES3Sampler::initialize(const GFXSamplerInfo &info) { +bool GLES3Sampler::initialize(const SamplerInfo &info) { _name = info.name; _minFilter = info.minFilter; _magFilter = info.magFilter; @@ -37,7 +37,7 @@ bool GLES3Sampler::initialize(const GFXSamplerInfo &info) { _gpuSampler->minLOD = _minLOD; _gpuSampler->maxLOD = _maxLOD; - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; GLES3CmdFuncCreateSampler((GLES3Device *)_device, _gpuSampler); @@ -50,7 +50,7 @@ void GLES3Sampler::destroy() { CC_DELETE(_gpuSampler); _gpuSampler = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-gles3/GLES3Sampler.h b/native/cocos/renderer/gfx-gles3/GLES3Sampler.h index e774a72d3e..8c67631ec4 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Sampler.h +++ b/native/cocos/renderer/gfx-gles3/GLES3Sampler.h @@ -6,13 +6,13 @@ namespace gfx { class GLES3GPUSampler; -class CC_GLES3_API GLES3Sampler : public GFXSampler { +class CC_GLES3_API GLES3Sampler : public Sampler { public: - GLES3Sampler(GFXDevice *device); + GLES3Sampler(Device *device); ~GLES3Sampler(); public: - virtual bool initialize(const GFXSamplerInfo &info) override; + virtual bool initialize(const SamplerInfo &info) override; virtual void destroy() override; CC_INLINE GLES3GPUSampler *gpuSampler() const { return _gpuSampler; } diff --git a/native/cocos/renderer/gfx-gles3/GLES3Shader.cc b/native/cocos/renderer/gfx-gles3/GLES3Shader.cc index 2b6ab35a8b..43d4f4ab58 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Shader.cc +++ b/native/cocos/renderer/gfx-gles3/GLES3Shader.cc @@ -5,14 +5,14 @@ namespace cc { namespace gfx { -GLES3Shader::GLES3Shader(GFXDevice *device) -: GFXShader(device) { +GLES3Shader::GLES3Shader(Device *device) +: Shader(device) { } GLES3Shader::~GLES3Shader() { } -bool GLES3Shader::initialize(const GFXShaderInfo &info) { +bool GLES3Shader::initialize(const ShaderInfo &info) { _name = info.name; _stages = info.stages; _attributes = info.attributes; @@ -30,7 +30,7 @@ bool GLES3Shader::initialize(const GFXShaderInfo &info) { GLES3CmdFuncCreateShader((GLES3Device *)_device, _gpuShader); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -42,7 +42,7 @@ void GLES3Shader::destroy() { _gpuShader = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-gles3/GLES3Shader.h b/native/cocos/renderer/gfx-gles3/GLES3Shader.h index 5d0dffe2ec..1f60aed389 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Shader.h +++ b/native/cocos/renderer/gfx-gles3/GLES3Shader.h @@ -6,13 +6,13 @@ namespace gfx { class GLES3GPUShader; -class CC_GLES3_API GLES3Shader : public GFXShader { +class CC_GLES3_API GLES3Shader : public Shader { public: - GLES3Shader(GFXDevice *device); + GLES3Shader(Device *device); ~GLES3Shader(); public: - virtual bool initialize(const GFXShaderInfo &info) override; + virtual bool initialize(const ShaderInfo &info) override; virtual void destroy() override; CC_INLINE GLES3GPUShader *gpuShader() const { return _gpuShader; } diff --git a/native/cocos/renderer/gfx-gles3/GLES3StateCache.h b/native/cocos/renderer/gfx-gles3/GLES3StateCache.h index 0d81a61074..9762e7281e 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3StateCache.h +++ b/native/cocos/renderer/gfx-gles3/GLES3StateCache.h @@ -21,11 +21,11 @@ public: bool glCurrentAttribLocs[GFX_MAX_VERTEX_ATTRIBUTES] = {false}; GLuint glFramebuffer = 0; GLuint glReadFBO = 0; - GFXViewport viewport; - GFXRect scissor; - GFXRasterizerState rs; - GFXDepthStencilState dss; - GFXBlendState bs; + Viewport viewport; + Rect scissor; + RasterizerState rs; + DepthStencilState dss; + BlendState bs; bool isCullFaceEnabled = true; bool isStencilTestEnabled = false; diff --git a/native/cocos/renderer/gfx-gles3/GLES3Texture.cc b/native/cocos/renderer/gfx-gles3/GLES3Texture.cc index ec525517fa..8232d0b571 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Texture.cc +++ b/native/cocos/renderer/gfx-gles3/GLES3Texture.cc @@ -6,14 +6,14 @@ namespace cc { namespace gfx { -GLES3Texture::GLES3Texture(GFXDevice *device) -: GFXTexture(device) { +GLES3Texture::GLES3Texture(Device *device) +: Texture(device) { } GLES3Texture::~GLES3Texture() { } -bool GLES3Texture::initialize(const GFXTextureInfo &info) { +bool GLES3Texture::initialize(const TextureInfo &info) { _type = info.type; _usage = info.usage; @@ -25,45 +25,45 @@ bool GLES3Texture::initialize(const GFXTextureInfo &info) { _mipLevel = info.mipLevel; _samples = info.samples; _flags = info.flags; - _size = GFXFormatSize(_format, _width, _height, _depth); + _size = FormatSize(_format, _width, _height, _depth); #if COCOS2D_DEBUG > 0 switch (_format) { // device feature validation - case GFXFormat::D16: - if (_device->hasFeature(GFXFeature::FORMAT_D16)) break; + case Format::D16: + if (_device->hasFeature(Feature::FORMAT_D16)) break; CC_LOG_ERROR("D16 texture format is not supported on this backend"); return false; - case GFXFormat::D16S8: - if (_device->hasFeature(GFXFeature::FORMAT_D16S8)) break; + case Format::D16S8: + if (_device->hasFeature(Feature::FORMAT_D16S8)) break; CC_LOG_WARNING("D16S8 texture format is not supported on this backend"); return false; - case GFXFormat::D24: - if (_device->hasFeature(GFXFeature::FORMAT_D24)) break; + case Format::D24: + if (_device->hasFeature(Feature::FORMAT_D24)) break; CC_LOG_WARNING("D24 texture format is not supported on this backend"); return false; - case GFXFormat::D24S8: - if (_device->hasFeature(GFXFeature::FORMAT_D24S8)) break; + case Format::D24S8: + if (_device->hasFeature(Feature::FORMAT_D24S8)) break; CC_LOG_WARNING("D24S8 texture format is not supported on this backend"); return false; - case GFXFormat::D32F: - if (_device->hasFeature(GFXFeature::FORMAT_D32F)) break; + case Format::D32F: + if (_device->hasFeature(Feature::FORMAT_D32F)) break; CC_LOG_WARNING("D32F texture format is not supported on this backend"); return false; - case GFXFormat::D32F_S8: - if (_device->hasFeature(GFXFeature::FORMAT_D32FS8)) break; + case Format::D32F_S8: + if (_device->hasFeature(Feature::FORMAT_D32FS8)) break; CC_LOG_WARNING("D32FS8 texture format is not supported on this backend"); return false; - case GFXFormat::RGB8: - if (_device->hasFeature(GFXFeature::FORMAT_RGB8)) break; + case Format::RGB8: + if (_device->hasFeature(Feature::FORMAT_RGB8)) break; CC_LOG_WARNING("RGB8 texture format is not supported on this backend"); return false; } #endif - if (_flags & GFXTextureFlags::BAKUP_BUFFER) { + if (_flags & TextureFlags::BAKUP_BUFFER) { _buffer = (uint8_t *)CC_MALLOC(_size); if (!_buffer) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CC_LOG_ERROR("GLES3Texture: CC_MALLOC backup buffer failed."); return false; } @@ -72,7 +72,7 @@ bool GLES3Texture::initialize(const GFXTextureInfo &info) { _gpuTexture = CC_NEW(GLES3GPUTexture); if (!_gpuTexture) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CC_LOG_ERROR("GLES3Texture: CC_NEW GLES3GPUTexture failed."); return false; } @@ -91,14 +91,14 @@ bool GLES3Texture::initialize(const GFXTextureInfo &info) { GLES3CmdFuncCreateTexture((GLES3Device *)_device, _gpuTexture); _device->getMemoryStatus().textureSize += _size; - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } -bool GLES3Texture::initialize(const GFXTextureViewInfo &info) { +bool GLES3Texture::initialize(const TextureViewInfo &info) { CC_LOG_ERROR("GLES3 doesn't support texture view."); - _status = GFXStatus::FAILED; + _status = Status::FAILED; return false; } @@ -116,18 +116,18 @@ void GLES3Texture::destroy() { _buffer = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void GLES3Texture::resize(uint width, uint height) { - uint size = GFXFormatSize(_format, width, height, _depth); + uint size = FormatSize(_format, width, height, _depth); if (_size != size) { const uint oldSize = _size; _width = width; _height = height; _size = size; - GFXMemoryStatus &status = _device->getMemoryStatus(); + MemoryStatus &status = _device->getMemoryStatus(); _gpuTexture->width = _width; _gpuTexture->height = _height; _gpuTexture->size = _size; @@ -139,7 +139,7 @@ void GLES3Texture::resize(uint width, uint height) { const uint8_t *oldBuffer = _buffer; uint8_t *buffer = (uint8_t *)CC_MALLOC(_size); if (!buffer) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CC_LOG_ERROR("GLES3Texture: CC_MALLOC backup buffer failed when resize the texture."); return; } @@ -149,7 +149,7 @@ void GLES3Texture::resize(uint width, uint height) { status.bufferSize -= oldSize; status.bufferSize += _size; } - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; } } diff --git a/native/cocos/renderer/gfx-gles3/GLES3Texture.h b/native/cocos/renderer/gfx-gles3/GLES3Texture.h index 91c4282295..bbc12070bf 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Texture.h +++ b/native/cocos/renderer/gfx-gles3/GLES3Texture.h @@ -6,14 +6,14 @@ namespace gfx { class GLES3GPUTexture; -class CC_GLES3_API GLES3Texture : public GFXTexture { +class CC_GLES3_API GLES3Texture : public Texture { public: - GLES3Texture(GFXDevice *device); + GLES3Texture(Device *device); ~GLES3Texture(); public: - virtual bool initialize(const GFXTextureInfo &info) override; - virtual bool initialize(const GFXTextureViewInfo &info) override; + virtual bool initialize(const TextureInfo &info) override; + virtual bool initialize(const TextureViewInfo &info) override; virtual void destroy() override; virtual void resize(uint width, uint height) override; diff --git a/native/cocos/renderer/gfx-metal/MTLBindingLayout.cpp b/native/cocos/renderer/gfx-metal/MTLBindingLayout.cpp index 7780744ff2..2131575a26 100644 --- a/native/cocos/renderer/gfx-metal/MTLBindingLayout.cpp +++ b/native/cocos/renderer/gfx-metal/MTLBindingLayout.cpp @@ -4,15 +4,15 @@ namespace cc { namespace gfx { -CCMTLBindingLayout::CCMTLBindingLayout(GFXDevice *device) : GFXBindingLayout(device) {} +CCMTLBindingLayout::CCMTLBindingLayout(Device *device) : BindingLayout(device) {} CCMTLBindingLayout::~CCMTLBindingLayout() { destroy(); } -bool CCMTLBindingLayout::initialize(const GFXBindingLayoutInfo &info) { +bool CCMTLBindingLayout::initialize(const BindingLayoutInfo &info) { if (info.bindings.size()) { _bindingUnits.resize(info.bindings.size()); for (size_t i = 0; i < _bindingUnits.size(); ++i) { - GFXBindingUnit &bindingUnit = _bindingUnits[i]; - const GFXBinding &binding = info.bindings[i]; + BindingUnit &bindingUnit = _bindingUnits[i]; + const Binding &binding = info.bindings[i]; bindingUnit.shaderStages = binding.shaderStages; bindingUnit.binding = binding.binding; bindingUnit.type = binding.type; @@ -20,12 +20,12 @@ bool CCMTLBindingLayout::initialize(const GFXBindingLayoutInfo &info) { } } - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } void CCMTLBindingLayout::destroy() { - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void CCMTLBindingLayout::update() { diff --git a/native/cocos/renderer/gfx-metal/MTLBindingLayout.h b/native/cocos/renderer/gfx-metal/MTLBindingLayout.h index 9d3529410b..27d2fa671c 100644 --- a/native/cocos/renderer/gfx-metal/MTLBindingLayout.h +++ b/native/cocos/renderer/gfx-metal/MTLBindingLayout.h @@ -3,12 +3,12 @@ namespace cc { namespace gfx { -class CCMTLBindingLayout : public GFXBindingLayout { +class CCMTLBindingLayout : public BindingLayout { public: - CCMTLBindingLayout(GFXDevice *device); + CCMTLBindingLayout(Device *device); virtual ~CCMTLBindingLayout(); - virtual bool initialize(const GFXBindingLayoutInfo &info) override; + virtual bool initialize(const BindingLayoutInfo &info) override; virtual void destroy() override; virtual void update() override; }; diff --git a/native/cocos/renderer/gfx-metal/MTLBuffer.h b/native/cocos/renderer/gfx-metal/MTLBuffer.h index 3c483ffdb9..d2f2046b88 100644 --- a/native/cocos/renderer/gfx-metal/MTLBuffer.h +++ b/native/cocos/renderer/gfx-metal/MTLBuffer.h @@ -7,12 +7,12 @@ namespace cc { namespace gfx { -class CCMTLBuffer : public GFXBuffer { +class CCMTLBuffer : public Buffer { public: - CCMTLBuffer(GFXDevice *device); + CCMTLBuffer(Device *device); ~CCMTLBuffer(); - virtual bool initialize(const GFXBufferInfo &info) override; + virtual bool initialize(const BufferInfo &info) override; virtual void destroy() override; virtual void resize(uint size) override; virtual void update(void *buffer, uint offset, uint size) override; @@ -21,11 +21,11 @@ public: CC_INLINE uint8_t *getTransferBuffer() const { return _transferBuffer; } CC_INLINE MTLIndexType getIndexType() const { return _indexType; } CC_INLINE bool isDrawIndirectByIndex() const { return _isDrawIndirectByIndex; } - void encodeBuffer(id encoder, uint offset, uint binding, GFXShaderType stages); + void encodeBuffer(id encoder, uint offset, uint binding, ShaderType stages); private: void resizeBuffer(uint8_t **, uint, uint); - bool createMTLBuffer(uint size, GFXMemoryUsage usage); + bool createMTLBuffer(uint size, MemoryUsage usage); id _mtlBuffer = nullptr; uint8_t *_transferBuffer = nullptr; diff --git a/native/cocos/renderer/gfx-metal/MTLBuffer.mm b/native/cocos/renderer/gfx-metal/MTLBuffer.mm index a7eef0ffe5..8c5d5f505a 100644 --- a/native/cocos/renderer/gfx-metal/MTLBuffer.mm +++ b/native/cocos/renderer/gfx-metal/MTLBuffer.mm @@ -10,13 +10,13 @@ namespace cc { namespace gfx { -CCMTLBuffer::CCMTLBuffer(GFXDevice *device) : GFXBuffer(device) {} +CCMTLBuffer::CCMTLBuffer(Device *device) : Buffer(device) {} CCMTLBuffer::~CCMTLBuffer() { destroy(); } -bool CCMTLBuffer::initialize(const GFXBufferInfo &info) { +bool CCMTLBuffer::initialize(const BufferInfo &info) { _usage = info.usage; _memUsage = info.memUsage; _size = info.size; @@ -24,7 +24,7 @@ bool CCMTLBuffer::initialize(const GFXBufferInfo &info) { _count = _size / _stride; _flags = info.flags; - if (_usage & GFXBufferUsage::INDEX) { + if (_usage & BufferUsage::INDEX) { switch (_stride) { case 4: _indexType = MTLIndexTypeUInt32; break; case 2: _indexType = MTLIndexTypeUInt16; break; @@ -34,19 +34,19 @@ bool CCMTLBuffer::initialize(const GFXBufferInfo &info) { } } - if ((_flags & GFXBufferFlagBit::BAKUP_BUFFER) && _size > 0) { + if ((_flags & BufferFlagBit::BAKUP_BUFFER) && _size > 0) { _buffer = (uint8_t *)CC_MALLOC(_size); if (_buffer) _device->getMemoryStatus().bufferSize += _size; else { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CC_LOG_ERROR("CCMTLBuffer: Failed to create backup buffer."); return false; } } - if (_usage & GFXBufferUsageBit::VERTEX || - _usage & GFXBufferUsageBit::UNIFORM) { + if (_usage & BufferUsageBit::VERTEX || + _usage & BufferUsageBit::UNIFORM) { //for single-use data smaller than 4 KB, use setVertexBytes:length:atIndex: instead //see more detail at https://developer.apple.com/documentation/metal/mtlrendercommandencoder/1515846-setvertexbytes?language=objc if (_size < MINIMUMR_REQUIRED_SIZE_4KB) { @@ -56,29 +56,29 @@ bool CCMTLBuffer::initialize(const GFXBufferInfo &info) { } else { createMTLBuffer(_size, _memUsage); } - } else if (_usage & GFXBufferUsageBit::INDEX || - _usage & GFXBufferUsageBit::INDIRECT) { + } else if (_usage & BufferUsageBit::INDEX || + _usage & BufferUsageBit::INDIRECT) { createMTLBuffer(_size, _memUsage); - } else if (_usage & GFXBufferUsageBit::TRANSFER_SRC || - _usage & GFXBufferUsageBit::TRANSFER_DST) { + } else if (_usage & BufferUsageBit::TRANSFER_SRC || + _usage & BufferUsageBit::TRANSFER_DST) { _transferBuffer = (uint8_t *)CC_MALLOC(_size); if (!_transferBuffer) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CCASSERT(false, "CCMTLBuffer: failed to create memory for transfer buffer."); return false; } _device->getMemoryStatus().bufferSize += _size; } else { - _status = GFXStatus::FAILED; - CCASSERT(false, "Unsupported GFXBufferType, create buffer failed."); + _status = Status::FAILED; + CCASSERT(false, "Unsupported BufferType, create buffer failed."); return false; } - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } -bool CCMTLBuffer::createMTLBuffer(uint size, GFXMemoryUsage usage) { +bool CCMTLBuffer::createMTLBuffer(uint size, MemoryUsage usage) { if (_mtlBuffer) [_mtlBuffer release]; @@ -86,7 +86,7 @@ bool CCMTLBuffer::createMTLBuffer(uint size, GFXMemoryUsage usage) { _mtlBuffer = [id(((CCMTLDevice *)_device)->getMTLDevice()) newBufferWithLength:size options:_mtlResourceOptions]; if (_mtlBuffer == nil) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CCASSERT(false, "Failed to create MTLBuffer."); return false; } @@ -116,17 +116,17 @@ void CCMTLBuffer::destroy() { _device->getMemoryStatus().bufferSize -= _size; _bufferBytes = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void CCMTLBuffer::resize(uint size) { if (_size == size) return; - if (_usage & GFXBufferUsageBit::VERTEX || - _usage & GFXBufferUsageBit::INDEX || - _usage & GFXBufferUsageBit::UNIFORM || - _usage & GFXBufferUsageBit::INDIRECT) { + if (_usage & BufferUsageBit::VERTEX || + _usage & BufferUsageBit::INDEX || + _usage & BufferUsageBit::UNIFORM || + _usage & BufferUsageBit::INDIRECT) { if (_useOptimizedBufferEncoder) { if (size < MINIMUMR_REQUIRED_SIZE_4KB) resizeBuffer(&_bufferBytes, size, _size); @@ -147,14 +147,14 @@ void CCMTLBuffer::resize(uint size) { _count = _size / _stride; resizeBuffer(&_transferBuffer, _size, oldSize); resizeBuffer(&_buffer, _size, oldSize); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; } void CCMTLBuffer::resizeBuffer(uint8_t **buffer, uint size, uint oldSize) { if (!(*buffer)) return; - GFXMemoryStatus &status = _device->getMemoryStatus(); + MemoryStatus &status = _device->getMemoryStatus(); const uint8_t *oldBuffer = *buffer; uint8_t *temp = (uint8_t *)CC_MALLOC(size); if (temp) { @@ -162,23 +162,23 @@ void CCMTLBuffer::resizeBuffer(uint8_t **buffer, uint size, uint oldSize) { *buffer = temp; status.bufferSize += size; } else { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CC_LOG_ERROR("Failed to resize buffer."); return; } CC_FREE(oldBuffer); status.bufferSize -= oldSize; - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; } void CCMTLBuffer::update(void *buffer, uint offset, uint size) { if (_buffer) memcpy(_buffer + offset, buffer, size); - if (_usage & GFXBufferUsageBit::INDIRECT) { + if (_usage & BufferUsageBit::INDIRECT) { auto drawInfoCount = size / _stride; - auto *drawInfo = static_cast(buffer); + auto *drawInfo = static_cast(buffer); if (drawInfoCount > 0) { if (drawInfo->indexCount) { vector arguments(drawInfoCount); @@ -229,13 +229,13 @@ void CCMTLBuffer::update(void *buffer, uint offset, uint size) { } } -void CCMTLBuffer::encodeBuffer(id encoder, uint offset, uint binding, GFXShaderType stages) { +void CCMTLBuffer::encodeBuffer(id encoder, uint offset, uint binding, ShaderType stages) { if (encoder == nil) { CC_LOG_ERROR("CCMTLBuffer::encodeBuffer: MTLRenderCommandEncoder should not be nil."); return; } - if (stages & GFXShaderType::VERTEX) { + if (stages & ShaderType::VERTEX) { if (_useOptimizedBufferEncoder) { [encoder setVertexBytes:_bufferBytes length:_size @@ -247,7 +247,7 @@ void CCMTLBuffer::encodeBuffer(id encoder, uint offset, } } - if (stages & GFXShaderType::FRAGMENT) { + if (stages & ShaderType::FRAGMENT) { if (_useOptimizedBufferEncoder) { [encoder setFragmentBytes:_bufferBytes length:_size diff --git a/native/cocos/renderer/gfx-metal/MTLCommandAllocator.h b/native/cocos/renderer/gfx-metal/MTLCommandAllocator.h index fc61d0423a..ca728995e1 100644 --- a/native/cocos/renderer/gfx-metal/MTLCommandAllocator.h +++ b/native/cocos/renderer/gfx-metal/MTLCommandAllocator.h @@ -8,12 +8,12 @@ namespace gfx { class CCMTLCommandPackage; -class CCMTLCommandAllocator : public GFXCommandAllocator { +class CCMTLCommandAllocator : public CommandAllocator { public: - CCMTLCommandAllocator(GFXDevice *device); + CCMTLCommandAllocator(Device *device); ~CCMTLCommandAllocator(); - virtual bool initialize(const GFXCommandAllocatorInfo &info) override; + virtual bool initialize(const CommandAllocatorInfo &info) override; virtual void destroy() override; void clearCommands(CCMTLCommandPackage *commandPackage); @@ -28,11 +28,11 @@ public: private: friend class CCMTLCommandBuffer; - GFXCommandPool _beginRenderPassCmdPool; - GFXCommandPool _bindStatesCmdPool; - GFXCommandPool _drawCmdPool; - GFXCommandPool _updateBufferCmdPool; - GFXCommandPool _copyBufferToTextureCmdPool; + CommandPool _beginRenderPassCmdPool; + CommandPool _bindStatesCmdPool; + CommandPool _drawCmdPool; + CommandPool _updateBufferCmdPool; + CommandPool _copyBufferToTextureCmdPool; }; } // namespace gfx diff --git a/native/cocos/renderer/gfx-metal/MTLCommandAllocator.mm b/native/cocos/renderer/gfx-metal/MTLCommandAllocator.mm index 95d7df1bfe..9f9a71e991 100644 --- a/native/cocos/renderer/gfx-metal/MTLCommandAllocator.mm +++ b/native/cocos/renderer/gfx-metal/MTLCommandAllocator.mm @@ -6,16 +6,16 @@ namespace cc { namespace gfx { -CCMTLCommandAllocator::CCMTLCommandAllocator(GFXDevice *device) : GFXCommandAllocator(device) {} +CCMTLCommandAllocator::CCMTLCommandAllocator(Device *device) : CommandAllocator(device) {} CCMTLCommandAllocator::~CCMTLCommandAllocator() { destroy(); } -bool CCMTLCommandAllocator::initialize(const GFXCommandAllocatorInfo &info) { - _status = GFXStatus::SUCCESS; +bool CCMTLCommandAllocator::initialize(const CommandAllocatorInfo &info) { + _status = Status::SUCCESS; return true; } void CCMTLCommandAllocator::destroy() { - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void CCMTLCommandAllocator::clearCommands(CCMTLCommandPackage *commandPackage) { diff --git a/native/cocos/renderer/gfx-metal/MTLCommandBuffer.h b/native/cocos/renderer/gfx-metal/MTLCommandBuffer.h index 5d5e4f87d0..2b8c29e754 100644 --- a/native/cocos/renderer/gfx-metal/MTLCommandBuffer.h +++ b/native/cocos/renderer/gfx-metal/MTLCommandBuffer.h @@ -12,34 +12,34 @@ class CCMTLInputAssembler; class CCMTLPipelineState; class CCMTLBindingLayout; -class CCMTLCommandBuffer : public GFXCommandBuffer { +class CCMTLCommandBuffer : public CommandBuffer { friend class CCMTLQueue; public: - CCMTLCommandBuffer(GFXDevice *device); + CCMTLCommandBuffer(Device *device); ~CCMTLCommandBuffer(); - virtual bool initialize(const GFXCommandBufferInfo &info) override; + virtual bool initialize(const CommandBufferInfo &info) override; virtual void destroy() override; - virtual void begin(GFXRenderPass *renderPass = nullptr, uint subpass = 0, GFXFramebuffer *frameBuffer = nullptr) override; + virtual void begin(RenderPass *renderPass = nullptr, uint subpass = 0, Framebuffer *frameBuffer = nullptr) override; virtual void end() override; - virtual void beginRenderPass(GFXFramebuffer *fbo, const GFXRect &render_area, GFXClearFlags clear_flags, const std::vector &colors, float depth, int stencil) override; + virtual void beginRenderPass(Framebuffer *fbo, const Rect &render_area, ClearFlags clear_flags, const std::vector &colors, float depth, int stencil) override; virtual void endRenderPass() override; - virtual void bindPipelineState(GFXPipelineState *pso) override; - virtual void bindBindingLayout(GFXBindingLayout *layout) override; - virtual void bindInputAssembler(GFXInputAssembler *ia) override; - virtual void setViewport(const GFXViewport &vp) override; - virtual void setScissor(const GFXRect &rect) override; + virtual void bindPipelineState(PipelineState *pso) override; + virtual void bindBindingLayout(BindingLayout *layout) override; + virtual void bindInputAssembler(InputAssembler *ia) override; + virtual void setViewport(const Viewport &vp) override; + virtual void setScissor(const Rect &rect) override; virtual void setLineWidth(const float width) override; virtual void setDepthBias(float constant, float clamp, float slope) override; - virtual void setBlendConstants(const GFXColor &constants) override; + virtual void setBlendConstants(const Color &constants) override; virtual void setDepthBound(float min_bounds, float max_bounds) override; - virtual void setStencilWriteMask(GFXStencilFace face, uint mask) override; - virtual void setStencilCompareMask(GFXStencilFace face, int ref, uint mask) override; - virtual void draw(GFXInputAssembler *ia) override; - virtual void updateBuffer(GFXBuffer *buff, void *data, uint size, uint offset = 0) override; - virtual void copyBufferToTexture(GFXBuffer *src, GFXTexture *dst, GFXTextureLayout layout, const GFXBufferTextureCopyList ®ions) override; - virtual void execute(const std::vector &cmd_buffs, uint32_t count) override; + virtual void setStencilWriteMask(StencilFace face, uint mask) override; + virtual void setStencilCompareMask(StencilFace face, int ref, uint mask) override; + virtual void draw(InputAssembler *ia) override; + virtual void updateBuffer(Buffer *buff, void *data, uint size, uint offset = 0) override; + virtual void copyBufferToTexture(Buffer *src, Texture *dst, TextureLayout layout, const BufferTextureCopyList ®ions) override; + virtual void execute(const std::vector &cmd_buffs, uint32_t count) override; CC_INLINE const CCMTLCommandPackage *getCommandPackage() const { return _commandPackage; } @@ -55,12 +55,12 @@ private: CCMTLPipelineState *_currentPipelineState = nullptr; CCMTLInputAssembler *_currentInputAssembler = nullptr; CCMTLBindingLayout *_currentBindingLayout = nullptr; - GFXViewport _currentViewport; - GFXRect _currentScissor; + Viewport _currentViewport; + Rect _currentScissor; // Just don't want to include "Commands.h", because "Commands.h" includes Objective-C codes. CCMTLDepthBias *_currentDepthBias = nullptr; CCMTLDepthBounds *_currentDepthBounds = nullptr; - GFXColor _currentBlendConstants; + Color _currentBlendConstants; const static uint DYNAMIC_STATE_SIZE = 8; std::array _dynamicStateDirty = {false, false, false, false, false, false, false, false}; }; diff --git a/native/cocos/renderer/gfx-metal/MTLCommandBuffer.mm b/native/cocos/renderer/gfx-metal/MTLCommandBuffer.mm index 81d0b3c9b4..18a7fc4565 100644 --- a/native/cocos/renderer/gfx-metal/MTLCommandBuffer.mm +++ b/native/cocos/renderer/gfx-metal/MTLCommandBuffer.mm @@ -15,10 +15,10 @@ namespace cc { namespace gfx { -CCMTLCommandBuffer::CCMTLCommandBuffer(GFXDevice *device) : GFXCommandBuffer(device) {} +CCMTLCommandBuffer::CCMTLCommandBuffer(Device *device) : CommandBuffer(device) {} CCMTLCommandBuffer::~CCMTLCommandBuffer() { destroy(); } -bool CCMTLCommandBuffer::initialize(const GFXCommandBufferInfo &info) { +bool CCMTLCommandBuffer::initialize(const CommandBufferInfo &info) { if (!info.allocator) return false; @@ -44,7 +44,7 @@ bool CCMTLCommandBuffer::initialize(const GFXCommandBufferInfo &info) { return false; } - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -55,14 +55,14 @@ void CCMTLCommandBuffer::destroy() { _MTLCommandAllocator = nullptr; } _allocator = nullptr; - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; CC_SAFE_DELETE(_commandPackage); CC_SAFE_DELETE(_currentDepthBias); CC_SAFE_DELETE(_currentDepthBounds); } -void CCMTLCommandBuffer::begin(GFXRenderPass *renderPass, uint subpass, GFXFramebuffer *frameBuffer) { +void CCMTLCommandBuffer::begin(RenderPass *renderPass, uint subpass, Framebuffer *frameBuffer) { _MTLCommandAllocator->clearCommands(_commandPackage); _numTriangles = 0; _numDrawCalls = 0; @@ -72,7 +72,7 @@ void CCMTLCommandBuffer::end() { _isInRenderPass = false; } -void CCMTLCommandBuffer::beginRenderPass(GFXFramebuffer *fbo, const GFXRect &render_area, GFXClearFlags clear_flags, const std::vector &colors, float depth, int stencil) { +void CCMTLCommandBuffer::beginRenderPass(Framebuffer *fbo, const Rect &render_area, ClearFlags clear_flags, const std::vector &colors, float depth, int stencil) { _isInRenderPass = true; CCMTLCmdBeginRenderPass *cmd = _MTLCommandAllocator->_beginRenderPassCmdPool.alloc(); @@ -92,33 +92,33 @@ void CCMTLCommandBuffer::endRenderPass() { _commandPackage->commandTypes.push(GFXCmdType::END_RENDER_PASS); } -void CCMTLCommandBuffer::bindPipelineState(GFXPipelineState *pso) { +void CCMTLCommandBuffer::bindPipelineState(PipelineState *pso) { _isStateInValid = true; _currentPipelineState = static_cast(pso); } -void CCMTLCommandBuffer::bindBindingLayout(GFXBindingLayout *layout) { +void CCMTLCommandBuffer::bindBindingLayout(BindingLayout *layout) { _currentBindingLayout = static_cast(layout); _isStateInValid = true; } -void CCMTLCommandBuffer::bindInputAssembler(GFXInputAssembler *ia) { +void CCMTLCommandBuffer::bindInputAssembler(InputAssembler *ia) { _currentInputAssembler = static_cast(ia); _isStateInValid = true; } -void CCMTLCommandBuffer::setViewport(const GFXViewport &vp) { +void CCMTLCommandBuffer::setViewport(const Viewport &vp) { if (_currentViewport != vp) { _currentViewport = vp; - _dynamicStateDirty[static_cast(GFXDynamicState::VIEWPORT)] = true; + _dynamicStateDirty[static_cast(DynamicState::VIEWPORT)] = true; _isStateInValid = true; } } -void CCMTLCommandBuffer::setScissor(const GFXRect &rect) { +void CCMTLCommandBuffer::setScissor(const Rect &rect) { if (_currentScissor != rect) { _currentScissor = rect; - _dynamicStateDirty[static_cast(GFXDynamicState::SCISSOR)] = true; + _dynamicStateDirty[static_cast(DynamicState::SCISSOR)] = true; _isStateInValid = true; } } @@ -135,11 +135,11 @@ void CCMTLCommandBuffer::setDepthBias(float constant, float clamp, float slope) _currentDepthBias->slopeScale = slope; _currentDepthBias->clamp = clamp; _isStateInValid = true; - _dynamicStateDirty[static_cast(GFXDynamicState::DEPTH_BIAS)] = true; + _dynamicStateDirty[static_cast(DynamicState::DEPTH_BIAS)] = true; } } -void CCMTLCommandBuffer::setBlendConstants(const GFXColor &constants) { +void CCMTLCommandBuffer::setBlendConstants(const Color &constants) { if (math::IsNotEqualF(constants.r, _currentBlendConstants.r) || math::IsNotEqualF(constants.g, _currentBlendConstants.g) || math::IsNotEqualF(constants.b, _currentBlendConstants.b) || @@ -149,7 +149,7 @@ void CCMTLCommandBuffer::setBlendConstants(const GFXColor &constants) { _currentBlendConstants.b = constants.b; _currentBlendConstants.a = constants.a; _isStateInValid = true; - _dynamicStateDirty[static_cast(GFXDynamicState::BLEND_CONSTANTS)] = true; + _dynamicStateDirty[static_cast(DynamicState::BLEND_CONSTANTS)] = true; } } @@ -157,17 +157,17 @@ void CCMTLCommandBuffer::setDepthBound(float minBounds, float maxBounds) { CC_LOG_ERROR("Metal doesn't support setting depth bound."); } -void CCMTLCommandBuffer::setStencilWriteMask(GFXStencilFace face, uint mask) { +void CCMTLCommandBuffer::setStencilWriteMask(StencilFace face, uint mask) { CC_LOG_ERROR("Don't support change stencil write mask here."); } -void CCMTLCommandBuffer::setStencilCompareMask(GFXStencilFace face, int ref, uint mask) { +void CCMTLCommandBuffer::setStencilCompareMask(StencilFace face, int ref, uint mask) { CC_LOG_ERROR("Don't support change stencil compare mask here."); } -void CCMTLCommandBuffer::draw(GFXInputAssembler *ia) { - if ((_type == GFXCommandBufferType::PRIMARY && _isInRenderPass) || - _type == GFXCommandBufferType::SECONDARY) { +void CCMTLCommandBuffer::draw(InputAssembler *ia) { + if ((_type == CommandBufferType::PRIMARY && _isInRenderPass) || + _type == CommandBufferType::SECONDARY) { CCMTLCmdDraw *cmd = _MTLCommandAllocator->_drawCmdPool.alloc(); if (!cmd) return; @@ -198,9 +198,9 @@ void CCMTLCommandBuffer::draw(GFXInputAssembler *ia) { CC_LOG_ERROR("Command 'draw' must be recorded inside a render pass."); } -void CCMTLCommandBuffer::updateBuffer(GFXBuffer *buff, void *data, uint size, uint offset) { - if ((_type == GFXCommandBufferType::PRIMARY && _isInRenderPass) || - (_type == GFXCommandBufferType::SECONDARY)) { +void CCMTLCommandBuffer::updateBuffer(Buffer *buff, void *data, uint size, uint offset) { + if ((_type == CommandBufferType::PRIMARY && _isInRenderPass) || + (_type == CommandBufferType::SECONDARY)) { if (buff) { CCMTLCmdUpdateBuffer *cmd = _MTLCommandAllocator->_updateBufferCmdPool.alloc(); cmd->gpuBuffer = static_cast(buff); @@ -216,9 +216,9 @@ void CCMTLCommandBuffer::updateBuffer(GFXBuffer *buff, void *data, uint size, ui } } -void CCMTLCommandBuffer::copyBufferToTexture(GFXBuffer *src, GFXTexture *dst, GFXTextureLayout layout, const GFXBufferTextureCopyList ®ions) { - if ((_type == GFXCommandBufferType::PRIMARY && _isInRenderPass) || - (_type == GFXCommandBufferType::SECONDARY)) { +void CCMTLCommandBuffer::copyBufferToTexture(Buffer *src, Texture *dst, TextureLayout layout, const BufferTextureCopyList ®ions) { + if ((_type == CommandBufferType::PRIMARY && _isInRenderPass) || + (_type == CommandBufferType::SECONDARY)) { if (src && dst) { CCMTLCmdCopyBufferToTexture *cmd = _MTLCommandAllocator->_copyBufferToTextureCmdPool.alloc(); cmd->gpuBuffer = static_cast(src); @@ -235,7 +235,7 @@ void CCMTLCommandBuffer::copyBufferToTexture(GFXBuffer *src, GFXTexture *dst, GF } } -void CCMTLCommandBuffer::execute(const std::vector &commandBuffs, uint32_t count) { +void CCMTLCommandBuffer::execute(const std::vector &commandBuffs, uint32_t count) { for (uint i = 0; i < count; ++i) { auto commandBuffer = static_cast(commandBuffs[i]); for (uint j = 0; j < commandBuffer->_commandPackage->beginRenderPassCmds.size(); ++j) { diff --git a/native/cocos/renderer/gfx-metal/MTLCommands.h b/native/cocos/renderer/gfx-metal/MTLCommands.h index 451532f02e..ee2b4091bc 100644 --- a/native/cocos/renderer/gfx-metal/MTLCommands.h +++ b/native/cocos/renderer/gfx-metal/MTLCommands.h @@ -26,11 +26,11 @@ struct CCMTLDepthBounds { class CCMTLCmdBeginRenderPass : public GFXCmd { public: - GFXRect renderArea; - GFXClearFlags clearFlags = GFXClearFlags::NONE; + Rect renderArea; + ClearFlags clearFlags = ClearFlags::NONE; CCMTLFramebuffer *frameBuffer = nullptr; uint numOfClearColor = 0; - vector clearColors; + vector clearColors; float clearDepth = 1.f; int clearStencil = 0; @@ -43,7 +43,7 @@ public: class CCMTLCmdBindStates : public GFXCmd { public: - GFXBindingLayout *bindingLayout = nullptr; + BindingLayout *bindingLayout = nullptr; CCMTLPipelineState *pipelineState = nullptr; CCMTLInputAssembler *inputAssembler = nullptr; MTLViewport viewport = {}; @@ -51,7 +51,7 @@ public: bool depthBiasEnabled = false; CCMTLDepthBias depthBias; CCMTLDepthBounds depthBounds; - GFXColor blendConstants; + Color blendConstants; const static uint DYNAMIC_STATE_SIZE = 8; std::array dynamicStateDirty = {false, false, false, false, false, false, false, false}; @@ -62,7 +62,7 @@ public: class CCMTLCmdDraw : public GFXCmd { public: - GFXDrawInfo drawInfo; + DrawInfo drawInfo; CCMTLCmdDraw() : GFXCmd(GFXCmdType::DRAW) {} virtual void clear() override {} @@ -72,8 +72,8 @@ class CCMTLCmdCopyBufferToTexture : public GFXCmd { public: CCMTLBuffer *gpuBuffer = nullptr; CCMTLTexture *gpuTexture = nullptr; - GFXTextureLayout dstLayout; - GFXBufferTextureCopyList regions; + TextureLayout dstLayout; + BufferTextureCopyList regions; CCMTLCmdCopyBufferToTexture() : GFXCmd(GFXCmdType::COPY_BUFFER_TO_TEXTURE) {} virtual void clear() override { diff --git a/native/cocos/renderer/gfx-metal/MTLContext.h b/native/cocos/renderer/gfx-metal/MTLContext.h index cf17e3994e..befd698dfb 100644 --- a/native/cocos/renderer/gfx-metal/MTLContext.h +++ b/native/cocos/renderer/gfx-metal/MTLContext.h @@ -3,12 +3,12 @@ namespace cc { namespace gfx { -class CCMTLContext : public GFXContext { +class CCMTLContext : public Context { public: - CCMTLContext(GFXDevice *device); + CCMTLContext(Device *device); ~CCMTLContext(); - bool initialize(const GFXContextInfo &info) override; + bool initialize(const ContextInfo &info) override; void destroy() override{}; void present() override{}; }; diff --git a/native/cocos/renderer/gfx-metal/MTLContext.mm b/native/cocos/renderer/gfx-metal/MTLContext.mm index e62ca50f27..1da27c5cf0 100644 --- a/native/cocos/renderer/gfx-metal/MTLContext.mm +++ b/native/cocos/renderer/gfx-metal/MTLContext.mm @@ -9,32 +9,32 @@ namespace cc { namespace gfx { namespace { -GFXFormat toGFXFormat(MTLPixelFormat format) { +Format toFormat(MTLPixelFormat format) { switch (format) { - case MTLPixelFormatRGBA8Unorm: return GFXFormat::RGBA8; - case MTLPixelFormatBGRA8Unorm: return GFXFormat::BGRA8; - case MTLPixelFormatDepth24Unorm_Stencil8: return GFXFormat::D24S8; - case MTLPixelFormatDepth32Float_Stencil8: return GFXFormat::D32F_S8; + case MTLPixelFormatRGBA8Unorm: return Format::RGBA8; + case MTLPixelFormatBGRA8Unorm: return Format::BGRA8; + case MTLPixelFormatDepth24Unorm_Stencil8: return Format::D24S8; + case MTLPixelFormatDepth32Float_Stencil8: return Format::D32F_S8; default: CC_LOG_ERROR("invalid MTLPixelFormat."); - return GFXFormat::UNKNOWN; + return Format::UNKNOWN; } } } -CCMTLContext::CCMTLContext(GFXDevice *device) -: GFXContext(device) { +CCMTLContext::CCMTLContext(Device *device) +: Context(device) { } CCMTLContext::~CCMTLContext() { } -bool CCMTLContext::initialize(const GFXContextInfo &info) { +bool CCMTLContext::initialize(const ContextInfo &info) { _vsyncMode = info.vsyncMode; _windowHandle = info.windowHandle; MTKView *view = (MTKView *)((CCMTLDevice *)_device)->getMTKView(); - _colorFmt = toGFXFormat(view.colorPixelFormat); - _depthStencilFmt = toGFXFormat(view.depthStencilPixelFormat); + _colorFmt = toFormat(view.colorPixelFormat); + _depthStencilFmt = toFormat(view.depthStencilPixelFormat); return true; } diff --git a/native/cocos/renderer/gfx-metal/MTLDevice.h b/native/cocos/renderer/gfx-metal/MTLDevice.h index 5417ea4e3c..ad4b0545f1 100644 --- a/native/cocos/renderer/gfx-metal/MTLDevice.h +++ b/native/cocos/renderer/gfx-metal/MTLDevice.h @@ -5,32 +5,32 @@ namespace gfx { class CCMTLStateCache; -class CCMTLDevice : public GFXDevice { +class CCMTLDevice : public Device { public: CCMTLDevice(); ~CCMTLDevice(); - virtual bool initialize(const GFXDeviceInfo &info) override; + virtual bool initialize(const DeviceInfo &info) override; virtual void destroy() override; virtual void resize(uint width, uint height) override; virtual void acquire() override{}; virtual void present() override; - virtual GFXFence *createFence(const GFXFenceInfo &info) override; - virtual GFXQueue *createQueue(const GFXQueueInfo &info) override; - virtual GFXCommandAllocator *createCommandAllocator(const GFXCommandAllocatorInfo &info) override; - virtual GFXCommandBuffer *createCommandBuffer(const GFXCommandBufferInfo &info) override; - virtual GFXBuffer *createBuffer(const GFXBufferInfo &info) override; - virtual GFXTexture *createTexture(const GFXTextureInfo &info) override; - virtual GFXTexture *createTexture(const GFXTextureViewInfo &info) override; - virtual GFXSampler *createSampler(const GFXSamplerInfo &info) override; - virtual GFXShader *createShader(const GFXShaderInfo &info) override; - virtual GFXInputAssembler *createInputAssembler(const GFXInputAssemblerInfo &info) override; - virtual GFXRenderPass *createRenderPass(const GFXRenderPassInfo &info) override; - virtual GFXFramebuffer *createFramebuffer(const GFXFramebufferInfo &info) override; - virtual GFXBindingLayout *createBindingLayout(const GFXBindingLayoutInfo &info) override; - virtual GFXPipelineState *createPipelineState(const GFXPipelineStateInfo &info) override; - virtual GFXPipelineLayout *createPipelineLayout(const GFXPipelineLayoutInfo &info) override; - virtual void copyBuffersToTexture(const GFXDataArray &buffers, GFXTexture *dst, const GFXBufferTextureCopyList ®ions) override; + virtual Fence *createFence(const FenceInfo &info) override; + virtual Queue *createQueue(const QueueInfo &info) override; + virtual CommandAllocator *createCommandAllocator(const CommandAllocatorInfo &info) override; + virtual CommandBuffer *createCommandBuffer(const CommandBufferInfo &info) override; + virtual Buffer *createBuffer(const BufferInfo &info) override; + virtual Texture *createTexture(const TextureInfo &info) override; + virtual Texture *createTexture(const TextureViewInfo &info) override; + virtual Sampler *createSampler(const SamplerInfo &info) override; + virtual Shader *createShader(const ShaderInfo &info) override; + virtual InputAssembler *createInputAssembler(const InputAssemblerInfo &info) override; + virtual RenderPass *createRenderPass(const RenderPassInfo &info) override; + virtual Framebuffer *createFramebuffer(const FramebufferInfo &info) override; + virtual BindingLayout *createBindingLayout(const BindingLayoutInfo &info) override; + virtual PipelineState *createPipelineState(const PipelineStateInfo &info) override; + virtual PipelineLayout *createPipelineLayout(const PipelineLayoutInfo &info) override; + virtual void copyBuffersToTexture(const DataArray &buffers, Texture *dst, const BufferTextureCopyList ®ions) override; virtual void blitBuffer(void *srcBuffer, uint offset, uint size, void *dstBuffer); CC_INLINE void *getMTKView() const { return _mtkView; } diff --git a/native/cocos/renderer/gfx-metal/MTLDevice.mm b/native/cocos/renderer/gfx-metal/MTLDevice.mm index 6e7ada6c23..90af8cf8b8 100644 --- a/native/cocos/renderer/gfx-metal/MTLDevice.mm +++ b/native/cocos/renderer/gfx-metal/MTLDevice.mm @@ -28,8 +28,8 @@ namespace gfx { CCMTLDevice::CCMTLDevice() {} CCMTLDevice::~CCMTLDevice() {} -bool CCMTLDevice::initialize(const GFXDeviceInfo &info) { - _gfxAPI = GFXAPI::METAL; +bool CCMTLDevice::initialize(const DeviceInfo &info) { + _API = API::METAL; _deviceName = "Metal"; _width = info.width; _height = info.height; @@ -42,7 +42,7 @@ bool CCMTLDevice::initialize(const GFXDeviceInfo &info) { _mtkView = (MTKView *)_windowHandle; _mtlDevice = ((MTKView *)_mtkView).device; - GFXContextInfo contextCreateInfo; + ContextInfo contextCreateInfo; contextCreateInfo.windowHandle = _windowHandle; contextCreateInfo.sharedCtx = info.sharedCtx; _context = CC_NEW(CCMTLContext(this)); @@ -51,11 +51,11 @@ bool CCMTLDevice::initialize(const GFXDeviceInfo &info) { return false; } - GFXQueueInfo queue_info; - queue_info.type = GFXQueueType::GRAPHICS; + QueueInfo queue_info; + queue_info.type = QueueType::GRAPHICS; _queue = createQueue(queue_info); - GFXCommandAllocatorInfo cmd_alloc_info; + CommandAllocatorInfo cmd_alloc_info; _cmdAllocator = createCommandAllocator(cmd_alloc_info); _minClipZ = 0; @@ -75,46 +75,46 @@ bool CCMTLDevice::initialize(const GFXDeviceInfo &info) { if ([id(_mtlDevice) isDepth24Stencil8PixelFormatSupported]) { _depthBits = 24; _stencilBits = 8; - _features[(int)GFXFeature::FORMAT_D24S8] = true; + _features[(int)Feature::FORMAT_D24S8] = true; } - _features[static_cast(GFXFeature::COLOR_FLOAT)] = mu::isColorBufferFloatSupported(gpuFamily); - _features[static_cast(GFXFeature::COLOR_HALF_FLOAT)] = mu::isColorBufferHalfFloatSupported(gpuFamily); - _features[static_cast(GFXFeature::TEXTURE_FLOAT_LINEAR)] = mu::isLinearTextureSupported(gpuFamily); - _features[static_cast(GFXFeature::TEXTURE_HALF_FLOAT_LINEAR)] = mu::isLinearTextureSupported(gpuFamily); + _features[static_cast(Feature::COLOR_FLOAT)] = mu::isColorBufferFloatSupported(gpuFamily); + _features[static_cast(Feature::COLOR_HALF_FLOAT)] = mu::isColorBufferHalfFloatSupported(gpuFamily); + _features[static_cast(Feature::TEXTURE_FLOAT_LINEAR)] = mu::isLinearTextureSupported(gpuFamily); + _features[static_cast(Feature::TEXTURE_HALF_FLOAT_LINEAR)] = mu::isLinearTextureSupported(gpuFamily); String compressedFormats; if (mu::isPVRTCSuppported(gpuFamily)) { - _features[static_cast(GFXFeature::FORMAT_PVRTC)] = true; + _features[static_cast(Feature::FORMAT_PVRTC)] = true; compressedFormats += "pvrtc "; } if (mu::isEAC_ETCCSuppported(gpuFamily)) { - _features[static_cast(GFXFeature::FORMAT_ETC2)] = true; + _features[static_cast(Feature::FORMAT_ETC2)] = true; compressedFormats += "etc2 "; } if (mu::isASTCSuppported(gpuFamily)) { - _features[static_cast(GFXFeature::FORMAT_ASTC)] = true; + _features[static_cast(Feature::FORMAT_ASTC)] = true; compressedFormats += "astc "; } if (mu::isBCSupported(gpuFamily)) { - _features[static_cast(GFXFeature::FORMAT_ASTC)] = true; + _features[static_cast(Feature::FORMAT_ASTC)] = true; compressedFormats += "dxt "; } - _features[(int)GFXFeature::TEXTURE_FLOAT] = true; - _features[(int)GFXFeature::TEXTURE_HALF_FLOAT] = true; - _features[(int)GFXFeature::FORMAT_R11G11B10F] = true; - _features[(int)GFXFeature::MSAA] = true; - _features[(int)GFXFeature::INSTANCED_ARRAYS] = true; - _features[static_cast(GFXFeature::DEPTH_BOUNDS)] = false; - _features[static_cast(GFXFeature::LINE_WIDTH)] = false; - _features[static_cast(GFXFeature::STENCIL_COMPARE_MASK)] = false; - _features[static_cast(GFXFeature::STENCIL_WRITE_MASK)] = false; - _features[static_cast(GFXFeature::FORMAT_RGB8)] = false; - _features[static_cast(GFXFeature::FORMAT_D16)] = mu::isDepthStencilFormatSupported(GFXFormat::D16, gpuFamily); - _features[static_cast(GFXFeature::FORMAT_D16S8)] = mu::isDepthStencilFormatSupported(GFXFormat::D16S8, gpuFamily); - _features[static_cast(GFXFeature::FORMAT_D32F)] = mu::isDepthStencilFormatSupported(GFXFormat::D32F, gpuFamily); - _features[static_cast(GFXFeature::FORMAT_D32FS8)] = mu::isDepthStencilFormatSupported(GFXFormat::D32F_S8, gpuFamily); + _features[(int)Feature::TEXTURE_FLOAT] = true; + _features[(int)Feature::TEXTURE_HALF_FLOAT] = true; + _features[(int)Feature::FORMAT_R11G11B10F] = true; + _features[(int)Feature::MSAA] = true; + _features[(int)Feature::INSTANCED_ARRAYS] = true; + _features[static_cast(Feature::DEPTH_BOUNDS)] = false; + _features[static_cast(Feature::LINE_WIDTH)] = false; + _features[static_cast(Feature::STENCIL_COMPARE_MASK)] = false; + _features[static_cast(Feature::STENCIL_WRITE_MASK)] = false; + _features[static_cast(Feature::FORMAT_RGB8)] = false; + _features[static_cast(Feature::FORMAT_D16)] = mu::isDepthStencilFormatSupported(Format::D16, gpuFamily); + _features[static_cast(Feature::FORMAT_D16S8)] = mu::isDepthStencilFormatSupported(Format::D16S8, gpuFamily); + _features[static_cast(Feature::FORMAT_D32F)] = mu::isDepthStencilFormatSupported(Format::D32F, gpuFamily); + _features[static_cast(Feature::FORMAT_D32FS8)] = mu::isDepthStencilFormatSupported(Format::D32F_S8, gpuFamily); CC_LOG_INFO("Metal Feature Set: %s", mu::featureSetToString(MTLFeatureSet(_mtlFeatureSet)).c_str()); @@ -140,7 +140,7 @@ void CCMTLDevice::present() { queue->_numTriangles = 0; } -GFXFence *CCMTLDevice::createFence(const GFXFenceInfo &info) { +Fence *CCMTLDevice::createFence(const FenceInfo &info) { auto fence = CC_NEW(CCMTLFence(this)); if (fence && fence->initialize(info)) return fence; @@ -149,7 +149,7 @@ GFXFence *CCMTLDevice::createFence(const GFXFenceInfo &info) { return nullptr; } -GFXQueue *CCMTLDevice::createQueue(const GFXQueueInfo &info) { +Queue *CCMTLDevice::createQueue(const QueueInfo &info) { auto queue = CC_NEW(CCMTLQueue(this)); if (queue && queue->initialize(info)) return queue; @@ -158,7 +158,7 @@ GFXQueue *CCMTLDevice::createQueue(const GFXQueueInfo &info) { return nullptr; } -GFXCommandAllocator *CCMTLDevice::createCommandAllocator(const GFXCommandAllocatorInfo &info) { +CommandAllocator *CCMTLDevice::createCommandAllocator(const CommandAllocatorInfo &info) { auto allocator = CC_NEW(CCMTLCommandAllocator(this)); if (allocator && allocator->initialize(info)) return allocator; @@ -167,7 +167,7 @@ GFXCommandAllocator *CCMTLDevice::createCommandAllocator(const GFXCommandAllocat return nullptr; } -GFXCommandBuffer *CCMTLDevice::createCommandBuffer(const GFXCommandBufferInfo &info) { +CommandBuffer *CCMTLDevice::createCommandBuffer(const CommandBufferInfo &info) { auto commandBuffer = CC_NEW(CCMTLCommandBuffer(this)); if (commandBuffer && commandBuffer->initialize(info)) return commandBuffer; @@ -176,7 +176,7 @@ GFXCommandBuffer *CCMTLDevice::createCommandBuffer(const GFXCommandBufferInfo &i return nullptr; } -GFXBuffer *CCMTLDevice::createBuffer(const GFXBufferInfo &info) { +Buffer *CCMTLDevice::createBuffer(const BufferInfo &info) { auto buffer = CC_NEW(CCMTLBuffer(this)); if (buffer && buffer->initialize(info)) return buffer; @@ -185,7 +185,7 @@ GFXBuffer *CCMTLDevice::createBuffer(const GFXBufferInfo &info) { return nullptr; } -GFXTexture *CCMTLDevice::createTexture(const GFXTextureInfo &info) { +Texture *CCMTLDevice::createTexture(const TextureInfo &info) { auto texture = CC_NEW(CCMTLTexture(this)); if (texture && texture->initialize(info)) return texture; @@ -194,7 +194,7 @@ GFXTexture *CCMTLDevice::createTexture(const GFXTextureInfo &info) { return nullptr; } -GFXTexture *CCMTLDevice::createTexture(const GFXTextureViewInfo &info) { +Texture *CCMTLDevice::createTexture(const TextureViewInfo &info) { auto texture = CC_NEW(CCMTLTexture(this)); if (texture && texture->initialize(info)) return texture; @@ -203,7 +203,7 @@ GFXTexture *CCMTLDevice::createTexture(const GFXTextureViewInfo &info) { return nullptr; } -GFXSampler *CCMTLDevice::createSampler(const GFXSamplerInfo &info) { +Sampler *CCMTLDevice::createSampler(const SamplerInfo &info) { auto sampler = CC_NEW(CCMTLSampler(this)); if (sampler && sampler->initialize(info)) return sampler; @@ -212,7 +212,7 @@ GFXSampler *CCMTLDevice::createSampler(const GFXSamplerInfo &info) { return sampler; } -GFXShader *CCMTLDevice::createShader(const GFXShaderInfo &info) { +Shader *CCMTLDevice::createShader(const ShaderInfo &info) { auto shader = CC_NEW(CCMTLShader(this)); if (shader && shader->initialize(info)) return shader; @@ -221,7 +221,7 @@ GFXShader *CCMTLDevice::createShader(const GFXShaderInfo &info) { return shader; } -GFXInputAssembler *CCMTLDevice::createInputAssembler(const GFXInputAssemblerInfo &info) { +InputAssembler *CCMTLDevice::createInputAssembler(const InputAssemblerInfo &info) { auto ia = CC_NEW(CCMTLInputAssembler(this)); if (ia && ia->initialize(info)) return ia; @@ -230,7 +230,7 @@ GFXInputAssembler *CCMTLDevice::createInputAssembler(const GFXInputAssemblerInfo return nullptr; } -GFXRenderPass *CCMTLDevice::createRenderPass(const GFXRenderPassInfo &info) { +RenderPass *CCMTLDevice::createRenderPass(const RenderPassInfo &info) { auto renderPass = CC_NEW(CCMTLRenderPass(this)); if (renderPass && renderPass->initialize(info)) return renderPass; @@ -239,7 +239,7 @@ GFXRenderPass *CCMTLDevice::createRenderPass(const GFXRenderPassInfo &info) { return nullptr; } -GFXFramebuffer *CCMTLDevice::createFramebuffer(const GFXFramebufferInfo &info) { +Framebuffer *CCMTLDevice::createFramebuffer(const FramebufferInfo &info) { auto frameBuffer = CC_NEW(CCMTLFramebuffer(this)); if (frameBuffer && frameBuffer->initialize(info)) return frameBuffer; @@ -248,7 +248,7 @@ GFXFramebuffer *CCMTLDevice::createFramebuffer(const GFXFramebufferInfo &info) { return nullptr; } -GFXBindingLayout *CCMTLDevice::createBindingLayout(const GFXBindingLayoutInfo &info) { +BindingLayout *CCMTLDevice::createBindingLayout(const BindingLayoutInfo &info) { auto bl = CC_NEW(CCMTLBindingLayout(this)); if (bl && bl->initialize(info)) return bl; @@ -257,7 +257,7 @@ GFXBindingLayout *CCMTLDevice::createBindingLayout(const GFXBindingLayoutInfo &i return nullptr; } -GFXPipelineState *CCMTLDevice::createPipelineState(const GFXPipelineStateInfo &info) { +PipelineState *CCMTLDevice::createPipelineState(const PipelineStateInfo &info) { auto ps = CC_NEW(CCMTLPipelineState(this)); if (ps && ps->initialize(info)) return ps; @@ -266,7 +266,7 @@ GFXPipelineState *CCMTLDevice::createPipelineState(const GFXPipelineStateInfo &i return nullptr; } -GFXPipelineLayout *CCMTLDevice::createPipelineLayout(const GFXPipelineLayoutInfo &info) { +PipelineLayout *CCMTLDevice::createPipelineLayout(const PipelineLayoutInfo &info) { auto pl = CC_NEW(CCMTLPipelineLayout(this)); if (pl && pl->initialize(info)) return pl; @@ -275,7 +275,7 @@ GFXPipelineLayout *CCMTLDevice::createPipelineLayout(const GFXPipelineLayoutInfo return nullptr; } -void CCMTLDevice::copyBuffersToTexture(const GFXDataArray &buffers, GFXTexture *dst, const GFXBufferTextureCopyList ®ions) { +void CCMTLDevice::copyBuffersToTexture(const DataArray &buffers, Texture *dst, const BufferTextureCopyList ®ions) { static_cast(dst)->update(buffers.datas.data(), regions); } diff --git a/native/cocos/renderer/gfx-metal/MTLFence.h b/native/cocos/renderer/gfx-metal/MTLFence.h index fbd8de17be..50bfdb3200 100644 --- a/native/cocos/renderer/gfx-metal/MTLFence.h +++ b/native/cocos/renderer/gfx-metal/MTLFence.h @@ -3,12 +3,12 @@ namespace cc { namespace gfx { -class CCMTLFence : public GFXFence { +class CCMTLFence : public Fence { public: - CCMTLFence(GFXDevice *device); + CCMTLFence(Device *device); ~CCMTLFence(); - virtual bool initialize(const GFXFenceInfo &info) override; + virtual bool initialize(const FenceInfo &info) override; virtual void destroy() override; virtual void wait() override; virtual void reset() override; diff --git a/native/cocos/renderer/gfx-metal/MTLFence.mm b/native/cocos/renderer/gfx-metal/MTLFence.mm index 77bab3a904..ee6873e73d 100644 --- a/native/cocos/renderer/gfx-metal/MTLFence.mm +++ b/native/cocos/renderer/gfx-metal/MTLFence.mm @@ -6,23 +6,23 @@ namespace cc { namespace gfx { -CCMTLFence::CCMTLFence(GFXDevice *device) : GFXFence(device) {} +CCMTLFence::CCMTLFence(Device *device) : Fence(device) {} CCMTLFence::~CCMTLFence() { destroy(); } -bool CCMTLFence::initialize(const GFXFenceInfo &info) { +bool CCMTLFence::initialize(const FenceInfo &info) { // TODO - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } void CCMTLFence::destroy() { // TODO - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void CCMTLFence::wait() { diff --git a/native/cocos/renderer/gfx-metal/MTLFrameBuffer.h b/native/cocos/renderer/gfx-metal/MTLFrameBuffer.h index e474a5bddc..c17ce88a65 100644 --- a/native/cocos/renderer/gfx-metal/MTLFrameBuffer.h +++ b/native/cocos/renderer/gfx-metal/MTLFrameBuffer.h @@ -3,12 +3,12 @@ namespace cc { namespace gfx { -class CCMTLFramebuffer : public GFXFramebuffer { +class CCMTLFramebuffer : public Framebuffer { public: - CCMTLFramebuffer(GFXDevice *device); + CCMTLFramebuffer(Device *device); ~CCMTLFramebuffer(); - virtual bool initialize(const GFXFramebufferInfo &info) override; + virtual bool initialize(const FramebufferInfo &info) override; virtual void destroy() override; }; diff --git a/native/cocos/renderer/gfx-metal/MTLFramebuffer.mm b/native/cocos/renderer/gfx-metal/MTLFramebuffer.mm index 7cd28d7dae..c527cebecd 100644 --- a/native/cocos/renderer/gfx-metal/MTLFramebuffer.mm +++ b/native/cocos/renderer/gfx-metal/MTLFramebuffer.mm @@ -7,10 +7,10 @@ namespace cc { namespace gfx { -CCMTLFramebuffer::CCMTLFramebuffer(GFXDevice *device) : GFXFramebuffer(device) {} +CCMTLFramebuffer::CCMTLFramebuffer(Device *device) : Framebuffer(device) {} CCMTLFramebuffer::~CCMTLFramebuffer() { destroy(); } -bool CCMTLFramebuffer::initialize(const GFXFramebufferInfo &info) { +bool CCMTLFramebuffer::initialize(const FramebufferInfo &info) { _renderPass = info.renderPass; _colorTextures = info.colorTextures; _depthStencilTexture = info.depthStencilTexture; @@ -38,13 +38,13 @@ bool CCMTLFramebuffer::initialize(const GFXFramebufferInfo &info) { } } - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } void CCMTLFramebuffer::destroy() { - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-metal/MTLInputAssembler.h b/native/cocos/renderer/gfx-metal/MTLInputAssembler.h index f10da056e5..8cabc1053b 100644 --- a/native/cocos/renderer/gfx-metal/MTLInputAssembler.h +++ b/native/cocos/renderer/gfx-metal/MTLInputAssembler.h @@ -6,14 +6,14 @@ namespace gfx { class CCMTLCmdDraw; class CCMTLGPUInputAssembler; -class CCMTLInputAssembler : public GFXInputAssembler { +class CCMTLInputAssembler : public InputAssembler { friend class CCMTLQueue; public: - CCMTLInputAssembler(GFXDevice *device); + CCMTLInputAssembler(Device *device); ~CCMTLInputAssembler(); - virtual bool initialize(const GFXInputAssemblerInfo &info) override; + virtual bool initialize(const InputAssemblerInfo &info) override; virtual void destroy() override; void extractDrawInfo(CCMTLCmdDraw *) const; diff --git a/native/cocos/renderer/gfx-metal/MTLInputAssembler.mm b/native/cocos/renderer/gfx-metal/MTLInputAssembler.mm index 5614cf6a2a..344dff6ccc 100644 --- a/native/cocos/renderer/gfx-metal/MTLInputAssembler.mm +++ b/native/cocos/renderer/gfx-metal/MTLInputAssembler.mm @@ -8,10 +8,10 @@ namespace cc { namespace gfx { -CCMTLInputAssembler::CCMTLInputAssembler(GFXDevice *device) : GFXInputAssembler(device) {} +CCMTLInputAssembler::CCMTLInputAssembler(Device *device) : InputAssembler(device) {} CCMTLInputAssembler::~CCMTLInputAssembler() { destroy(); } -bool CCMTLInputAssembler::initialize(const GFXInputAssemblerInfo &info) { +bool CCMTLInputAssembler::initialize(const InputAssemblerInfo &info) { _attributes = info.attributes; _vertexBuffers = info.vertexBuffers; _indexBuffer = info.indexBuffer; @@ -35,14 +35,14 @@ bool CCMTLInputAssembler::initialize(const GFXInputAssemblerInfo &info) { _GPUInputAssembler->mtlVertexBufers.push_back(static_cast(vertexBuffer)->getMTLBuffer()); _attributesHash = computeAttributesHash(); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } void CCMTLInputAssembler::destroy() { CC_SAFE_DELETE(_GPUInputAssembler); - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void CCMTLInputAssembler::extractDrawInfo(CCMTLCmdDraw *cmd) const { diff --git a/native/cocos/renderer/gfx-metal/MTLPipelineLayout.cpp b/native/cocos/renderer/gfx-metal/MTLPipelineLayout.cpp index ab006cf0ea..8e8c21d679 100644 --- a/native/cocos/renderer/gfx-metal/MTLPipelineLayout.cpp +++ b/native/cocos/renderer/gfx-metal/MTLPipelineLayout.cpp @@ -4,19 +4,19 @@ namespace cc { namespace gfx { -CCMTLPipelineLayout::CCMTLPipelineLayout(GFXDevice *device) : GFXPipelineLayout(device) {} +CCMTLPipelineLayout::CCMTLPipelineLayout(Device *device) : PipelineLayout(device) {} CCMTLPipelineLayout::~CCMTLPipelineLayout() { destroy(); } -bool CCMTLPipelineLayout::initialize(const GFXPipelineLayoutInfo &info) { +bool CCMTLPipelineLayout::initialize(const PipelineLayoutInfo &info) { _layouts = info.layouts; _pushConstantsRanges = info.pushConstantsRanges; - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } void CCMTLPipelineLayout::destroy() { - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-metal/MTLPipelineLayout.h b/native/cocos/renderer/gfx-metal/MTLPipelineLayout.h index 2eb375122b..e921e172e5 100644 --- a/native/cocos/renderer/gfx-metal/MTLPipelineLayout.h +++ b/native/cocos/renderer/gfx-metal/MTLPipelineLayout.h @@ -3,12 +3,12 @@ namespace cc { namespace gfx { -class CCMTLPipelineLayout : public GFXPipelineLayout { +class CCMTLPipelineLayout : public PipelineLayout { public: - CCMTLPipelineLayout(GFXDevice *device); + CCMTLPipelineLayout(Device *device); ~CCMTLPipelineLayout(); - virtual bool initialize(const GFXPipelineLayoutInfo &info) override; + virtual bool initialize(const PipelineLayoutInfo &info) override; virtual void destroy() override; }; diff --git a/native/cocos/renderer/gfx-metal/MTLPipelineState.h b/native/cocos/renderer/gfx-metal/MTLPipelineState.h index de17e3d859..9d133c82e9 100644 --- a/native/cocos/renderer/gfx-metal/MTLPipelineState.h +++ b/native/cocos/renderer/gfx-metal/MTLPipelineState.h @@ -9,12 +9,12 @@ namespace cc { namespace gfx { -class CCMTLPipelineState : public GFXPipelineState { +class CCMTLPipelineState : public PipelineState { public: - CCMTLPipelineState(GFXDevice *device); + CCMTLPipelineState(Device *device); virtual ~CCMTLPipelineState(); - virtual bool initialize(const GFXPipelineStateInfo &info) override; + virtual bool initialize(const PipelineStateInfo &info) override; virtual void destroy() override; CC_INLINE CCMTLGPUPipelineState *getGPUPipelineState() const { return _GPUPipelieState; } diff --git a/native/cocos/renderer/gfx-metal/MTLPipelineState.mm b/native/cocos/renderer/gfx-metal/MTLPipelineState.mm index 8fdff9a31f..221502392e 100644 --- a/native/cocos/renderer/gfx-metal/MTLPipelineState.mm +++ b/native/cocos/renderer/gfx-metal/MTLPipelineState.mm @@ -16,10 +16,10 @@ namespace cc { namespace gfx { -CCMTLPipelineState::CCMTLPipelineState(GFXDevice *device) : GFXPipelineState(device) {} +CCMTLPipelineState::CCMTLPipelineState(Device *device) : PipelineState(device) {} CCMTLPipelineState::~CCMTLPipelineState() { destroy(); } -bool CCMTLPipelineState::initialize(const GFXPipelineStateInfo &info) { +bool CCMTLPipelineState::initialize(const PipelineStateInfo &info) { _primitive = info.primitive; _shader = info.shader; _inputState = info.inputState; @@ -31,10 +31,10 @@ bool CCMTLPipelineState::initialize(const GFXPipelineStateInfo &info) { _renderPass = info.renderPass; if (!createGPUPipelineState()) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; return false; } - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -50,7 +50,7 @@ void CCMTLPipelineState::destroy() { } CC_SAFE_DELETE(_GPUPipelieState); - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } bool CCMTLPipelineState::createGPUPipelineState() { @@ -216,8 +216,8 @@ void CCMTLPipelineState::setFormats(MTLRenderPipelineDescriptor *descriptor) { void CCMTLPipelineState::setBlendStates(MTLRenderPipelineDescriptor *descriptor) { //FIXME: how to handle these two attributes? - // GFXBlendState::isIndepend - // GFXBlendState::blendColor; + // BlendState::isIndepend + // BlendState::blendColor; descriptor.alphaToCoverageEnabled = _blendState.isA2C; diff --git a/native/cocos/renderer/gfx-metal/MTLQueue.h b/native/cocos/renderer/gfx-metal/MTLQueue.h index a8bac2fdb3..9ff4a3d4b0 100644 --- a/native/cocos/renderer/gfx-metal/MTLQueue.h +++ b/native/cocos/renderer/gfx-metal/MTLQueue.h @@ -8,16 +8,16 @@ namespace gfx { class CCMTLCommandPackage; -class CCMTLQueue : public GFXQueue { +class CCMTLQueue : public Queue { friend class CCMTLDevice; public: - CCMTLQueue(GFXDevice *device); + CCMTLQueue(Device *device); ~CCMTLQueue(); - virtual bool initialize(const GFXQueueInfo &info) override; + virtual bool initialize(const QueueInfo &info) override; virtual void destroy() override; - virtual void submit(const vector &cmdBuffs, GFXFence *fence) override; + virtual void submit(const vector &cmdBuffs, Fence *fence) override; private: CC_INLINE void executeCommands(const CCMTLCommandPackage *, id mtlCommandBuffer); diff --git a/native/cocos/renderer/gfx-metal/MTLQueue.mm b/native/cocos/renderer/gfx-metal/MTLQueue.mm index e9f456c687..dbff1b0740 100644 --- a/native/cocos/renderer/gfx-metal/MTLQueue.mm +++ b/native/cocos/renderer/gfx-metal/MTLQueue.mm @@ -22,15 +22,15 @@ namespace cc { namespace gfx { -CCMTLQueue::CCMTLQueue(GFXDevice *device) : GFXQueue(device) {} +CCMTLQueue::CCMTLQueue(Device *device) : Queue(device) {} CCMTLQueue::~CCMTLQueue() { destroy(); } -bool CCMTLQueue::initialize(const GFXQueueInfo &info) { +bool CCMTLQueue::initialize(const QueueInfo &info) { _type = info.type; - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; _frameBoundarySemaphore = dispatch_semaphore_create(1); _mtkView = (MTKView *)((CCMTLDevice *)_device)->getMTKView(); @@ -38,10 +38,10 @@ bool CCMTLQueue::initialize(const GFXQueueInfo &info) { } void CCMTLQueue::destroy() { - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } -void CCMTLQueue::submit(const vector &cmdBuffs, GFXFence *fence) { +void CCMTLQueue::submit(const vector &cmdBuffs, Fence *fence) { // Should remove USE_METAL aftr switch to use metal. #ifdef USE_METAL // dispatch_semaphore_wait(_frameBoundarySemaphore, DISPATCH_TIME_FOREVER); @@ -103,7 +103,7 @@ void CCMTLQueue::executeCommands(const CCMTLCommandPackage *commandPackage, idclearFlags & GFXClearFlagBit::COLOR) { + if (cmdBeginRenderPass->clearFlags & ClearFlagBit::COLOR) { auto count = isOffscreen ? cmdBeginRenderPass->clearColors.size() : 1; for (size_t slot = 0; slot < count; slot++) { @@ -118,13 +118,13 @@ void CCMTLQueue::executeCommands(const CCMTLCommandPackage *commandPackage, idclearFlags & GFXClearFlagBit::DEPTH) { + if (cmdBeginRenderPass->clearFlags & ClearFlagBit::DEPTH) { mtlRenderPassDescriptor.depthAttachment.clearDepth = cmdBeginRenderPass->clearDepth; mtlRenderPassDescriptor.depthAttachment.loadAction = MTLLoadActionClear; } else mtlRenderPassDescriptor.depthAttachment.loadAction = MTLLoadActionLoad; - if (cmdBeginRenderPass->clearFlags & GFXClearFlagBit::STENCIL) { + if (cmdBeginRenderPass->clearFlags & ClearFlagBit::STENCIL) { mtlRenderPassDescriptor.stencilAttachment.clearStencil = cmdBeginRenderPass->clearStencil; mtlRenderPassDescriptor.stencilAttachment.loadAction = MTLLoadActionClear; } else @@ -165,7 +165,7 @@ void CCMTLQueue::executeCommands(const CCMTLCommandPackage *commandPackage, id(binding.buffer)->encodeBuffer(encoder, 0, binding.binding, binding.shaderStages); - if (binding.shaderStages & GFXShaderType::VERTEX) { + if (binding.shaderStages & ShaderType::VERTEX) { if (binding.texture) [encoder setVertexTexture:static_cast(binding.texture)->getMTLTexture() atIndex:binding.binding]; @@ -175,7 +175,7 @@ void CCMTLQueue::executeCommands(const CCMTLCommandPackage *commandPackage, id(binding.texture)->getMTLTexture() atIndex:binding.binding]; @@ -195,23 +195,23 @@ void CCMTLQueue::executeCommands(const CCMTLCommandPackage *commandPackage, idvertexBufferBindingInfo) { auto index = std::get<0>(bindingInfo); auto stream = std::get<1>(bindingInfo); - static_cast(inputAssembler->_vertexBuffers[stream])->encodeBuffer(encoder, 0, index, GFXShaderType::VERTEX); + static_cast(inputAssembler->_vertexBuffers[stream])->encodeBuffer(encoder, 0, index, ShaderType::VERTEX); } } - if (cmd->dynamicStateDirty[static_cast(GFXDynamicState::VIEWPORT)]) + if (cmd->dynamicStateDirty[static_cast(DynamicState::VIEWPORT)]) [encoder setViewport:cmd->viewport]; - if (cmd->dynamicStateDirty[static_cast(GFXDynamicState::SCISSOR)]) + if (cmd->dynamicStateDirty[static_cast(DynamicState::SCISSOR)]) [encoder setScissorRect:cmd->scissorRect]; if (cmd->depthBiasEnabled) { - if (cmd->dynamicStateDirty[static_cast(GFXDynamicState::DEPTH_BIAS)]) + if (cmd->dynamicStateDirty[static_cast(DynamicState::DEPTH_BIAS)]) [encoder setDepthBias:cmd->depthBias.depthBias slopeScale:cmd->depthBias.slopeScale clamp:cmd->depthBias.clamp]; } else { [encoder setDepthBias:0 slopeScale:0 clamp:0]; } - if (cmd->dynamicStateDirty[static_cast(GFXDynamicState::BLEND_CONSTANTS)]) + if (cmd->dynamicStateDirty[static_cast(DynamicState::BLEND_CONSTANTS)]) [encoder setBlendColorRed:cmd->blendConstants.r green:cmd->blendConstants.g blue:cmd->blendConstants.b diff --git a/native/cocos/renderer/gfx-metal/MTLRenderPass.h b/native/cocos/renderer/gfx-metal/MTLRenderPass.h index 85b6acfdfa..378a40485d 100644 --- a/native/cocos/renderer/gfx-metal/MTLRenderPass.h +++ b/native/cocos/renderer/gfx-metal/MTLRenderPass.h @@ -7,14 +7,14 @@ namespace cc { namespace gfx { -class GFXTextureView; +class TextureView; -class CCMTLRenderPass : public GFXRenderPass { +class CCMTLRenderPass : public RenderPass { public: - CCMTLRenderPass(GFXDevice *device); + CCMTLRenderPass(Device *device); ~CCMTLRenderPass(); - virtual bool initialize(const GFXRenderPassInfo &info) override; + virtual bool initialize(const RenderPassInfo &info) override; virtual void destroy() override; void setColorAttachment(size_t slot, id texture, int level); diff --git a/native/cocos/renderer/gfx-metal/MTLRenderPass.mm b/native/cocos/renderer/gfx-metal/MTLRenderPass.mm index 8c2ff4af46..20e4b7d105 100644 --- a/native/cocos/renderer/gfx-metal/MTLRenderPass.mm +++ b/native/cocos/renderer/gfx-metal/MTLRenderPass.mm @@ -7,10 +7,10 @@ namespace cc { namespace gfx { -CCMTLRenderPass::CCMTLRenderPass(GFXDevice *device) : GFXRenderPass(device) {} +CCMTLRenderPass::CCMTLRenderPass(Device *device) : RenderPass(device) {} CCMTLRenderPass::~CCMTLRenderPass() { destroy(); } -bool CCMTLRenderPass::initialize(const GFXRenderPassInfo &info) { +bool CCMTLRenderPass::initialize(const RenderPassInfo &info) { _colorAttachments = info.colorAttachments; _depthStencilAttachment = info.depthStencilAttachment; @@ -30,7 +30,7 @@ bool CCMTLRenderPass::initialize(const GFXRenderPassInfo &info) { _mtlRenderPassDescriptor.stencilAttachment.storeAction = mu::toMTLStoreAction(_depthStencilAttachment.depthStoreOp); _hash = computeHash(); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -41,32 +41,32 @@ void CCMTLRenderPass::destroy() { _mtlRenderPassDescriptor = nil; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void CCMTLRenderPass::setColorAttachment(size_t slot, id texture, int level) { if (!_mtlRenderPassDescriptor) { CC_LOG_ERROR("CCMTLRenderPass: MTLRenderPassDescriptor should not be nullptr."); - _status = GFXStatus::FAILED; + _status = Status::FAILED; return; } if (_colorRenderTargetNums < slot) { CC_LOG_ERROR("CCMTLRenderPass: invalid color attachment slot %d.", slot); - _status = GFXStatus::FAILED; + _status = Status::FAILED; return; } _mtlRenderPassDescriptor.colorAttachments[slot].texture = texture; _mtlRenderPassDescriptor.colorAttachments[slot].level = level; - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; } void CCMTLRenderPass::setDepthStencilAttachment(id texture, int level) { if (!_mtlRenderPassDescriptor) { CC_LOG_ERROR("CCMTLRenderPass: MTLRenderPassDescriptor should not be nullptr."); - _status = GFXStatus::FAILED; + _status = Status::FAILED; return; } @@ -75,7 +75,7 @@ void CCMTLRenderPass::setDepthStencilAttachment(id texture, int leve _mtlRenderPassDescriptor.stencilAttachment.texture = texture; _mtlRenderPassDescriptor.stencilAttachment.level = level; - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-metal/MTLSampler.h b/native/cocos/renderer/gfx-metal/MTLSampler.h index e4b9fd1f6d..31843415b8 100644 --- a/native/cocos/renderer/gfx-metal/MTLSampler.h +++ b/native/cocos/renderer/gfx-metal/MTLSampler.h @@ -5,12 +5,12 @@ namespace cc { namespace gfx { -class CCMTLSampler : public GFXSampler { +class CCMTLSampler : public Sampler { public: - CCMTLSampler(GFXDevice *device); + CCMTLSampler(Device *device); ~CCMTLSampler(); - bool initialize(const GFXSamplerInfo &info) override; + bool initialize(const SamplerInfo &info) override; void destroy() override; CC_INLINE id getMTLSamplerState() const { return _mtlSamplerState; } diff --git a/native/cocos/renderer/gfx-metal/MTLSampler.mm b/native/cocos/renderer/gfx-metal/MTLSampler.mm index baf126d31f..ca72ebde94 100644 --- a/native/cocos/renderer/gfx-metal/MTLSampler.mm +++ b/native/cocos/renderer/gfx-metal/MTLSampler.mm @@ -9,10 +9,10 @@ namespace cc { namespace gfx { -CCMTLSampler::CCMTLSampler(GFXDevice *device) : GFXSampler(device) {} +CCMTLSampler::CCMTLSampler(Device *device) : Sampler(device) {} CCMTLSampler::~CCMTLSampler() { destroy(); } -bool CCMTLSampler::initialize(const GFXSamplerInfo &info) { +bool CCMTLSampler::initialize(const SamplerInfo &info) { _name = info.name; _minFilter = info.minFilter; _magFilter = info.magFilter; @@ -45,7 +45,7 @@ bool CCMTLSampler::initialize(const GFXSamplerInfo &info) { [descriptor release]; - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return _mtlSamplerState != nil; } @@ -56,7 +56,7 @@ void CCMTLSampler::destroy() { _mtlSamplerState = nil; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-metal/MTLShader.h b/native/cocos/renderer/gfx-metal/MTLShader.h index 060e80e9e0..fdd1459ab4 100644 --- a/native/cocos/renderer/gfx-metal/MTLShader.h +++ b/native/cocos/renderer/gfx-metal/MTLShader.h @@ -6,12 +6,12 @@ namespace cc { namespace gfx { -class CCMTLShader : public GFXShader { +class CCMTLShader : public Shader { public: - CCMTLShader(GFXDevice *device); + CCMTLShader(Device *device); ~CCMTLShader(); - virtual bool initialize(const GFXShaderInfo &info) override; + virtual bool initialize(const ShaderInfo &info) override; virtual void destroy() override; CC_INLINE id getVertMTLFunction() const { return _vertexMTLFunction; } @@ -27,7 +27,7 @@ public: #endif private: - bool createMTLFunction(const GFXShaderStage &); + bool createMTLFunction(const ShaderStage &); private: id _vertexMTLFunction = nil; diff --git a/native/cocos/renderer/gfx-metal/MTLShader.mm b/native/cocos/renderer/gfx-metal/MTLShader.mm index 8f8d9e60ef..17132eab36 100644 --- a/native/cocos/renderer/gfx-metal/MTLShader.mm +++ b/native/cocos/renderer/gfx-metal/MTLShader.mm @@ -8,10 +8,10 @@ namespace cc { namespace gfx { -CCMTLShader::CCMTLShader(GFXDevice *device) : GFXShader(device) {} +CCMTLShader::CCMTLShader(Device *device) : Shader(device) {} CCMTLShader::~CCMTLShader() { destroy(); } -bool CCMTLShader::initialize(const GFXShaderInfo &info) { +bool CCMTLShader::initialize(const ShaderInfo &info) { _name = info.name; _stages = info.stages; _attributes = info.attributes; @@ -21,12 +21,12 @@ bool CCMTLShader::initialize(const GFXShaderInfo &info) { for (const auto &stage : _stages) { if (!createMTLFunction(stage)) { destroy(); - _status = GFXStatus::FAILED; + _status = Status::FAILED; return false; } } - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; CC_LOG_INFO("%s compile succeed.", _name.c_str()); return true; } @@ -42,11 +42,11 @@ void CCMTLShader::destroy() { _fragmentMTLFunction = nil; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } -bool CCMTLShader::createMTLFunction(const GFXShaderStage &stage) { - bool isVertexShader = stage.type == GFXShaderType::VERTEX; +bool CCMTLShader::createMTLFunction(const ShaderStage &stage) { + bool isVertexShader = stage.type == ShaderType::VERTEX; id mtlDevice = id(((CCMTLDevice *)_device)->getMTLDevice()); auto mtlShader = mu::compileGLSLShader2Msl(stage.source, stage.type, @@ -64,7 +64,7 @@ bool CCMTLShader::createMTLFunction(const GFXShaderStage &stage) { return false; } - if (stage.type == GFXShaderType::VERTEX) { + if (stage.type == ShaderType::VERTEX) { _vertexMTLFunction = [library newFunctionWithName:@"main0"]; if (!_vertexMTLFunction) { [library release]; diff --git a/native/cocos/renderer/gfx-metal/MTLTexture.h b/native/cocos/renderer/gfx-metal/MTLTexture.h index 736c307fca..66cb2b04ad 100644 --- a/native/cocos/renderer/gfx-metal/MTLTexture.h +++ b/native/cocos/renderer/gfx-metal/MTLTexture.h @@ -5,30 +5,30 @@ namespace cc { namespace gfx { -class CCMTLTexture : public GFXTexture { +class CCMTLTexture : public Texture { friend class CCMTLDevice; friend class CCMTLQueue; public: - CCMTLTexture(GFXDevice *device); + CCMTLTexture(Device *device); ~CCMTLTexture(); - virtual bool initialize(const GFXTextureInfo &info) override; - virtual bool initialize(const GFXTextureViewInfo &info) override; + virtual bool initialize(const TextureInfo &info) override; + virtual bool initialize(const TextureViewInfo &info) override; virtual void destroy() override; virtual void resize(uint width, uint height) override; CC_INLINE id getMTLTexture() const { return _mtlTexture; } - CC_INLINE GFXFormat getConvertedFormat() const { return _convertedFormat; } + CC_INLINE Format getConvertedFormat() const { return _convertedFormat; } private: - void update(uint8_t *const *datas, const GFXBufferTextureCopyList ®ions); + void update(uint8_t *const *datas, const BufferTextureCopyList ®ions); bool createMTLTexture(); void generateMipmaps(); private: id _mtlTexture = nil; - GFXFormat _convertedFormat = GFXFormat::UNKNOWN; + Format _convertedFormat = Format::UNKNOWN; }; } // namespace gfx diff --git a/native/cocos/renderer/gfx-metal/MTLTexture.mm b/native/cocos/renderer/gfx-metal/MTLTexture.mm index 5e5da96d3a..44debf8849 100644 --- a/native/cocos/renderer/gfx-metal/MTLTexture.mm +++ b/native/cocos/renderer/gfx-metal/MTLTexture.mm @@ -9,19 +9,19 @@ namespace cc { namespace gfx { namespace { -uint8_t *convertData(uint8_t *source, uint length, GFXFormat type) { +uint8_t *convertData(uint8_t *source, uint length, Format type) { switch (type) { - case GFXFormat::RGB8: return mu::convertRGB8ToRGBA8(source, length); - case GFXFormat::RGB32F: return mu::convertRGB32FToRGBA32F(source, length); + case Format::RGB8: return mu::convertRGB8ToRGBA8(source, length); + case Format::RGB32F: return mu::convertRGB32FToRGBA32F(source, length); default: return source; } } } // end of namespace -CCMTLTexture::CCMTLTexture(GFXDevice *device) : GFXTexture(device) {} +CCMTLTexture::CCMTLTexture(Device *device) : Texture(device) {} CCMTLTexture::~CCMTLTexture() { destroy(); } -bool CCMTLTexture::initialize(const GFXTextureInfo &info) { +bool CCMTLTexture::initialize(const TextureInfo &info) { _type = info.type; _usage = info.usage; _format = info.format; @@ -32,45 +32,45 @@ bool CCMTLTexture::initialize(const GFXTextureInfo &info) { _mipLevel = info.mipLevel; _samples = info.samples; _flags = info.flags; - _size = GFXFormatSize(_format, _width, _height, _depth); + _size = FormatSize(_format, _width, _height, _depth); #if COCOS2D_DEBUG > 0 switch (_format) { // device feature validation - case GFXFormat::D16: - if (_device->hasFeature(GFXFeature::FORMAT_D16)) break; + case Format::D16: + if (_device->hasFeature(Feature::FORMAT_D16)) break; CC_LOG_ERROR("D16 texture format is not supported on this backend"); return false; - case GFXFormat::D16S8: - if (_device->hasFeature(GFXFeature::FORMAT_D16S8)) break; + case Format::D16S8: + if (_device->hasFeature(Feature::FORMAT_D16S8)) break; CC_LOG_WARNING("D16S8 texture format is not supported on this backend"); return false; - case GFXFormat::D24: - if (_device->hasFeature(GFXFeature::FORMAT_D24)) break; + case Format::D24: + if (_device->hasFeature(Feature::FORMAT_D24)) break; CC_LOG_WARNING("D24 texture format is not supported on this backend"); return false; - case GFXFormat::D24S8: - if (_device->hasFeature(GFXFeature::FORMAT_D24S8)) break; + case Format::D24S8: + if (_device->hasFeature(Feature::FORMAT_D24S8)) break; CC_LOG_WARNING("D24S8 texture format is not supported on this backend"); return false; - case GFXFormat::D32F: - if (_device->hasFeature(GFXFeature::FORMAT_D32F)) break; + case Format::D32F: + if (_device->hasFeature(Feature::FORMAT_D32F)) break; CC_LOG_WARNING("D32F texture format is not supported on this backend"); return false; - case GFXFormat::D32F_S8: - if (_device->hasFeature(GFXFeature::FORMAT_D32FS8)) break; + case Format::D32F_S8: + if (_device->hasFeature(Feature::FORMAT_D32FS8)) break; CC_LOG_WARNING("D32FS8 texture format is not supported on this backend"); return false; - case GFXFormat::RGB8: - if (_device->hasFeature(GFXFeature::FORMAT_RGB8)) break; + case Format::RGB8: + if (_device->hasFeature(Feature::FORMAT_RGB8)) break; CC_LOG_WARNING("RGB8 texture format is not supported on this backend"); return false; } #endif - if (_flags & GFXTextureFlags::BAKUP_BUFFER) { + if (_flags & TextureFlags::BAKUP_BUFFER) { _buffer = (uint8_t *)CC_MALLOC(_size); if (!_buffer) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CC_LOG_ERROR("CCMTLTexture: CC_MALLOC backup buffer failed."); return false; } @@ -78,19 +78,19 @@ bool CCMTLTexture::initialize(const GFXTextureInfo &info) { } if (!createMTLTexture()) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CC_LOG_ERROR("CCMTLTexture: create MTLTexture failed."); return false; } _device->getMemoryStatus().textureSize += _size; - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } -bool CCMTLTexture::initialize(const GFXTextureViewInfo &info) { +bool CCMTLTexture::initialize(const TextureViewInfo &info) { if (!info.texture) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; return false; } @@ -113,11 +113,11 @@ bool CCMTLTexture::initialize(const GFXTextureViewInfo &info) { levels:NSMakeRange(info.baseLevel, info.levelCount) slices:NSMakeRange(info.baseLayer, info.layerCount)]; if (!_mtlTexture) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; return false; } - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -160,13 +160,13 @@ bool CCMTLTexture::createMTLTexture() { descriptor.textureType = mu::toMTLTextureType(_type); descriptor.sampleCount = mu::toMTLSampleCount(_samples); descriptor.mipmapLevelCount = _mipLevel; - descriptor.arrayLength = _flags & GFXTextureFlagBit::CUBEMAP ? 1 : _arrayLayer; + descriptor.arrayLength = _flags & TextureFlagBit::CUBEMAP ? 1 : _arrayLayer; - //FIXME: should change to MTLStorageModeManaged if texture usage is GFXTextureFlags::BAKUP_BUFFER? - if (_usage & GFXTextureUsage::COLOR_ATTACHMENT || - _usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT || - _usage & GFXTextureUsage::INPUT_ATTACHMENT || - _usage & GFXTextureUsage::TRANSIENT_ATTACHMENT) { + //FIXME: should change to MTLStorageModeManaged if texture usage is TextureFlags::BAKUP_BUFFER? + if (_usage & TextureUsage::COLOR_ATTACHMENT || + _usage & TextureUsage::DEPTH_STENCIL_ATTACHMENT || + _usage & TextureUsage::INPUT_ATTACHMENT || + _usage & TextureUsage::TRANSIENT_ATTACHMENT) { descriptor.resourceOptions = MTLResourceStorageModePrivate; } @@ -188,7 +188,7 @@ void CCMTLTexture::destroy() { _mtlTexture = nil; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void CCMTLTexture::resize(uint width, uint height) { @@ -202,9 +202,9 @@ void CCMTLTexture::resize(uint width, uint height) { _width = width; _height = height; - _size = GFXFormatSize(_format, _width, _height, _depth); + _size = FormatSize(_format, _width, _height, _depth); if (!createMTLTexture()) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; _width = oldWidth; _height = oldHeight; _size = oldSize; @@ -218,11 +218,11 @@ void CCMTLTexture::resize(uint width, uint height) { } _device->getMemoryStatus().textureSize -= oldSize; - if (_flags & GFXTextureFlags::BAKUP_BUFFER) { + if (_flags & TextureFlags::BAKUP_BUFFER) { const uint8_t *oldBuffer = _buffer; uint8_t *buffer = (uint8_t *)CC_MALLOC(_size); if (!buffer) { - _status = GFXStatus::FAILED; + _status = Status::FAILED; CC_LOG_ERROR("CCMTLTexture: CC_MALLOC backup buffer failed when try to resize the texture."); return; } @@ -233,10 +233,10 @@ void CCMTLTexture::resize(uint width, uint height) { } _device->getMemoryStatus().textureSize += _size; - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; } -void CCMTLTexture::update(uint8_t *const *datas, const GFXBufferTextureCopyList ®ions) { +void CCMTLTexture::update(uint8_t *const *datas, const BufferTextureCopyList ®ions) { if (!_mtlTexture) return; @@ -291,7 +291,7 @@ void CCMTLTexture::update(uint8_t *const *datas, const GFXBufferTextureCopyList CCASSERT(false, "Unsupported MTLTextureType, metal texture update failed."); break; } - if (_flags & GFXTextureFlags::GEN_MIPMAP) + if (_flags & TextureFlags::GEN_MIPMAP) generateMipmaps(); } diff --git a/native/cocos/renderer/gfx-metal/MTLUtils.h b/native/cocos/renderer/gfx-metal/MTLUtils.h index 7e9ae1a661..14f47401a8 100644 --- a/native/cocos/renderer/gfx-metal/MTLUtils.h +++ b/native/cocos/renderer/gfx-metal/MTLUtils.h @@ -12,34 +12,34 @@ namespace cc { namespace gfx { namespace mu { -MTLResourceOptions toMTLResourseOption(GFXMemoryUsage usage); -MTLLoadAction toMTLLoadAction(GFXLoadOp op); -MTLStoreAction toMTLStoreAction(GFXStoreOp op); -MTLClearColor toMTLClearColor(const GFXColor &clearColor); -MTLVertexFormat toMTLVertexFormat(GFXFormat, bool); -MTLPixelFormat toMTLPixelFormat(GFXFormat); +MTLResourceOptions toMTLResourseOption(MemoryUsage usage); +MTLLoadAction toMTLLoadAction(LoadOp op); +MTLStoreAction toMTLStoreAction(StoreOp op); +MTLClearColor toMTLClearColor(const Color &clearColor); +MTLVertexFormat toMTLVertexFormat(Format, bool); +MTLPixelFormat toMTLPixelFormat(Format); // Because some pixel format is not supported on metal, so need to convert to supported pixel format. -GFXFormat convertGFXPixelFormat(GFXFormat); -MTLColorWriteMask toMTLColorWriteMask(GFXColorMask); -MTLBlendFactor toMTLBlendFactor(GFXBlendFactor); -MTLBlendOperation toMTLBlendOperation(GFXBlendOp); -MTLCullMode toMTLCullMode(GFXCullMode); +Format convertGFXPixelFormat(Format); +MTLColorWriteMask toMTLColorWriteMask(ColorMask); +MTLBlendFactor toMTLBlendFactor(BlendFactor); +MTLBlendOperation toMTLBlendOperation(BlendOp); +MTLCullMode toMTLCullMode(CullMode); MTLWinding toMTLWinding(bool isFrontFaceCCW); -MTLViewport toMTLViewport(const GFXViewport &); -MTLScissorRect toMTLScissorRect(const GFXRect &); -MTLTriangleFillMode toMTLTriangleFillMode(GFXPolygonMode); +MTLViewport toMTLViewport(const Viewport &); +MTLScissorRect toMTLScissorRect(const Rect &); +MTLTriangleFillMode toMTLTriangleFillMode(PolygonMode); MTLDepthClipMode toMTLDepthClipMode(bool isClip); -MTLCompareFunction toMTLCompareFunction(GFXComparisonFunc); -MTLStencilOperation toMTLStencilOperation(GFXStencilOp); -MTLPrimitiveType toMTLPrimitiveType(GFXPrimitiveMode); -MTLTextureUsage toMTLTextureUsage(GFXTextureUsage); -MTLTextureType toMTLTextureType(GFXTextureType type); -NSUInteger toMTLSampleCount(GFXSampleCount); -MTLSamplerAddressMode toMTLSamplerAddressMode(GFXAddress); -MTLSamplerBorderColor toMTLSamplerBorderColor(const GFXColor &); -MTLSamplerMinMagFilter toMTLSamplerMinMagFilter(GFXFilter); -MTLSamplerMipFilter toMTLSamplerMipFilter(GFXFilter); -String compileGLSLShader2Msl(const String &src, GFXShaderType shaderType, int maxSamplerUnits, std::unordered_map &samplerBindings); +MTLCompareFunction toMTLCompareFunction(ComparisonFunc); +MTLStencilOperation toMTLStencilOperation(StencilOp); +MTLPrimitiveType toMTLPrimitiveType(PrimitiveMode); +MTLTextureUsage toMTLTextureUsage(TextureUsage); +MTLTextureType toMTLTextureType(TextureType type); +NSUInteger toMTLSampleCount(SampleCount); +MTLSamplerAddressMode toMTLSamplerAddressMode(Address); +MTLSamplerBorderColor toMTLSamplerBorderColor(const Color &); +MTLSamplerMinMagFilter toMTLSamplerMinMagFilter(Filter); +MTLSamplerMipFilter toMTLSamplerMipFilter(Filter); +String compileGLSLShader2Msl(const String &src, ShaderType shaderType, int maxSamplerUnits, std::unordered_map &samplerBindings); uint8_t *convertRGB8ToRGBA8(uint8_t *source, uint length); uint8_t *convertRGB32FToRGBA32F(uint8_t *source, uint length); NSUInteger highestSupportedFeatureSet(id device); @@ -59,7 +59,7 @@ bool isColorBufferFloatSupported(uint family); bool isColorBufferHalfFloatSupported(uint family); bool isLinearTextureSupported(uint family); bool isIndirectCommandBufferSupported(MTLFeatureSet featureSet); -bool isDepthStencilFormatSupported(GFXFormat format, uint family); +bool isDepthStencilFormatSupported(Format format, uint family); String featureSetToString(MTLFeatureSet featureSet); } // namespace mu diff --git a/native/cocos/renderer/gfx-metal/MTLUtils.mm b/native/cocos/renderer/gfx-metal/MTLUtils.mm index ab2dd1a6f8..9fc9c6f67d 100644 --- a/native/cocos/renderer/gfx-metal/MTLUtils.mm +++ b/native/cocos/renderer/gfx-metal/MTLUtils.mm @@ -10,16 +10,16 @@ namespace cc { namespace gfx { namespace { -EShLanguage getShaderStage(GFXShaderType type) { +EShLanguage getShaderStage(ShaderType type) { switch (type) { - case GFXShaderType::VERTEX: return EShLangVertex; - case GFXShaderType::CONTROL: return EShLangTessControl; - case GFXShaderType::EVALUATION: return EShLangTessEvaluation; - case GFXShaderType::GEOMETRY: return EShLangGeometry; - case GFXShaderType::FRAGMENT: return EShLangFragment; - case GFXShaderType::COMPUTE: return EShLangCompute; + case ShaderType::VERTEX: return EShLangVertex; + case ShaderType::CONTROL: return EShLangTessControl; + case ShaderType::EVALUATION: return EShLangTessEvaluation; + case ShaderType::GEOMETRY: return EShLangGeometry; + case ShaderType::FRAGMENT: return EShLangFragment; + case ShaderType::COMPUTE: return EShLangCompute; default: { - CCASSERT(false, "Unsupported GFXShaderType, convert to EShLanguage failed."); + CCASSERT(false, "Unsupported ShaderType, convert to EShLanguage failed."); return EShLangVertex; } } @@ -49,7 +49,7 @@ glslang::EShTargetLanguageVersion getTargetVersion(int vulkanMinorVersion) { } } -const std::vector GLSL2SPIRV(GFXShaderType type, const String &source, int vulkanMinorVersion = 2) { +const std::vector GLSL2SPIRV(ShaderType type, const String &source, int vulkanMinorVersion = 2) { static bool glslangInitialized = false; if (!glslangInitialized) { glslang::InitializeProcess(); @@ -113,10 +113,10 @@ enum class GPUFamily : uint { } namespace mu { -MTLResourceOptions toMTLResourseOption(GFXMemoryUsage usage) { - if (usage & GFXMemoryUsage::HOST && usage & GFXMemoryUsage::DEVICE) +MTLResourceOptions toMTLResourseOption(MemoryUsage usage) { + if (usage & MemoryUsage::HOST && usage & MemoryUsage::DEVICE) return MTLResourceStorageModeShared; - else if (usage & GFXMemoryUsage::DEVICE) + else if (usage & MemoryUsage::DEVICE) return MTLResourceStorageModePrivate; else #if (CC_PLATFORM == CC_PLATFORM_MAC_IOS) @@ -126,61 +126,61 @@ MTLResourceOptions toMTLResourseOption(GFXMemoryUsage usage) { #endif } -MTLLoadAction toMTLLoadAction(GFXLoadOp op) { +MTLLoadAction toMTLLoadAction(LoadOp op) { switch (op) { - case GFXLoadOp::CLEAR: return MTLLoadActionClear; - case GFXLoadOp::LOAD: return MTLLoadActionLoad; - case GFXLoadOp::DISCARD: return MTLLoadActionDontCare; + case LoadOp::CLEAR: return MTLLoadActionClear; + case LoadOp::LOAD: return MTLLoadActionLoad; + case LoadOp::DISCARD: return MTLLoadActionDontCare; default: return MTLLoadActionDontCare; } } -MTLStoreAction toMTLStoreAction(GFXStoreOp op) { +MTLStoreAction toMTLStoreAction(StoreOp op) { switch (op) { - case GFXStoreOp::STORE: return MTLStoreActionStore; - case GFXStoreOp::DISCARD: return MTLStoreActionDontCare; + case StoreOp::STORE: return MTLStoreActionStore; + case StoreOp::DISCARD: return MTLStoreActionDontCare; default: return MTLStoreActionDontCare; } } -MTLClearColor toMTLClearColor(const GFXColor &clearColor) { +MTLClearColor toMTLClearColor(const Color &clearColor) { MTLClearColor mtlColor; mtlColor = MTLClearColorMake(clearColor.r, clearColor.g, clearColor.b, clearColor.a); return MTLClearColorMake(clearColor.r, clearColor.g, clearColor.b, clearColor.a); } -MTLVertexFormat toMTLVertexFormat(GFXFormat format, bool isNormalized) { +MTLVertexFormat toMTLVertexFormat(Format format, bool isNormalized) { switch (format) { - case GFXFormat::R32F: return MTLVertexFormatFloat; - case GFXFormat::R32I: return MTLVertexFormatInt; - case GFXFormat::R32UI: return MTLVertexFormatUInt; - case GFXFormat::RG8: return isNormalized ? MTLVertexFormatUChar2Normalized : MTLVertexFormatUChar2; - case GFXFormat::RG8I: return isNormalized ? MTLVertexFormatChar2Normalized : MTLVertexFormatChar2; - case GFXFormat::RG16F: return MTLVertexFormatHalf2; - case GFXFormat::RG16UI: return isNormalized ? MTLVertexFormatUShort2Normalized : MTLVertexFormatUShort2; - case GFXFormat::RG16I: return isNormalized ? MTLVertexFormatShort2Normalized : MTLVertexFormatShort2; - case GFXFormat::RG32I: return MTLVertexFormatInt2; - case GFXFormat::RG32UI: return MTLVertexFormatUInt2; - case GFXFormat::RG32F: return MTLVertexFormatFloat2; - case GFXFormat::RGB8: return isNormalized ? MTLVertexFormatUChar3Normalized : MTLVertexFormatUChar3; - case GFXFormat::RGB8I: return isNormalized ? MTLVertexFormatChar3Normalized : MTLVertexFormatChar3; - case GFXFormat::RGB16I: return isNormalized ? MTLVertexFormatShort3Normalized : MTLVertexFormatShort3; - case GFXFormat::RGB16UI: return isNormalized ? MTLVertexFormatUShort3Normalized : MTLVertexFormatUShort3; - case GFXFormat::RGB16F: return MTLVertexFormatHalf3; - case GFXFormat::RGB32I: return MTLVertexFormatInt3; - case GFXFormat::RGB32UI: return MTLVertexFormatUInt3; - case GFXFormat::RGB32F: return MTLVertexFormatFloat3; - case GFXFormat::RGBA8: return isNormalized ? MTLVertexFormatUChar4Normalized : MTLVertexFormatUChar4; - case GFXFormat::RGBA8I: return isNormalized ? MTLVertexFormatChar4Normalized : MTLVertexFormatChar4; - case GFXFormat::RGBA16I: return isNormalized ? MTLVertexFormatShort4Normalized : MTLVertexFormatShort4; - case GFXFormat::RGBA16UI: return isNormalized ? MTLVertexFormatUShort4Normalized : MTLVertexFormatUShort4; - case GFXFormat::RGBA16F: return MTLVertexFormatHalf4; - case GFXFormat::RGBA32I: return MTLVertexFormatInt4; - case GFXFormat::RGBA32UI: return MTLVertexFormatUInt4; - case GFXFormat::RGBA32F: return MTLVertexFormatFloat4; - case GFXFormat::RGB10A2: return isNormalized ? MTLVertexFormatInt1010102Normalized : MTLVertexFormatInvalid; - case GFXFormat::RGB10A2UI: return isNormalized ? MTLVertexFormatUInt1010102Normalized : MTLVertexFormatInvalid; - case GFXFormat::BGRA8: { + case Format::R32F: return MTLVertexFormatFloat; + case Format::R32I: return MTLVertexFormatInt; + case Format::R32UI: return MTLVertexFormatUInt; + case Format::RG8: return isNormalized ? MTLVertexFormatUChar2Normalized : MTLVertexFormatUChar2; + case Format::RG8I: return isNormalized ? MTLVertexFormatChar2Normalized : MTLVertexFormatChar2; + case Format::RG16F: return MTLVertexFormatHalf2; + case Format::RG16UI: return isNormalized ? MTLVertexFormatUShort2Normalized : MTLVertexFormatUShort2; + case Format::RG16I: return isNormalized ? MTLVertexFormatShort2Normalized : MTLVertexFormatShort2; + case Format::RG32I: return MTLVertexFormatInt2; + case Format::RG32UI: return MTLVertexFormatUInt2; + case Format::RG32F: return MTLVertexFormatFloat2; + case Format::RGB8: return isNormalized ? MTLVertexFormatUChar3Normalized : MTLVertexFormatUChar3; + case Format::RGB8I: return isNormalized ? MTLVertexFormatChar3Normalized : MTLVertexFormatChar3; + case Format::RGB16I: return isNormalized ? MTLVertexFormatShort3Normalized : MTLVertexFormatShort3; + case Format::RGB16UI: return isNormalized ? MTLVertexFormatUShort3Normalized : MTLVertexFormatUShort3; + case Format::RGB16F: return MTLVertexFormatHalf3; + case Format::RGB32I: return MTLVertexFormatInt3; + case Format::RGB32UI: return MTLVertexFormatUInt3; + case Format::RGB32F: return MTLVertexFormatFloat3; + case Format::RGBA8: return isNormalized ? MTLVertexFormatUChar4Normalized : MTLVertexFormatUChar4; + case Format::RGBA8I: return isNormalized ? MTLVertexFormatChar4Normalized : MTLVertexFormatChar4; + case Format::RGBA16I: return isNormalized ? MTLVertexFormatShort4Normalized : MTLVertexFormatShort4; + case Format::RGBA16UI: return isNormalized ? MTLVertexFormatUShort4Normalized : MTLVertexFormatUShort4; + case Format::RGBA16F: return MTLVertexFormatHalf4; + case Format::RGBA32I: return MTLVertexFormatInt4; + case Format::RGBA32UI: return MTLVertexFormatUInt4; + case Format::RGBA32F: return MTLVertexFormatFloat4; + case Format::RGB10A2: return isNormalized ? MTLVertexFormatInt1010102Normalized : MTLVertexFormatInvalid; + case Format::RGB10A2UI: return isNormalized ? MTLVertexFormatUInt1010102Normalized : MTLVertexFormatInvalid; + case Format::BGRA8: { #if CC_PLATFORM == CC_PLATFORM_MAC_IOS if (@available(iOS 11.0, *)) { if (isNormalized) { @@ -208,73 +208,73 @@ MTLVertexFormat toMTLVertexFormat(GFXFormat format, bool isNormalized) { } } -GFXFormat convertGFXPixelFormat(GFXFormat format) { +Format convertGFXPixelFormat(Format format) { switch (format) { - case GFXFormat::RGB8: return GFXFormat::RGBA8; - case GFXFormat::RGB32F: return GFXFormat::RGBA32F; + case Format::RGB8: return Format::RGBA8; + case Format::RGB32F: return Format::RGBA32F; default: return format; } } -MTLPixelFormat toMTLPixelFormat(GFXFormat format) { +MTLPixelFormat toMTLPixelFormat(Format format) { switch (format) { - case GFXFormat::A8: return MTLPixelFormatA8Unorm; - case GFXFormat::R8: return MTLPixelFormatR8Uint; - case GFXFormat::R8SN: return MTLPixelFormatR8Snorm; - case GFXFormat::R8UI: return MTLPixelFormatR8Uint; - case GFXFormat::R16F: return MTLPixelFormatR16Float; - case GFXFormat::R32F: return MTLPixelFormatR32Float; - case GFXFormat::R32UI: return MTLPixelFormatR32Uint; - case GFXFormat::R32I: return MTLPixelFormatR32Sint; + case Format::A8: return MTLPixelFormatA8Unorm; + case Format::R8: return MTLPixelFormatR8Uint; + case Format::R8SN: return MTLPixelFormatR8Snorm; + case Format::R8UI: return MTLPixelFormatR8Uint; + case Format::R16F: return MTLPixelFormatR16Float; + case Format::R32F: return MTLPixelFormatR32Float; + case Format::R32UI: return MTLPixelFormatR32Uint; + case Format::R32I: return MTLPixelFormatR32Sint; - case GFXFormat::RG8: return MTLPixelFormatRG8Unorm; - case GFXFormat::RG8SN: return MTLPixelFormatRG8Snorm; - case GFXFormat::RG8UI: return MTLPixelFormatRG8Uint; - case GFXFormat::RG8I: return MTLPixelFormatRG8Sint; - case GFXFormat::RG16F: return MTLPixelFormatRG16Float; - case GFXFormat::RG16UI: return MTLPixelFormatRG16Uint; - case GFXFormat::RG16I: + case Format::RG8: return MTLPixelFormatRG8Unorm; + case Format::RG8SN: return MTLPixelFormatRG8Snorm; + case Format::RG8UI: return MTLPixelFormatRG8Uint; + case Format::RG8I: return MTLPixelFormatRG8Sint; + case Format::RG16F: return MTLPixelFormatRG16Float; + case Format::RG16UI: return MTLPixelFormatRG16Uint; + case Format::RG16I: return MTLPixelFormatRG16Sint; - // case GFXFormat::RGB8SN: return MTLPixelFormatRGBA8Snorm; - // case GFXFormat::RGB8UI: return MTLPixelFormatRGBA8Uint; - // case GFXFormat::RGB8I: return MTLPixelFormatRGBA8Sint; - // case GFXFormat::RGB16F: return MTLPixelFormatRGBA16Float; - // case GFXFormat::RGB16UI: return MTLPixelFormatRGBA16Uint; - // case GFXFormat::RGB16I: return MTLPixelFormatRGBA16Sint; - // case GFXFormat::RGB32F: return MTLPixelFormatRGBA32Float; - // case GFXFormat::RGB32UI: return MTLPixelFormatRGBA32Uint; - // case GFXFormat::RGB32I: return MTLPixelFormatRGBA32Sint; + // case Format::RGB8SN: return MTLPixelFormatRGBA8Snorm; + // case Format::RGB8UI: return MTLPixelFormatRGBA8Uint; + // case Format::RGB8I: return MTLPixelFormatRGBA8Sint; + // case Format::RGB16F: return MTLPixelFormatRGBA16Float; + // case Format::RGB16UI: return MTLPixelFormatRGBA16Uint; + // case Format::RGB16I: return MTLPixelFormatRGBA16Sint; + // case Format::RGB32F: return MTLPixelFormatRGBA32Float; + // case Format::RGB32UI: return MTLPixelFormatRGBA32Uint; + // case Format::RGB32I: return MTLPixelFormatRGBA32Sint; - case GFXFormat::RGBA8: return MTLPixelFormatRGBA8Unorm; - case GFXFormat::RGBA8SN: return MTLPixelFormatRGBA8Snorm; - case GFXFormat::RGBA8UI: return MTLPixelFormatRGBA8Uint; - case GFXFormat::RGBA8I: return MTLPixelFormatRGBA8Sint; - case GFXFormat::RGBA16F: return MTLPixelFormatRGBA16Float; - case GFXFormat::RGBA16UI: return MTLPixelFormatRGBA16Uint; - case GFXFormat::RGBA16I: return MTLPixelFormatRGBA16Sint; - case GFXFormat::RGBA32F: return MTLPixelFormatRGBA32Float; - case GFXFormat::RGBA32UI: return MTLPixelFormatRGBA32Uint; - case GFXFormat::RGBA32I: return MTLPixelFormatRGBA32Sint; - case GFXFormat::BGRA8: + case Format::RGBA8: return MTLPixelFormatRGBA8Unorm; + case Format::RGBA8SN: return MTLPixelFormatRGBA8Snorm; + case Format::RGBA8UI: return MTLPixelFormatRGBA8Uint; + case Format::RGBA8I: return MTLPixelFormatRGBA8Sint; + case Format::RGBA16F: return MTLPixelFormatRGBA16Float; + case Format::RGBA16UI: return MTLPixelFormatRGBA16Uint; + case Format::RGBA16I: return MTLPixelFormatRGBA16Sint; + case Format::RGBA32F: return MTLPixelFormatRGBA32Float; + case Format::RGBA32UI: return MTLPixelFormatRGBA32Uint; + case Format::RGBA32I: return MTLPixelFormatRGBA32Sint; + case Format::BGRA8: return MTLPixelFormatBGRA8Unorm; // Should convert. - // case GFXFormat::R5G6B5: return MTLPixelFormatB5G6R5Unorm; - // case GFXFormat::RGB5A1: return MTLPixelFormatBGR5A1Unorm; - // case GFXFormat::RGBA4: return MTLPixelFormatABGR4Unorm; - // case GFXFormat::RGB10A2: return MTLPixelFormatBGR10A2Unorm; - case GFXFormat::RGB9E5: return MTLPixelFormatRGB9E5Float; - case GFXFormat::RGB10A2UI: return MTLPixelFormatRGB10A2Uint; - case GFXFormat::R11G11B10F: return MTLPixelFormatRG11B10Float; + // case Format::R5G6B5: return MTLPixelFormatB5G6R5Unorm; + // case Format::RGB5A1: return MTLPixelFormatBGR5A1Unorm; + // case Format::RGBA4: return MTLPixelFormatABGR4Unorm; + // case Format::RGB10A2: return MTLPixelFormatBGR10A2Unorm; + case Format::RGB9E5: return MTLPixelFormatRGB9E5Float; + case Format::RGB10A2UI: return MTLPixelFormatRGB10A2Uint; + case Format::R11G11B10F: return MTLPixelFormatRG11B10Float; - case GFXFormat::D16: return MTLPixelFormatDepth16Unorm; - case GFXFormat::D24S8: return MTLPixelFormatDepth24Unorm_Stencil8; - case GFXFormat::D32F: return MTLPixelFormatDepth32Float; - case GFXFormat::D32F_S8: return MTLPixelFormatDepth32Float_Stencil8; + case Format::D16: return MTLPixelFormatDepth16Unorm; + case Format::D24S8: return MTLPixelFormatDepth24Unorm_Stencil8; + case Format::D32F: return MTLPixelFormatDepth32Float; + case Format::D32F_S8: return MTLPixelFormatDepth32Float_Stencil8; - case GFXFormat::BC1_ALPHA: return MTLPixelFormatBC1_RGBA; - case GFXFormat::BC1_SRGB_ALPHA: return MTLPixelFormatBC1_RGBA_sRGB; + case Format::BC1_ALPHA: return MTLPixelFormatBC1_RGBA; + case Format::BC1_SRGB_ALPHA: return MTLPixelFormatBC1_RGBA_sRGB; default: { CC_LOG_ERROR("Invalid pixel format %u", format); @@ -283,30 +283,30 @@ MTLPixelFormat toMTLPixelFormat(GFXFormat format) { } } -MTLColorWriteMask toMTLColorWriteMask(GFXColorMask mask) { +MTLColorWriteMask toMTLColorWriteMask(ColorMask mask) { switch (mask) { - case GFXColorMask::R: return MTLColorWriteMaskRed; - case GFXColorMask::G: return MTLColorWriteMaskGreen; - case GFXColorMask::B: return MTLColorWriteMaskBlue; - case GFXColorMask::A: return MTLColorWriteMaskAlpha; - case GFXColorMask::ALL: return MTLColorWriteMaskAll; + case ColorMask::R: return MTLColorWriteMaskRed; + case ColorMask::G: return MTLColorWriteMaskGreen; + case ColorMask::B: return MTLColorWriteMaskBlue; + case ColorMask::A: return MTLColorWriteMaskAlpha; + case ColorMask::ALL: return MTLColorWriteMaskAll; default: return MTLColorWriteMaskNone; } } -MTLBlendFactor toMTLBlendFactor(GFXBlendFactor factor) { +MTLBlendFactor toMTLBlendFactor(BlendFactor factor) { switch (factor) { - case GFXBlendFactor::ZERO: return MTLBlendFactorZero; - case GFXBlendFactor::ONE: return MTLBlendFactorOne; - case GFXBlendFactor::SRC_ALPHA: return MTLBlendFactorSourceAlpha; - case GFXBlendFactor::DST_ALPHA: return MTLBlendFactorDestinationAlpha; - case GFXBlendFactor::ONE_MINUS_SRC_ALPHA: return MTLBlendFactorOneMinusSourceAlpha; - case GFXBlendFactor::ONE_MINUS_DST_ALPHA: return MTLBlendFactorOneMinusDestinationAlpha; - case GFXBlendFactor::SRC_COLOR: return MTLBlendFactorSourceColor; - case GFXBlendFactor::DST_COLOR: return MTLBlendFactorDestinationColor; - case GFXBlendFactor::ONE_MINUS_SRC_COLOR: return MTLBlendFactorOneMinusSourceColor; - case GFXBlendFactor::ONE_MINUS_DST_COLOR: return MTLBlendFactorOneMinusDestinationColor; - case GFXBlendFactor::SRC_ALPHA_SATURATE: return MTLBlendFactorSourceAlphaSaturated; + case BlendFactor::ZERO: return MTLBlendFactorZero; + case BlendFactor::ONE: return MTLBlendFactorOne; + case BlendFactor::SRC_ALPHA: return MTLBlendFactorSourceAlpha; + case BlendFactor::DST_ALPHA: return MTLBlendFactorDestinationAlpha; + case BlendFactor::ONE_MINUS_SRC_ALPHA: return MTLBlendFactorOneMinusSourceAlpha; + case BlendFactor::ONE_MINUS_DST_ALPHA: return MTLBlendFactorOneMinusDestinationAlpha; + case BlendFactor::SRC_COLOR: return MTLBlendFactorSourceColor; + case BlendFactor::DST_COLOR: return MTLBlendFactorDestinationColor; + case BlendFactor::ONE_MINUS_SRC_COLOR: return MTLBlendFactorOneMinusSourceColor; + case BlendFactor::ONE_MINUS_DST_COLOR: return MTLBlendFactorOneMinusDestinationColor; + case BlendFactor::SRC_ALPHA_SATURATE: return MTLBlendFactorSourceAlphaSaturated; default: { CC_LOG_ERROR("Unsupported blend factor %u", (uint)factor); return MTLBlendFactorZero; @@ -314,21 +314,21 @@ MTLBlendFactor toMTLBlendFactor(GFXBlendFactor factor) { } } -MTLBlendOperation toMTLBlendOperation(GFXBlendOp op) { +MTLBlendOperation toMTLBlendOperation(BlendOp op) { switch (op) { - case GFXBlendOp::ADD: return MTLBlendOperationAdd; - case GFXBlendOp::SUB: return MTLBlendOperationSubtract; - case GFXBlendOp::REV_SUB: return MTLBlendOperationReverseSubtract; - case GFXBlendOp::MIN: return MTLBlendOperationMin; - case GFXBlendOp::MAX: return MTLBlendOperationMax; + case BlendOp::ADD: return MTLBlendOperationAdd; + case BlendOp::SUB: return MTLBlendOperationSubtract; + case BlendOp::REV_SUB: return MTLBlendOperationReverseSubtract; + case BlendOp::MIN: return MTLBlendOperationMin; + case BlendOp::MAX: return MTLBlendOperationMax; } } -MTLCullMode toMTLCullMode(GFXCullMode mode) { +MTLCullMode toMTLCullMode(CullMode mode) { switch (mode) { - case GFXCullMode::FRONT: return MTLCullModeFront; - case GFXCullMode::BACK: return MTLCullModeBack; - case GFXCullMode::NONE: return MTLCullModeNone; + case CullMode::FRONT: return MTLCullModeFront; + case CullMode::BACK: return MTLCullModeBack; + case CullMode::NONE: return MTLCullModeNone; } } @@ -339,7 +339,7 @@ MTLWinding toMTLWinding(bool isFrontFaceCCW) { return MTLWindingClockwise; } -MTLViewport toMTLViewport(const GFXViewport &viewport) { +MTLViewport toMTLViewport(const Viewport &viewport) { MTLViewport mtlViewport; mtlViewport.originX = viewport.left; mtlViewport.originY = viewport.top; @@ -351,7 +351,7 @@ MTLViewport toMTLViewport(const GFXViewport &viewport) { return mtlViewport; } -MTLScissorRect toMTLScissorRect(const GFXRect &rect) { +MTLScissorRect toMTLScissorRect(const Rect &rect) { MTLScissorRect scissorRect; scissorRect.x = rect.x; scissorRect.y = rect.y; @@ -361,12 +361,12 @@ MTLScissorRect toMTLScissorRect(const GFXRect &rect) { return scissorRect; } -MTLTriangleFillMode toMTLTriangleFillMode(GFXPolygonMode mode) { +MTLTriangleFillMode toMTLTriangleFillMode(PolygonMode mode) { switch (mode) { - case GFXPolygonMode::FILL: return MTLTriangleFillModeFill; - case GFXPolygonMode::LINE: return MTLTriangleFillModeLines; - case GFXPolygonMode::POINT: { - CC_LOG_WARNING("Metal doesn't support GFXPolygonMode::POINT, translate to GFXPolygonMode::LINE."); + case PolygonMode::FILL: return MTLTriangleFillModeFill; + case PolygonMode::LINE: return MTLTriangleFillModeLines; + case PolygonMode::POINT: { + CC_LOG_WARNING("Metal doesn't support PolygonMode::POINT, translate to PolygonMode::LINE."); return MTLTriangleFillModeLines; } } @@ -379,42 +379,42 @@ MTLDepthClipMode toMTLDepthClipMode(bool isClip) { return MTLDepthClipModeClamp; } -MTLCompareFunction toMTLCompareFunction(GFXComparisonFunc func) { +MTLCompareFunction toMTLCompareFunction(ComparisonFunc func) { switch (func) { - case GFXComparisonFunc::NEVER: return MTLCompareFunctionNever; - case GFXComparisonFunc::LESS: return MTLCompareFunctionLess; - case GFXComparisonFunc::EQUAL: return MTLCompareFunctionEqual; - case GFXComparisonFunc::LESS_EQUAL: return MTLCompareFunctionLessEqual; - case GFXComparisonFunc::GREATER: return MTLCompareFunctionGreater; - case GFXComparisonFunc::NOT_EQUAL: return MTLCompareFunctionNotEqual; - case GFXComparisonFunc::GREATER_EQUAL: return MTLCompareFunctionGreaterEqual; - case GFXComparisonFunc::ALWAYS: return MTLCompareFunctionAlways; + case ComparisonFunc::NEVER: return MTLCompareFunctionNever; + case ComparisonFunc::LESS: return MTLCompareFunctionLess; + case ComparisonFunc::EQUAL: return MTLCompareFunctionEqual; + case ComparisonFunc::LESS_EQUAL: return MTLCompareFunctionLessEqual; + case ComparisonFunc::GREATER: return MTLCompareFunctionGreater; + case ComparisonFunc::NOT_EQUAL: return MTLCompareFunctionNotEqual; + case ComparisonFunc::GREATER_EQUAL: return MTLCompareFunctionGreaterEqual; + case ComparisonFunc::ALWAYS: return MTLCompareFunctionAlways; } } -MTLStencilOperation toMTLStencilOperation(GFXStencilOp op) { +MTLStencilOperation toMTLStencilOperation(StencilOp op) { switch (op) { - case GFXStencilOp::ZERO: return MTLStencilOperationZero; - case GFXStencilOp::KEEP: return MTLStencilOperationKeep; - case GFXStencilOp::REPLACE: return MTLStencilOperationReplace; - case GFXStencilOp::INCR: return MTLStencilOperationIncrementClamp; - case GFXStencilOp::DECR: return MTLStencilOperationDecrementClamp; - case GFXStencilOp::INVERT: return MTLStencilOperationInvert; - case GFXStencilOp::INCR_WRAP: return MTLStencilOperationIncrementWrap; - case GFXStencilOp::DECR_WRAP: return MTLStencilOperationDecrementWrap; + case StencilOp::ZERO: return MTLStencilOperationZero; + case StencilOp::KEEP: return MTLStencilOperationKeep; + case StencilOp::REPLACE: return MTLStencilOperationReplace; + case StencilOp::INCR: return MTLStencilOperationIncrementClamp; + case StencilOp::DECR: return MTLStencilOperationDecrementClamp; + case StencilOp::INVERT: return MTLStencilOperationInvert; + case StencilOp::INCR_WRAP: return MTLStencilOperationIncrementWrap; + case StencilOp::DECR_WRAP: return MTLStencilOperationDecrementWrap; } } -MTLPrimitiveType toMTLPrimitiveType(GFXPrimitiveMode mode) { +MTLPrimitiveType toMTLPrimitiveType(PrimitiveMode mode) { switch (mode) { - case GFXPrimitiveMode::POINT_LIST: return MTLPrimitiveTypePoint; - case GFXPrimitiveMode::LINE_LIST: return MTLPrimitiveTypeLine; - case GFXPrimitiveMode::LINE_STRIP: return MTLPrimitiveTypeLineStrip; - case GFXPrimitiveMode::TRIANGLE_LIST: return MTLPrimitiveTypeTriangle; - case GFXPrimitiveMode::TRIANGLE_STRIP: return MTLPrimitiveTypeTriangleStrip; + case PrimitiveMode::POINT_LIST: return MTLPrimitiveTypePoint; + case PrimitiveMode::LINE_LIST: return MTLPrimitiveTypeLine; + case PrimitiveMode::LINE_STRIP: return MTLPrimitiveTypeLineStrip; + case PrimitiveMode::TRIANGLE_LIST: return MTLPrimitiveTypeTriangle; + case PrimitiveMode::TRIANGLE_STRIP: return MTLPrimitiveTypeTriangleStrip; - case GFXPrimitiveMode::LINE_LOOP: { - CC_LOG_ERROR("Metal doesn't support GFXPrimitiveMode::LINE_LOOP. Translate to GFXPrimitiveMode::LINE_LIST."); + case PrimitiveMode::LINE_LOOP: { + CC_LOG_ERROR("Metal doesn't support PrimitiveMode::LINE_LOOP. Translate to PrimitiveMode::LINE_LIST."); return MTLPrimitiveTypeLine; } default: { @@ -425,62 +425,62 @@ MTLPrimitiveType toMTLPrimitiveType(GFXPrimitiveMode mode) { } } -MTLTextureUsage toMTLTextureUsage(GFXTextureUsage usage) { - if (usage == GFXTextureUsage::NONE) +MTLTextureUsage toMTLTextureUsage(TextureUsage usage) { + if (usage == TextureUsage::NONE) return MTLTextureUsageUnknown; MTLTextureUsage ret = MTLTextureUsageUnknown; - if (usage & GFXTextureUsage::TRANSFER_SRC) + if (usage & TextureUsage::TRANSFER_SRC) ret |= MTLTextureUsageShaderRead; - if (usage & GFXTextureUsage::TRANSFER_DST) + if (usage & TextureUsage::TRANSFER_DST) ret |= MTLTextureUsageShaderWrite; - if (usage & GFXTextureUsage::SAMPLED) + if (usage & TextureUsage::SAMPLED) ret |= MTLTextureUsageShaderRead; - if (usage & GFXTextureUsage::STORAGE) + if (usage & TextureUsage::STORAGE) ret |= MTLTextureUsageShaderWrite; - if (usage & GFXTextureUsage::COLOR_ATTACHMENT || - usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT || - usage & GFXTextureUsage::TRANSIENT_ATTACHMENT || - usage & GFXTextureUsage::INPUT_ATTACHMENT) { + if (usage & TextureUsage::COLOR_ATTACHMENT || + usage & TextureUsage::DEPTH_STENCIL_ATTACHMENT || + usage & TextureUsage::TRANSIENT_ATTACHMENT || + usage & TextureUsage::INPUT_ATTACHMENT) { ret |= MTLTextureUsageRenderTarget; } return ret; } -MTLTextureType toMTLTextureType(GFXTextureType type) { +MTLTextureType toMTLTextureType(TextureType type) { switch (type) { - case GFXTextureType::TEX1D: return MTLTextureType1D; - case GFXTextureType::TEX2D: return MTLTextureType2D; - case GFXTextureType::TEX3D: return MTLTextureType3D; - case GFXTextureType::CUBE: return MTLTextureTypeCube; - case GFXTextureType::TEX1D_ARRAY: return MTLTextureType1DArray; - case GFXTextureType::TEX2D_ARRAY: return MTLTextureType2DArray; + case TextureType::TEX1D: return MTLTextureType1D; + case TextureType::TEX2D: return MTLTextureType2D; + case TextureType::TEX3D: return MTLTextureType3D; + case TextureType::CUBE: return MTLTextureTypeCube; + case TextureType::TEX1D_ARRAY: return MTLTextureType1DArray; + case TextureType::TEX2D_ARRAY: return MTLTextureType2DArray; } } -NSUInteger toMTLSampleCount(GFXSampleCount count) { +NSUInteger toMTLSampleCount(SampleCount count) { switch (count) { - case GFXSampleCount::X1: return 1; - case GFXSampleCount::X2: return 2; - case GFXSampleCount::X4: return 4; - case GFXSampleCount::X8: return 8; - case GFXSampleCount::X16: return 16; - case GFXSampleCount::X32: return 32; - case GFXSampleCount::X64: return 64; + case SampleCount::X1: return 1; + case SampleCount::X2: return 2; + case SampleCount::X4: return 4; + case SampleCount::X8: return 8; + case SampleCount::X16: return 16; + case SampleCount::X32: return 32; + case SampleCount::X64: return 64; } } -MTLSamplerAddressMode toMTLSamplerAddressMode(GFXAddress mode) { +MTLSamplerAddressMode toMTLSamplerAddressMode(Address mode) { switch (mode) { - case GFXAddress::WRAP: return MTLSamplerAddressModeRepeat; - case GFXAddress::MIRROR: return MTLSamplerAddressModeMirrorRepeat; - case GFXAddress::CLAMP: return MTLSamplerAddressModeClampToEdge; - case GFXAddress::BORDER: return MTLSamplerAddressModeClampToBorderColor; + case Address::WRAP: return MTLSamplerAddressModeRepeat; + case Address::MIRROR: return MTLSamplerAddressModeMirrorRepeat; + case Address::CLAMP: return MTLSamplerAddressModeClampToEdge; + case Address::BORDER: return MTLSamplerAddressModeClampToBorderColor; } } -MTLSamplerBorderColor toMTLSamplerBorderColor(const GFXColor &color) { +MTLSamplerBorderColor toMTLSamplerBorderColor(const Color &color) { float diff = color.r - 0.5f; if (math::IsEqualF(color.a, 0.f)) return MTLSamplerBorderColorTransparentBlack; @@ -490,28 +490,28 @@ MTLSamplerBorderColor toMTLSamplerBorderColor(const GFXColor &color) { return MTLSamplerBorderColorOpaqueWhite; } -MTLSamplerMinMagFilter toMTLSamplerMinMagFilter(GFXFilter filter) { +MTLSamplerMinMagFilter toMTLSamplerMinMagFilter(Filter filter) { switch (filter) { - case GFXFilter::LINEAR: - case GFXFilter::ANISOTROPIC: + case Filter::LINEAR: + case Filter::ANISOTROPIC: return MTLSamplerMinMagFilterLinear; default: return MTLSamplerMinMagFilterNearest; } } -MTLSamplerMipFilter toMTLSamplerMipFilter(GFXFilter filter) { +MTLSamplerMipFilter toMTLSamplerMipFilter(Filter filter) { switch (filter) { - case GFXFilter::NONE: return MTLSamplerMipFilterNotMipmapped; - case GFXFilter::LINEAR: - case GFXFilter::ANISOTROPIC: + case Filter::NONE: return MTLSamplerMipFilterNotMipmapped; + case Filter::LINEAR: + case Filter::ANISOTROPIC: return MTLSamplerMipFilterLinear; - case GFXFilter::POINT: return MTLSamplerMipFilterNearest; + case Filter::POINT: return MTLSamplerMipFilterNearest; } } String compileGLSLShader2Msl(const String &src, - GFXShaderType shaderType, + ShaderType shaderType, int maxSamplerUnits, std::unordered_map &samplerBindings) { #if USE_METAL @@ -1097,10 +1097,10 @@ bool isIndirectCommandBufferSupported(MTLFeatureSet featureSet) { #endif return false; } -bool isDepthStencilFormatSupported(GFXFormat format, uint family) { +bool isDepthStencilFormatSupported(Format format, uint family) { GPUFamily gpuFamily = static_cast(family); switch (format) { - case GFXFormat::D16: + case Format::D16: switch (gpuFamily) { case GPUFamily::Apple1: case GPUFamily::Apple2: @@ -1114,8 +1114,8 @@ bool isDepthStencilFormatSupported(GFXFormat format, uint family) { default: return false; } - case GFXFormat::D32F: - case GFXFormat::D32F_S8: + case Format::D32F: + case Format::D32F_S8: switch (gpuFamily) { case GPUFamily::Apple1: case GPUFamily::Apple2: diff --git a/native/cocos/renderer/gfx-vulkan/VKBindingLayout.cc b/native/cocos/renderer/gfx-vulkan/VKBindingLayout.cc index 48f3f600b4..adefa2edc5 100644 --- a/native/cocos/renderer/gfx-vulkan/VKBindingLayout.cc +++ b/native/cocos/renderer/gfx-vulkan/VKBindingLayout.cc @@ -10,19 +10,19 @@ namespace cc { namespace gfx { -CCVKBindingLayout::CCVKBindingLayout(GFXDevice *device) -: GFXBindingLayout(device) { +CCVKBindingLayout::CCVKBindingLayout(Device *device) +: BindingLayout(device) { } CCVKBindingLayout::~CCVKBindingLayout() { } -bool CCVKBindingLayout::initialize(const GFXBindingLayoutInfo &info) { +bool CCVKBindingLayout::initialize(const BindingLayoutInfo &info) { if (info.bindings.size()) { _bindingUnits.resize(info.bindings.size()); for (size_t i = 0u; i < _bindingUnits.size(); ++i) { - GFXBindingUnit &bindingUnit = _bindingUnits[i]; - const GFXBinding &binding = info.bindings[i]; + BindingUnit &bindingUnit = _bindingUnits[i]; + const Binding &binding = info.bindings[i]; bindingUnit.binding = binding.binding; bindingUnit.type = binding.type; bindingUnit.name = binding.name; @@ -34,7 +34,7 @@ bool CCVKBindingLayout::initialize(const GFXBindingLayoutInfo &info) { _gpuBindingLayout = CC_NEW(CCVKGPUBindingLayout); CCVKCmdFuncCreateBindingLayout((CCVKDevice *)_device, _gpuBindingLayout, _bindingUnits); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -46,17 +46,17 @@ void CCVKBindingLayout::destroy() { _gpuBindingLayout = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void CCVKBindingLayout::update() { if (_isDirty && _gpuBindingLayout) { for (size_t i = 0u; i < _bindingUnits.size(); ++i) { - GFXBindingUnit &bindingUnit = _bindingUnits[i]; + BindingUnit &bindingUnit = _bindingUnits[i]; VkWriteDescriptorSet &binding = _gpuBindingLayout->bindings[i]; switch (bindingUnit.type) { - case GFXBindingType::UNIFORM_BUFFER: { + case BindingType::UNIFORM_BUFFER: { if (bindingUnit.buffer) { CCVKGPUBuffer *buffer = ((CCVKBuffer *)bindingUnit.buffer)->gpuBuffer(); VkDescriptorBufferInfo *info = (VkDescriptorBufferInfo *)binding.pBufferInfo; @@ -68,7 +68,7 @@ void CCVKBindingLayout::update() { break; } - case GFXBindingType::SAMPLER: { + case BindingType::SAMPLER: { VkDescriptorImageInfo *info = (VkDescriptorImageInfo *)binding.pImageInfo; info->imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; diff --git a/native/cocos/renderer/gfx-vulkan/VKBindingLayout.h b/native/cocos/renderer/gfx-vulkan/VKBindingLayout.h index e0a503ea93..b028b7121f 100644 --- a/native/cocos/renderer/gfx-vulkan/VKBindingLayout.h +++ b/native/cocos/renderer/gfx-vulkan/VKBindingLayout.h @@ -6,13 +6,13 @@ namespace gfx { class CCVKGPUBindingLayout; -class CC_VULKAN_API CCVKBindingLayout : public GFXBindingLayout { +class CC_VULKAN_API CCVKBindingLayout : public BindingLayout { public: - CCVKBindingLayout(GFXDevice *device); + CCVKBindingLayout(Device *device); ~CCVKBindingLayout(); public: - bool initialize(const GFXBindingLayoutInfo &info); + bool initialize(const BindingLayoutInfo &info); void destroy(); void update(); diff --git a/native/cocos/renderer/gfx-vulkan/VKBuffer.cc b/native/cocos/renderer/gfx-vulkan/VKBuffer.cc index fd8b64ccbd..049b289d98 100644 --- a/native/cocos/renderer/gfx-vulkan/VKBuffer.cc +++ b/native/cocos/renderer/gfx-vulkan/VKBuffer.cc @@ -6,14 +6,14 @@ namespace cc { namespace gfx { -CCVKBuffer::CCVKBuffer(GFXDevice *device) -: GFXBuffer(device) { +CCVKBuffer::CCVKBuffer(Device *device) +: Buffer(device) { } CCVKBuffer::~CCVKBuffer() { } -bool CCVKBuffer::initialize(const GFXBufferInfo &info) { +bool CCVKBuffer::initialize(const BufferInfo &info) { _usage = info.usage; _memUsage = info.memUsage; _size = info.size; @@ -21,7 +21,7 @@ bool CCVKBuffer::initialize(const GFXBufferInfo &info) { _count = _size / _stride; _flags = info.flags; - if ((_flags & GFXBufferFlagBit::BAKUP_BUFFER) && _size > 0) { + if ((_flags & BufferFlagBit::BAKUP_BUFFER) && _size > 0) { _buffer = (uint8_t *)CC_MALLOC(_size); _device->getMemoryStatus().bufferSize += _size; } @@ -33,8 +33,8 @@ bool CCVKBuffer::initialize(const GFXBufferInfo &info) { _gpuBuffer->stride = _stride; _gpuBuffer->count = _count; - if (_usage & GFXBufferUsageBit::INDIRECT) { - const size_t drawInfoCount = _size / sizeof(GFXDrawInfo); + if (_usage & BufferUsageBit::INDIRECT) { + const size_t drawInfoCount = _size / sizeof(DrawInfo); _gpuBuffer->indexedIndirectCmds.resize(drawInfoCount); _gpuBuffer->indirectCmds.resize(drawInfoCount); } else { @@ -43,7 +43,7 @@ bool CCVKBuffer::initialize(const GFXBufferInfo &info) { CCVKCmdFuncCreateBuffer((CCVKDevice *)_device, _gpuBuffer); _device->getMemoryStatus().bufferSize += _size; - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -62,7 +62,7 @@ void CCVKBuffer::destroy() { _buffer = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void CCVKBuffer::resize(uint size) { @@ -71,7 +71,7 @@ void CCVKBuffer::resize(uint size) { _size = size; _count = _size / _stride; - GFXMemoryStatus &status = _device->getMemoryStatus(); + MemoryStatus &status = _device->getMemoryStatus(); _gpuBuffer->size = _size; _gpuBuffer->count = _count; CCVKCmdFuncResizeBuffer((CCVKDevice *)_device, _gpuBuffer); @@ -87,8 +87,8 @@ void CCVKBuffer::resize(uint size) { status.bufferSize += _size; } - if (_usage & GFXBufferUsageBit::INDIRECT) { - const size_t drawInfoCount = _size / sizeof(GFXDrawInfo); + if (_usage & BufferUsageBit::INDIRECT) { + const size_t drawInfoCount = _size / sizeof(DrawInfo); _gpuBuffer->indexedIndirectCmds.resize(drawInfoCount); _gpuBuffer->indirectCmds.resize(drawInfoCount); } else { @@ -99,9 +99,9 @@ void CCVKBuffer::resize(uint size) { void CCVKBuffer::update(void *buffer, uint offset, uint size) { #if COCOS2D_DEBUG > 0 - if (_usage & GFXBufferUsageBit::INDIRECT) { - GFXDrawInfo *drawInfo = static_cast(buffer); - const size_t drawInfoCount = size / sizeof(GFXDrawInfo); + if (_usage & BufferUsageBit::INDIRECT) { + DrawInfo *drawInfo = static_cast(buffer); + const size_t drawInfoCount = size / sizeof(DrawInfo); const bool isIndexed = drawInfoCount > 0 && drawInfo->indexCount > 0; for (size_t i = 1u; i < drawInfoCount; i++) { if ((++drawInfo)->indexCount > 0 != isIndexed) { diff --git a/native/cocos/renderer/gfx-vulkan/VKBuffer.h b/native/cocos/renderer/gfx-vulkan/VKBuffer.h index 399a5ef568..f02e9bb0f3 100644 --- a/native/cocos/renderer/gfx-vulkan/VKBuffer.h +++ b/native/cocos/renderer/gfx-vulkan/VKBuffer.h @@ -6,13 +6,13 @@ namespace gfx { class CCVKGPUBuffer; -class CC_VULKAN_API CCVKBuffer : public GFXBuffer { +class CC_VULKAN_API CCVKBuffer : public Buffer { public: - CCVKBuffer(GFXDevice *device); + CCVKBuffer(Device *device); ~CCVKBuffer(); public: - bool initialize(const GFXBufferInfo &info); + bool initialize(const BufferInfo &info); void destroy(); void resize(uint size); void update(void *buffer, uint offset, uint size); diff --git a/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.cc b/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.cc index 578e2dbceb..6a49f81085 100644 --- a/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.cc +++ b/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.cc @@ -7,26 +7,26 @@ namespace cc { namespace gfx { -CCVKCommandAllocator::CCVKCommandAllocator(GFXDevice *device) -: GFXCommandAllocator(device) { +CCVKCommandAllocator::CCVKCommandAllocator(Device *device) +: CommandAllocator(device) { } CCVKCommandAllocator::~CCVKCommandAllocator() { } -bool CCVKCommandAllocator::initialize(const GFXCommandAllocatorInfo &info) { +bool CCVKCommandAllocator::initialize(const CommandAllocatorInfo &info) { _gpuCommandPool = CC_NEW(CCVKGPUCommandPool); CCVKCmdFuncCreateCommandPool((CCVKDevice *)_device, _gpuCommandPool); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } void CCVKCommandAllocator::destroy() { CCVKCmdFuncDestroyCommandPool((CCVKDevice *)_device, _gpuCommandPool); - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void CCVKCommandAllocator::reset() { diff --git a/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.h b/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.h index ae4c3081c9..3259ad0138 100644 --- a/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.h +++ b/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.h @@ -6,13 +6,13 @@ namespace gfx { class CCVKGPUCommandPool; -class CC_VULKAN_API CCVKCommandAllocator : public GFXCommandAllocator { +class CC_VULKAN_API CCVKCommandAllocator : public CommandAllocator { public: - CCVKCommandAllocator(GFXDevice *device); + CCVKCommandAllocator(Device *device); ~CCVKCommandAllocator(); public: - bool initialize(const GFXCommandAllocatorInfo &info); + bool initialize(const CommandAllocatorInfo &info); void destroy(); CC_INLINE CCVKGPUCommandPool *gpuCommandPool() { return _gpuCommandPool; } diff --git a/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.cc b/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.cc index 486e697946..7c711b617c 100644 --- a/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.cc +++ b/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.cc @@ -15,14 +15,14 @@ namespace cc { namespace gfx { -CCVKCommandBuffer::CCVKCommandBuffer(GFXDevice *device) -: GFXCommandBuffer(device) { +CCVKCommandBuffer::CCVKCommandBuffer(Device *device) +: CommandBuffer(device) { } CCVKCommandBuffer::~CCVKCommandBuffer() { } -bool CCVKCommandBuffer::initialize(const GFXCommandBufferInfo &info) { +bool CCVKCommandBuffer::initialize(const CommandBufferInfo &info) { if (!info.allocator) { return false; } @@ -35,7 +35,7 @@ bool CCVKCommandBuffer::initialize(const GFXCommandBufferInfo &info) { _gpuCommandBuffer->commandPool = ((CCVKCommandAllocator *)_allocator)->gpuCommandPool(); CCVKCmdFuncAllocateCommandBuffer((CCVKDevice *)_device, _gpuCommandBuffer); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -47,10 +47,10 @@ void CCVKCommandBuffer::destroy() { } _allocator = nullptr; - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } -void CCVKCommandBuffer::begin(GFXRenderPass *renderPass, uint subpass, GFXFramebuffer *frameBuffer) { +void CCVKCommandBuffer::begin(RenderPass *renderPass, uint subpass, Framebuffer *frameBuffer) { _curGPUPipelineState = nullptr; _curGPUBindingLayout = nullptr; _curGPUInputAssember = nullptr; @@ -61,7 +61,7 @@ void CCVKCommandBuffer::begin(GFXRenderPass *renderPass, uint subpass, GFXFrameb VkCommandBufferBeginInfo beginInfo{VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO}; beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; - if (_type == GFXCommandBufferType::SECONDARY) { + if (_type == CommandBufferType::SECONDARY) { if (!renderPass) { CC_LOG_ERROR("RenderPass has to be specified when beginning secondary command buffers."); return; @@ -80,8 +80,8 @@ void CCVKCommandBuffer::end() { VK_CHECK(vkEndCommandBuffer(_gpuCommandBuffer->vkCommandBuffer)); } -void CCVKCommandBuffer::beginRenderPass(GFXFramebuffer *fbo, const GFXRect &renderArea, - GFXClearFlags clearFlags, const std::vector &colors, float depth, int stencil) { +void CCVKCommandBuffer::beginRenderPass(Framebuffer *fbo, const Rect &renderArea, + ClearFlags clearFlags, const std::vector &colors, float depth, int stencil) { _curGPUFBO = ((CCVKFramebuffer *)fbo)->gpuFBO(); CCVKGPURenderPass *renderPass = _curGPUFBO->gpuRenderPass; VkFramebuffer framebuffer = _curGPUFBO->vkFramebuffer; @@ -123,7 +123,7 @@ void CCVKCommandBuffer::endRenderPass() { _curGPUFBO = nullptr; } -void CCVKCommandBuffer::bindPipelineState(GFXPipelineState *pso) { +void CCVKCommandBuffer::bindPipelineState(PipelineState *pso) { CCVKGPUPipelineState *gpuPipelineState = ((CCVKPipelineState *)pso)->gpuPipelineState(); if (_curGPUPipelineState != gpuPipelineState) { @@ -132,7 +132,7 @@ void CCVKCommandBuffer::bindPipelineState(GFXPipelineState *pso) { } } -void CCVKCommandBuffer::bindBindingLayout(GFXBindingLayout *layout) { +void CCVKCommandBuffer::bindBindingLayout(BindingLayout *layout) { if (!_curGPUPipelineState) { CC_LOG_ERROR("Command 'bindBindingLayout' must be recorded after 'bindPipelineState'."); return; @@ -147,7 +147,7 @@ void CCVKCommandBuffer::bindBindingLayout(GFXBindingLayout *layout) { } } -void CCVKCommandBuffer::bindInputAssembler(GFXInputAssembler *ia) { +void CCVKCommandBuffer::bindInputAssembler(InputAssembler *ia) { CCVKGPUInputAssembler *gpuInputAssembler = ((CCVKInputAssembler *)ia)->gpuInputAssembler(); if (_curGPUInputAssember != gpuInputAssembler) { @@ -174,7 +174,7 @@ void CCVKCommandBuffer::bindInputAssembler(GFXInputAssembler *ia) { } } -void CCVKCommandBuffer::setViewport(const GFXViewport &vp) { +void CCVKCommandBuffer::setViewport(const Viewport &vp) { if (_curViewport != vp) { _curViewport = vp; VkViewport viewport{(float)vp.left, (float)vp.top, (float)vp.width, (float)vp.height, vp.minDepth, vp.maxDepth}; @@ -182,7 +182,7 @@ void CCVKCommandBuffer::setViewport(const GFXViewport &vp) { } } -void CCVKCommandBuffer::setScissor(const GFXRect &rect) { +void CCVKCommandBuffer::setScissor(const Rect &rect) { if (_curScissor != rect) { _curScissor = rect; VkRect2D scissor{{rect.x, rect.y}, {rect.width, rect.height}}; @@ -208,7 +208,7 @@ void CCVKCommandBuffer::setDepthBias(float constant, float clamp, float slope) { } } -void CCVKCommandBuffer::setBlendConstants(const GFXColor &constants) { +void CCVKCommandBuffer::setBlendConstants(const Color &constants) { if (math::IsNotEqualF(_curBlendConstants.r, constants.r) || math::IsNotEqualF(_curBlendConstants.g, constants.g) || math::IsNotEqualF(_curBlendConstants.b, constants.b) || @@ -230,17 +230,17 @@ void CCVKCommandBuffer::setDepthBound(float minBounds, float maxBounds) { } } -void CCVKCommandBuffer::setStencilWriteMask(GFXStencilFace face, uint mask) { +void CCVKCommandBuffer::setStencilWriteMask(StencilFace face, uint mask) { if ((_curStencilWriteMask.face != face) || (_curStencilWriteMask.write_mask != mask)) { _curStencilWriteMask.face = face; _curStencilWriteMask.write_mask = mask; vkCmdSetStencilWriteMask(_gpuCommandBuffer->vkCommandBuffer, - face == GFXStencilFace::FRONT ? VK_STENCIL_FACE_FRONT_BIT : VK_STENCIL_FACE_BACK_BIT, mask); + face == StencilFace::FRONT ? VK_STENCIL_FACE_FRONT_BIT : VK_STENCIL_FACE_BACK_BIT, mask); } } -void CCVKCommandBuffer::setStencilCompareMask(GFXStencilFace face, int reference, uint mask) { +void CCVKCommandBuffer::setStencilCompareMask(StencilFace face, int reference, uint mask) { if ((_curStencilCompareMask.face != face) || (_curStencilCompareMask.reference != reference) || (_curStencilCompareMask.compareMask != mask)) { @@ -248,17 +248,17 @@ void CCVKCommandBuffer::setStencilCompareMask(GFXStencilFace face, int reference _curStencilCompareMask.reference = reference; _curStencilCompareMask.compareMask = mask; - VkStencilFaceFlagBits vkFace = (face == GFXStencilFace::FRONT ? VK_STENCIL_FACE_FRONT_BIT : VK_STENCIL_FACE_BACK_BIT); + VkStencilFaceFlagBits vkFace = (face == StencilFace::FRONT ? VK_STENCIL_FACE_FRONT_BIT : VK_STENCIL_FACE_BACK_BIT); vkCmdSetStencilReference(_gpuCommandBuffer->vkCommandBuffer, vkFace, reference); vkCmdSetStencilCompareMask(_gpuCommandBuffer->vkCommandBuffer, vkFace, mask); } } -void CCVKCommandBuffer::draw(GFXInputAssembler *ia) { - if ((_type == GFXCommandBufferType::PRIMARY && _curGPUFBO) || - (_type == GFXCommandBufferType::SECONDARY)) { +void CCVKCommandBuffer::draw(InputAssembler *ia) { + if ((_type == CommandBufferType::PRIMARY && _curGPUFBO) || + (_type == CommandBufferType::SECONDARY)) { CCVKGPUInputAssembler *gpuInputAssembler = ((CCVKInputAssembler *)ia)->gpuInputAssembler(); - GFXDrawInfo drawInfo; + DrawInfo drawInfo; if (gpuInputAssembler->gpuIndirectBuffer) { uint drawInfoCount = gpuInputAssembler->gpuIndirectBuffer->count; @@ -314,11 +314,11 @@ void CCVKCommandBuffer::draw(GFXInputAssembler *ia) { if (_curGPUPipelineState) { uint indexCount = hasIndexBuffer ? drawInfo.indexCount : drawInfo.vertexCount; switch (_curGPUPipelineState->primitive) { - case GFXPrimitiveMode::TRIANGLE_LIST: + case PrimitiveMode::TRIANGLE_LIST: _numTriangles += indexCount / 3 * instanceCount; break; - case GFXPrimitiveMode::TRIANGLE_STRIP: - case GFXPrimitiveMode::TRIANGLE_FAN: + case PrimitiveMode::TRIANGLE_STRIP: + case PrimitiveMode::TRIANGLE_FAN: _numTriangles += (indexCount - 2) * instanceCount; break; } @@ -329,7 +329,7 @@ void CCVKCommandBuffer::draw(GFXInputAssembler *ia) { } } -void CCVKCommandBuffer::execute(const std::vector &cmdBuffs, uint count) { +void CCVKCommandBuffer::execute(const std::vector &cmdBuffs, uint count) { if (!count) { return; } @@ -348,18 +348,18 @@ void CCVKCommandBuffer::execute(const std::vector &cmdBuffs, vkCmdExecuteCommands(_gpuCommandBuffer->vkCommandBuffer, count, vkCmdBuffs.data()); } -void CCVKCommandBuffer::updateBuffer(GFXBuffer *buff, void *data, uint size, uint offset) { - if ((_type == GFXCommandBufferType::PRIMARY && !_curGPUFBO) || - (_type == GFXCommandBufferType::SECONDARY)) { +void CCVKCommandBuffer::updateBuffer(Buffer *buff, void *data, uint size, uint offset) { + if ((_type == CommandBufferType::PRIMARY && !_curGPUFBO) || + (_type == CommandBufferType::SECONDARY)) { CCVKCmdFuncUpdateBuffer((CCVKDevice *)_device, ((CCVKBuffer *)buff)->gpuBuffer(), data, offset, size); } else { CC_LOG_ERROR("Command 'updateBuffer' must be recorded outside a render pass."); } } -void CCVKCommandBuffer::copyBufferToTexture(GFXBuffer *src, GFXTexture *dst, GFXTextureLayout layout, const GFXBufferTextureCopyList ®ions) { - if ((_type == GFXCommandBufferType::PRIMARY && !_curGPUFBO) || - (_type == GFXCommandBufferType::SECONDARY)) { +void CCVKCommandBuffer::copyBufferToTexture(Buffer *src, Texture *dst, TextureLayout layout, const BufferTextureCopyList ®ions) { + if ((_type == CommandBufferType::PRIMARY && !_curGPUFBO) || + (_type == CommandBufferType::SECONDARY)) { //const CCVKGPUBuffer* gpuBuffer = ((CCVKBuffer*)src)->gpuBuffer(); //const CCVKGPUTexture* gpuTexture = ((CCVKTexture*)dst)->gpuTexture(); //vkCmdCopyBufferToImage(_gpuCommandBuffer->vkCommandBuffer, gpuBuffer->vkBuffer, gpuTexture->vkImage, MapVkImageLayout(layout), diff --git a/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.h b/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.h index a499c4e6bd..27321fd5d9 100644 --- a/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.h +++ b/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.h @@ -6,36 +6,36 @@ namespace cc { namespace gfx { -class CC_VULKAN_API CCVKCommandBuffer : public GFXCommandBuffer { +class CC_VULKAN_API CCVKCommandBuffer : public CommandBuffer { public: - CCVKCommandBuffer(GFXDevice *device); + CCVKCommandBuffer(Device *device); ~CCVKCommandBuffer(); friend class CCVKQueue; public: - bool initialize(const GFXCommandBufferInfo &info); + bool initialize(const CommandBufferInfo &info); void destroy(); - void begin(GFXRenderPass *renderPass = nullptr, uint subpass = 0, GFXFramebuffer *frameBuffer = nullptr); + void begin(RenderPass *renderPass = nullptr, uint subpass = 0, Framebuffer *frameBuffer = nullptr); void end(); - void beginRenderPass(GFXFramebuffer *fbo, const GFXRect &render_area, GFXClearFlags clear_flags, const std::vector &colors, float depth, int stencil); + void beginRenderPass(Framebuffer *fbo, const Rect &render_area, ClearFlags clear_flags, const std::vector &colors, float depth, int stencil); void endRenderPass(); - void bindPipelineState(GFXPipelineState *pso); - void bindBindingLayout(GFXBindingLayout *layout); - void bindInputAssembler(GFXInputAssembler *ia); - void setViewport(const GFXViewport &vp); - void setScissor(const GFXRect &rect); + void bindPipelineState(PipelineState *pso); + void bindBindingLayout(BindingLayout *layout); + void bindInputAssembler(InputAssembler *ia); + void setViewport(const Viewport &vp); + void setScissor(const Rect &rect); void setLineWidth(const float width); void setDepthBias(float constant, float clamp, float slope); - void setBlendConstants(const GFXColor &constants); + void setBlendConstants(const Color &constants); void setDepthBound(float min_bounds, float max_bounds); - void setStencilWriteMask(GFXStencilFace face, uint mask); - void setStencilCompareMask(GFXStencilFace face, int reference, uint mask); - void draw(GFXInputAssembler *ia); - void updateBuffer(GFXBuffer *buff, void *data, uint size, uint offset); - void copyBufferToTexture(GFXBuffer *src, GFXTexture *dst, GFXTextureLayout layout, const GFXBufferTextureCopyList ®ions); - void execute(const std::vector &cmd_buffs, uint count); + void setStencilWriteMask(StencilFace face, uint mask); + void setStencilCompareMask(StencilFace face, int reference, uint mask); + void draw(InputAssembler *ia); + void updateBuffer(Buffer *buff, void *data, uint size, uint offset); + void copyBufferToTexture(Buffer *src, Texture *dst, TextureLayout layout, const BufferTextureCopyList ®ions); + void execute(const std::vector &cmd_buffs, uint count); CCVKGPUCommandBuffer *gpuCommandBuffer() const { return _gpuCommandBuffer; } @@ -47,11 +47,11 @@ private: CCVKGPUInputAssembler *_curGPUInputAssember = nullptr; CCVKGPUFramebuffer *_curGPUFBO = nullptr; - GFXViewport _curViewport; - GFXRect _curScissor; + Viewport _curViewport; + Rect _curScissor; float _curLineWidth = 1.0f; CCVKDepthBias _curDepthBias; - GFXColor _curBlendConstants; + Color _curBlendConstants; CCVKDepthBounds _curDepthBounds; CCVKStencilWriteMask _curStencilWriteMask; CCVKStencilCompareMask _curStencilCompareMask; diff --git a/native/cocos/renderer/gfx-vulkan/VKCommands.cc b/native/cocos/renderer/gfx-vulkan/VKCommands.cc index f69e796cc0..7242fb71b2 100644 --- a/native/cocos/renderer/gfx-vulkan/VKCommands.cc +++ b/native/cocos/renderer/gfx-vulkan/VKCommands.cc @@ -15,22 +15,22 @@ namespace cc { namespace gfx { -void insertVkDynamicStates(vector &out, const vector &dynamicStates) { - for (GFXDynamicState dynamicState : dynamicStates) { +void insertVkDynamicStates(vector &out, const vector &dynamicStates) { + for (DynamicState dynamicState : dynamicStates) { switch (dynamicState) { - case GFXDynamicState::VIEWPORT: break; // we make this dynamic by default - case GFXDynamicState::SCISSOR: break; // we make this dynamic by default - case GFXDynamicState::LINE_WIDTH: out.push_back(VK_DYNAMIC_STATE_LINE_WIDTH); break; - case GFXDynamicState::DEPTH_BIAS: out.push_back(VK_DYNAMIC_STATE_DEPTH_BIAS); break; - case GFXDynamicState::BLEND_CONSTANTS: out.push_back(VK_DYNAMIC_STATE_BLEND_CONSTANTS); break; - case GFXDynamicState::DEPTH_BOUNDS: out.push_back(VK_DYNAMIC_STATE_DEPTH_BOUNDS); break; - case GFXDynamicState::STENCIL_WRITE_MASK: out.push_back(VK_DYNAMIC_STATE_STENCIL_WRITE_MASK); break; - case GFXDynamicState::STENCIL_COMPARE_MASK: + case DynamicState::VIEWPORT: break; // we make this dynamic by default + case DynamicState::SCISSOR: break; // we make this dynamic by default + case DynamicState::LINE_WIDTH: out.push_back(VK_DYNAMIC_STATE_LINE_WIDTH); break; + case DynamicState::DEPTH_BIAS: out.push_back(VK_DYNAMIC_STATE_DEPTH_BIAS); break; + case DynamicState::BLEND_CONSTANTS: out.push_back(VK_DYNAMIC_STATE_BLEND_CONSTANTS); break; + case DynamicState::DEPTH_BOUNDS: out.push_back(VK_DYNAMIC_STATE_DEPTH_BOUNDS); break; + case DynamicState::STENCIL_WRITE_MASK: out.push_back(VK_DYNAMIC_STATE_STENCIL_WRITE_MASK); break; + case DynamicState::STENCIL_COMPARE_MASK: out.push_back(VK_DYNAMIC_STATE_STENCIL_REFERENCE); out.push_back(VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK); break; default: { - CCASSERT(false, "Unsupported GFXPrimitiveMode, convert to VkPrimitiveTopology failed."); + CCASSERT(false, "Unsupported PrimitiveMode, convert to VkPrimitiveTopology failed."); break; } } @@ -39,7 +39,7 @@ void insertVkDynamicStates(vector &out, const vectorcommandPool = ((CCVKCommandAllocator *)device->getCommandAllocator())->gpuCommandPool(); - cmdBuff->type = GFXCommandBufferType::PRIMARY; + cmdBuff->type = CommandBufferType::PRIMARY; CCVKCmdFuncAllocateCommandBuffer(device, cmdBuff); VkCommandBufferBeginInfo beginInfo{VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO}; @@ -92,7 +92,7 @@ void CCVKCmdFuncCreateRenderPass(CCVKDevice *device, CCVKGPURenderPass *gpuRende vector attachmentDescriptions(colorAttachmentCount + 1); gpuRenderPass->clearValues.resize(colorAttachmentCount + 1); for (size_t i = 0u; i < colorAttachmentCount; i++) { - const GFXColorAttachment &attachment = gpuRenderPass->colorAttachments[i]; + const ColorAttachment &attachment = gpuRenderPass->colorAttachments[i]; const VkImageLayout beginLayout = MapVkImageLayout(attachment.beginLayout); const VkImageLayout endLayout = MapVkImageLayout(attachment.endLayout); const VkAccessFlags beginAccessMask = MapVkAccessFlags(attachment.beginLayout); @@ -106,7 +106,7 @@ void CCVKCmdFuncCreateRenderPass(CCVKDevice *device, CCVKGPURenderPass *gpuRende attachmentDescriptions[i].initialLayout = beginLayout; attachmentDescriptions[i].finalLayout = endLayout; } - const GFXDepthStencilAttachment &depthStencilAttachment = gpuRenderPass->depthStencilAttachment; + const DepthStencilAttachment &depthStencilAttachment = gpuRenderPass->depthStencilAttachment; const VkImageLayout beginLayout = MapVkImageLayout(depthStencilAttachment.beginLayout); const VkImageLayout endLayout = MapVkImageLayout(depthStencilAttachment.endLayout); const VkAccessFlags beginAccessMask = MapVkAccessFlags(depthStencilAttachment.beginLayout); @@ -127,7 +127,7 @@ void CCVKCmdFuncCreateRenderPass(CCVKDevice *device, CCVKGPURenderPass *gpuRende if (subpassCount) { // pass on user-specified subpasses subpassDescriptions.resize(subpassCount); for (size_t i = 0u; i < subpassCount; i++) { - const GFXSubPass &subpass = gpuRenderPass->subPasses[i]; + const SubPass &subpass = gpuRenderPass->subPasses[i]; subpassDescriptions[i].pipelineBindPoint = MapVkPipelineBindPoint(subpass.bindPoint); // TODO } @@ -161,12 +161,12 @@ void CCVKCmdFuncGetDeviceQueue(CCVKDevice *device, CCVKGPUQueue *gpuQueue) { uint queueType = 0u; VkBool32 needPresentable = VK_FALSE; switch (gpuQueue->type) { - case GFXQueueType::GRAPHICS: + case QueueType::GRAPHICS: queueType = VK_QUEUE_GRAPHICS_BIT; needPresentable = VK_TRUE; break; - case GFXQueueType::COMPUTE: queueType = VK_QUEUE_COMPUTE_BIT; break; - case GFXQueueType::TRANSFER: queueType = VK_QUEUE_TRANSFER_BIT; break; + case QueueType::COMPUTE: queueType = VK_QUEUE_COMPUTE_BIT; break; + case QueueType::TRANSFER: queueType = VK_QUEUE_TRANSFER_BIT; break; } const CCVKGPUContext *context = ((CCVKContext *)device->getContext())->gpuContext(); @@ -233,13 +233,13 @@ void CCVKCmdFuncCreateBuffer(CCVKDevice *device, CCVKGPUBuffer *gpuBuffer) { VmaAllocationCreateInfo allocInfo{}; allocInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT; - if (gpuBuffer->memUsage == GFXMemoryUsage::HOST) { + if (gpuBuffer->memUsage == MemoryUsage::HOST) { bufferInfo.usage |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT; allocInfo.usage = VMA_MEMORY_USAGE_CPU_ONLY; - } else if (gpuBuffer->memUsage == GFXMemoryUsage::DEVICE) { + } else if (gpuBuffer->memUsage == MemoryUsage::DEVICE) { bufferInfo.usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT; allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; - } else if (gpuBuffer->memUsage == (GFXMemoryUsage::HOST | GFXMemoryUsage::DEVICE)) { + } else if (gpuBuffer->memUsage == (MemoryUsage::HOST | MemoryUsage::DEVICE)) { allocInfo.usage = VMA_MEMORY_USAGE_CPU_TO_GPU; } @@ -268,9 +268,9 @@ void CCVKCmdFuncUpdateBuffer(CCVKDevice *device, CCVKGPUBuffer *gpuBuffer, void const void *dataToUpload = nullptr; size_t sizeToUpload = 0u; - if (gpuBuffer->usage & GFXBufferUsageBit::INDIRECT) { - size_t drawInfoCount = size / sizeof(GFXDrawInfo); - GFXDrawInfo *drawInfo = static_cast(buffer); + if (gpuBuffer->usage & BufferUsageBit::INDIRECT) { + size_t drawInfoCount = size / sizeof(DrawInfo); + DrawInfo *drawInfo = static_cast(buffer); if (drawInfoCount > 0) { if (drawInfo->indexCount) { for (size_t i = 0; i < drawInfoCount; i++) { @@ -334,7 +334,7 @@ void CCVKCmdFuncCreateTexture(CCVKDevice *device, CCVKGPUTexture *gpuTexture) { } VkImageUsageFlags usageFlags = MapVkImageUsageFlagBits(gpuTexture->usage); - if (gpuTexture->flags & GFXTextureFlags::GEN_MIPMAP) { + if (gpuTexture->flags & TextureFlags::GEN_MIPMAP) { usageFlags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT; } @@ -553,12 +553,12 @@ void CCVKCmdFuncDestroyFramebuffer(CCVKDevice *device, CCVKGPUFramebuffer *gpuFr } } -void CCVKCmdFuncCreateBindingLayout(CCVKDevice *device, CCVKGPUBindingLayout *gpuBindingLayout, GFXBindingUnitList bindings) { +void CCVKCmdFuncCreateBindingLayout(CCVKDevice *device, CCVKGPUBindingLayout *gpuBindingLayout, BindingUnitList bindings) { size_t count = bindings.size(); vector setBindings(count); for (size_t i = 0u; i < count; i++) { - const GFXBindingUnit &binding = bindings[i]; + const BindingUnit &binding = bindings[i]; setBindings[i].binding = binding.binding; setBindings[i].descriptorType = MapVkDescriptorType(binding.type); setBindings[i].descriptorCount = binding.count; @@ -691,11 +691,11 @@ void CCVKCmdFuncCreatePipelineState(CCVKDevice *device, CCVKGPUPipelineState *gp ///////////////////// Input State ///////////////////// - const GFXAttributeList &attributes = gpuPipelineState->inputState.attributes; + const AttributeList &attributes = gpuPipelineState->inputState.attributes; const size_t attributeCount = attributes.size(); size_t bindingCount = 1u; for (size_t i = 0u; i < attributeCount; i++) { - const GFXAttribute &attr = attributes[i]; + const Attribute &attr = attributes[i]; bindingCount = std::max((size_t)bindingCount, (size_t)(attr.stream + 1)); } @@ -706,20 +706,20 @@ void CCVKCmdFuncCreatePipelineState(CCVKDevice *device, CCVKGPUPipelineState *gp bindingDescriptions[i].inputRate = VK_VERTEX_INPUT_RATE_VERTEX; } for (size_t i = 0u; i < attributeCount; i++) { - const GFXAttribute &attr = attributes[i]; + const Attribute &attr = attributes[i]; bindingDescriptions[attr.stream].stride += GFX_FORMAT_INFOS[(uint)attr.format].size; if (attr.isInstanced) { bindingDescriptions[attr.stream].inputRate = VK_VERTEX_INPUT_RATE_INSTANCE; } } - const GFXAttributeList &shaderAttrs = gpuPipelineState->gpuShader->attributes; + const AttributeList &shaderAttrs = gpuPipelineState->gpuShader->attributes; const size_t shaderAttrCount = shaderAttrs.size(); vector attributeDescriptions(shaderAttrCount); vector offsets(bindingCount, 0); uint record = 0u; for (size_t i = 0u; i < attributeCount; i++) { - const GFXAttribute &attr = attributes[i]; + const Attribute &attr = attributes[i]; size_t j = 0u; for (; j < shaderAttrCount; j++) { if (shaderAttrs[j].name == attr.name) { @@ -834,7 +834,7 @@ void CCVKCmdFuncCreatePipelineState(CCVKDevice *device, CCVKGPUPipelineState *gp size_t blendTargetCount = gpuPipelineState->bs.targets.size(); vector blendTargets(blendTargetCount); for (size_t i = 0u; i < blendTargetCount; i++) { - GFXBlendTarget &target = gpuPipelineState->bs.targets[i]; + BlendTarget &target = gpuPipelineState->bs.targets[i]; blendTargets[i].blendEnable = target.blend; blendTargets[i].srcColorBlendFactor = VK_BLEND_FACTORS[(uint)target.blendSrc]; blendTargets[i].dstColorBlendFactor = VK_BLEND_FACTORS[(uint)target.blendDst]; @@ -844,7 +844,7 @@ void CCVKCmdFuncCreatePipelineState(CCVKDevice *device, CCVKGPUPipelineState *gp blendTargets[i].alphaBlendOp = VK_BLEND_OPS[(uint)target.blendAlphaEq]; blendTargets[i].colorWriteMask = MapVkColorComponentFlags(target.blendColorMask); } - GFXColor &blendColor = gpuPipelineState->bs.blendColor; + Color &blendColor = gpuPipelineState->bs.blendColor; VkPipelineColorBlendStateCreateInfo colorBlendState{VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO}; //colorBlendState.logicOpEnable; @@ -875,7 +875,7 @@ void CCVKCmdFuncDestroyPipelineState(CCVKDevice *device, CCVKGPUPipelineState *g } } -void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice *device, uint8_t *const *buffers, CCVKGPUTexture *gpuTexture, const GFXBufferTextureCopyList ®ions) { +void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice *device, uint8_t *const *buffers, CCVKGPUTexture *gpuTexture, const BufferTextureCopyList ®ions) { //bool isCompressed = GFX_FORMAT_INFOS[(int)gpuTexture->format].isCompressed; CCVKGPUCommandBuffer cmdBuff; beginOneTimeCommands(device, &cmdBuff); @@ -898,10 +898,10 @@ void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice *device, uint8_t *const *buffers uint regionCount = regions.size(), totalSize = 0u; vector regionSizes(regionCount); for (size_t i = 0u; i < regionCount; ++i) { - const GFXBufferTextureCopy ®ion = regions[i]; + const BufferTextureCopy ®ion = regions[i]; uint w = region.buffStride > 0 ? region.buffStride : region.texExtent.width; uint h = region.buffTexHeight > 0 ? region.buffTexHeight : region.texExtent.height; - totalSize += regionSizes[i] = GFXFormatSize(gpuTexture->format, w, h, region.texExtent.depth); + totalSize += regionSizes[i] = FormatSize(gpuTexture->format, w, h, region.texExtent.depth); } CCVKGPUBuffer *stagingBuffer = device->stagingBuffer()->gpuBuffer(); @@ -910,7 +910,7 @@ void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice *device, uint8_t *const *buffers vector stagingRegions(regionCount); VkDeviceSize offset = stagingBuffer->startOffset; for (size_t i = 0u; i < regionCount; ++i) { - const GFXBufferTextureCopy ®ion = regions[i]; + const BufferTextureCopy ®ion = regions[i]; VkBufferImageCopy &stagingRegion = stagingRegions[i]; stagingRegion.bufferOffset = offset; stagingRegion.bufferRowLength = region.buffStride; @@ -927,7 +927,7 @@ void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice *device, uint8_t *const *buffers VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, stagingRegions.size(), stagingRegions.data()); bool layoutReady = false; - if (gpuTexture->flags & GFXTextureFlags::GEN_MIPMAP) { + if (gpuTexture->flags & TextureFlags::GEN_MIPMAP) { VkFormatProperties formatProperties; vkGetPhysicalDeviceFormatProperties(device->gpuContext()->physicalDevice, MapVkFormat(gpuTexture->format), &formatProperties); VkFormatFeatureFlags mipmapFeatures = VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT; diff --git a/native/cocos/renderer/gfx-vulkan/VKCommands.h b/native/cocos/renderer/gfx-vulkan/VKCommands.h index 8ebe87a87c..3b66894bb6 100644 --- a/native/cocos/renderer/gfx-vulkan/VKCommands.h +++ b/native/cocos/renderer/gfx-vulkan/VKCommands.h @@ -20,12 +20,12 @@ struct CCVKDepthBounds { }; struct CCVKStencilWriteMask { - GFXStencilFace face = GFXStencilFace::FRONT; + StencilFace face = StencilFace::FRONT; uint32_t write_mask = 0; }; struct CCVKStencilCompareMask { - GFXStencilFace face = GFXStencilFace::FRONT; + StencilFace face = StencilFace::FRONT; int reference = 0; uint32_t compareMask = 0; }; @@ -55,14 +55,14 @@ CC_VULKAN_API void CCVKCmdFuncCreateInputAssembler(CCVKDevice *device, CCVKGPUIn CC_VULKAN_API void CCVKCmdFuncDestroyInputAssembler(CCVKDevice *device, CCVKGPUInputAssembler *gpuInputAssembler); CC_VULKAN_API void CCVKCmdFuncCreateFramebuffer(CCVKDevice *device, CCVKGPUFramebuffer *gpuFramebuffer); CC_VULKAN_API void CCVKCmdFuncDestroyFramebuffer(CCVKDevice *device, CCVKGPUFramebuffer *gpuFramebuffer); -CC_VULKAN_API void CCVKCmdFuncCreateBindingLayout(CCVKDevice *device, CCVKGPUBindingLayout *gpuBindingLayout, GFXBindingUnitList bindings); +CC_VULKAN_API void CCVKCmdFuncCreateBindingLayout(CCVKDevice *device, CCVKGPUBindingLayout *gpuBindingLayout, BindingUnitList bindings); CC_VULKAN_API void CCVKCmdFuncDestroyBindingLayout(CCVKDevice *device, CCVKGPUBindingLayout *gpuBindingLayout); CC_VULKAN_API void CCVKCmdFuncCreatePipelineLayout(CCVKDevice *device, CCVKGPUPipelineLayout *gpuPipelineLayout); CC_VULKAN_API void CCVKCmdFuncDestroyPipelineLayout(CCVKDevice *device, CCVKGPUPipelineLayout *gpuPipelineLayout); CC_VULKAN_API void CCVKCmdFuncCreatePipelineState(CCVKDevice *device, CCVKGPUPipelineState *gpuPipelineState); CC_VULKAN_API void CCVKCmdFuncDestroyPipelineState(CCVKDevice *device, CCVKGPUPipelineState *gpuPipelineState); -CC_VULKAN_API void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice *device, uint8_t *const *buffers, CCVKGPUTexture *gpuTexture, const GFXBufferTextureCopyList ®ions); +CC_VULKAN_API void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice *device, uint8_t *const *buffers, CCVKGPUTexture *gpuTexture, const BufferTextureCopyList ®ions); } // namespace gfx } // namespace cc diff --git a/native/cocos/renderer/gfx-vulkan/VKContext.cc b/native/cocos/renderer/gfx-vulkan/VKContext.cc index f85be5cf1d..c97b057b2f 100644 --- a/native/cocos/renderer/gfx-vulkan/VKContext.cc +++ b/native/cocos/renderer/gfx-vulkan/VKContext.cc @@ -60,14 +60,14 @@ VKAPI_ATTR VkBool32 VKAPI_CALL debugReportCallback(VkDebugReportFlagsEXT flags, #endif } // namespace -CCVKContext::CCVKContext(GFXDevice *device) -: GFXContext(device) { +CCVKContext::CCVKContext(Device *device) +: Context(device) { } CCVKContext::~CCVKContext() { } -bool CCVKContext::initialize(const GFXContextInfo &info) { +bool CCVKContext::initialize(const ContextInfo &info) { _vsyncMode = info.vsyncMode; _windowHandle = info.windowHandle; @@ -314,8 +314,8 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { ///////////////////// Swapchain Preperation ///////////////////// - _colorFmt = GFXFormat::BGRA8; - _depthStencilFmt = GFXFormat::D24S8; + _colorFmt = Format::BGRA8; + _depthStencilFmt = Format::D24S8; VkSurfaceCapabilitiesKHR surfaceCapabilities{}; vkGetPhysicalDeviceSurfaceCapabilitiesKHR(_gpuContext->physicalDevice, _gpuContext->vkSurface, &surfaceCapabilities); @@ -360,14 +360,14 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { } } - vector> depthFormatPriorityList = { - {GFXFormat::D32F_S8, VK_FORMAT_D32_SFLOAT_S8_UINT}, - {GFXFormat::D24S8, VK_FORMAT_D24_UNORM_S8_UINT}, - {GFXFormat::D16S8, VK_FORMAT_D16_UNORM_S8_UINT}, - {GFXFormat::D32F, VK_FORMAT_D32_SFLOAT}, - {GFXFormat::D16, VK_FORMAT_D16_UNORM}, + vector> depthFormatPriorityList = { + {Format::D32F_S8, VK_FORMAT_D32_SFLOAT_S8_UINT}, + {Format::D24S8, VK_FORMAT_D24_UNORM_S8_UINT}, + {Format::D16S8, VK_FORMAT_D16_UNORM_S8_UINT}, + {Format::D32F, VK_FORMAT_D32_SFLOAT}, + {Format::D16, VK_FORMAT_D16_UNORM}, }; - for (std::pair &format : depthFormatPriorityList) { + for (std::pair &format : depthFormatPriorityList) { VkFormatProperties formatProperties; vkGetPhysicalDeviceFormatProperties(_gpuContext->physicalDevice, format.second, &formatProperties); // Format must support depth stencil attachment for optimal tiling @@ -384,11 +384,11 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { vector presentModePriorityList; switch (_vsyncMode) { - case GFXVsyncMode::OFF: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR}); break; - case GFXVsyncMode::ON: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_FIFO_KHR}); break; - case GFXVsyncMode::RELAXED: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_FIFO_RELAXED_KHR, VK_PRESENT_MODE_FIFO_KHR}); break; - case GFXVsyncMode::MAILBOX: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR}); break; - case GFXVsyncMode::HALF: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_FIFO_KHR}); break; // TODO + case VsyncMode::OFF: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR}); break; + case VsyncMode::ON: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_FIFO_KHR}); break; + case VsyncMode::RELAXED: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_FIFO_RELAXED_KHR, VK_PRESENT_MODE_FIFO_KHR}); break; + case VsyncMode::MAILBOX: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR}); break; + case VsyncMode::HALF: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_FIFO_KHR}); break; // TODO } VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR; diff --git a/native/cocos/renderer/gfx-vulkan/VKContext.h b/native/cocos/renderer/gfx-vulkan/VKContext.h index 485cecc663..50d70088e1 100644 --- a/native/cocos/renderer/gfx-vulkan/VKContext.h +++ b/native/cocos/renderer/gfx-vulkan/VKContext.h @@ -10,13 +10,13 @@ class CCVKGPUContext; class CCVKGPUSwapchain; class CCVKGPUSemaphorePool; -class CC_VULKAN_API CCVKContext : public GFXContext { +class CC_VULKAN_API CCVKContext : public Context { public: - CCVKContext(GFXDevice *device); + CCVKContext(Device *device); ~CCVKContext(); public: - bool initialize(const GFXContextInfo &info); + bool initialize(const ContextInfo &info); void destroy(); void present() {} diff --git a/native/cocos/renderer/gfx-vulkan/VKDevice.cc b/native/cocos/renderer/gfx-vulkan/VKDevice.cc index 969b3e388b..165e0aa6bf 100644 --- a/native/cocos/renderer/gfx-vulkan/VKDevice.cc +++ b/native/cocos/renderer/gfx-vulkan/VKDevice.cc @@ -38,8 +38,8 @@ CCVKGPUContext *CCVKDevice::gpuContext() const { return ((CCVKContext *)_context)->gpuContext(); } -bool CCVKDevice::initialize(const GFXDeviceInfo &info) { - _gfxAPI = GFXAPI::VULKAN; +bool CCVKDevice::initialize(const DeviceInfo &info) { + _API = API::VULKAN; _deviceName = "Vulkan"; _width = info.width; _height = info.height; @@ -47,7 +47,7 @@ bool CCVKDevice::initialize(const GFXDeviceInfo &info) { _nativeHeight = info.nativeHeight; _windowHandle = info.windowHandle; - GFXContextInfo contextCreateInfo; + ContextInfo contextCreateInfo; contextCreateInfo.windowHandle = _windowHandle; contextCreateInfo.sharedCtx = info.sharedCtx; @@ -148,61 +148,61 @@ bool CCVKDevice::initialize(const GFXDeviceInfo &info) { ///////////////////// Gather Device Properties ///////////////////// - _features[(int)GFXFeature::COLOR_FLOAT] = true; - _features[(int)GFXFeature::COLOR_HALF_FLOAT] = true; - _features[(int)GFXFeature::TEXTURE_FLOAT] = true; - _features[(int)GFXFeature::TEXTURE_HALF_FLOAT] = true; - _features[(int)GFXFeature::TEXTURE_FLOAT_LINEAR] = true; - _features[(int)GFXFeature::TEXTURE_HALF_FLOAT_LINEAR] = true; - _features[(int)GFXFeature::FORMAT_R11G11B10F] = true; - _features[(int)GFXFeature::MSAA] = true; - _features[(int)GFXFeature::ELEMENT_INDEX_UINT] = true; - _features[(int)GFXFeature::INSTANCED_ARRAYS] = true; - _features[static_cast(GFXFeature::DEPTH_BOUNDS)] = deviceFeatures.depthBounds; - _features[static_cast(GFXFeature::LINE_WIDTH)] = true; - _features[static_cast(GFXFeature::STENCIL_COMPARE_MASK)] = true; - _features[static_cast(GFXFeature::STENCIL_WRITE_MASK)] = true; + _features[(int)Feature::COLOR_FLOAT] = true; + _features[(int)Feature::COLOR_HALF_FLOAT] = true; + _features[(int)Feature::TEXTURE_FLOAT] = true; + _features[(int)Feature::TEXTURE_HALF_FLOAT] = true; + _features[(int)Feature::TEXTURE_FLOAT_LINEAR] = true; + _features[(int)Feature::TEXTURE_HALF_FLOAT_LINEAR] = true; + _features[(int)Feature::FORMAT_R11G11B10F] = true; + _features[(int)Feature::MSAA] = true; + _features[(int)Feature::ELEMENT_INDEX_UINT] = true; + _features[(int)Feature::INSTANCED_ARRAYS] = true; + _features[static_cast(Feature::DEPTH_BOUNDS)] = deviceFeatures.depthBounds; + _features[static_cast(Feature::LINE_WIDTH)] = true; + _features[static_cast(Feature::STENCIL_COMPARE_MASK)] = true; + _features[static_cast(Feature::STENCIL_WRITE_MASK)] = true; _multiDrawIndirectSupported = deviceFeatures2.features.multiDrawIndirect; VkFormatFeatureFlags requiredFeatures = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; VkFormatProperties formatProperties; vkGetPhysicalDeviceFormatProperties(gpuContext->physicalDevice, VK_FORMAT_R8G8B8_UNORM, &formatProperties); if (formatProperties.optimalTilingFeatures & requiredFeatures) { - _features[(int)GFXFeature::FORMAT_RGB8] = true; + _features[(int)Feature::FORMAT_RGB8] = true; } requiredFeatures = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT; vkGetPhysicalDeviceFormatProperties(gpuContext->physicalDevice, VK_FORMAT_D16_UNORM, &formatProperties); if (formatProperties.optimalTilingFeatures & requiredFeatures) { - _features[(int)GFXFeature::FORMAT_D16] = true; + _features[(int)Feature::FORMAT_D16] = true; } vkGetPhysicalDeviceFormatProperties(gpuContext->physicalDevice, VK_FORMAT_X8_D24_UNORM_PACK32, &formatProperties); if (formatProperties.optimalTilingFeatures & requiredFeatures) { - _features[(int)GFXFeature::FORMAT_D24] = true; + _features[(int)Feature::FORMAT_D24] = true; } vkGetPhysicalDeviceFormatProperties(gpuContext->physicalDevice, VK_FORMAT_D32_SFLOAT, &formatProperties); if (formatProperties.optimalTilingFeatures & requiredFeatures) { - _features[(int)GFXFeature::FORMAT_D32F] = true; + _features[(int)Feature::FORMAT_D32F] = true; } vkGetPhysicalDeviceFormatProperties(gpuContext->physicalDevice, VK_FORMAT_D16_UNORM_S8_UINT, &formatProperties); if (formatProperties.optimalTilingFeatures & requiredFeatures) { - _features[(int)GFXFeature::FORMAT_D16S8] = true; + _features[(int)Feature::FORMAT_D16S8] = true; } vkGetPhysicalDeviceFormatProperties(gpuContext->physicalDevice, VK_FORMAT_D24_UNORM_S8_UINT, &formatProperties); if (formatProperties.optimalTilingFeatures & requiredFeatures) { - _features[(int)GFXFeature::FORMAT_D24S8] = true; + _features[(int)Feature::FORMAT_D24S8] = true; } vkGetPhysicalDeviceFormatProperties(gpuContext->physicalDevice, VK_FORMAT_D32_SFLOAT_S8_UINT, &formatProperties); if (formatProperties.optimalTilingFeatures & requiredFeatures) { - _features[(int)GFXFeature::FORMAT_D32FS8] = true; + _features[(int)Feature::FORMAT_D32FS8] = true; } String compressedFmts; if (deviceFeatures.textureCompressionETC2) { - _features[(int)GFXFeature::FORMAT_ETC2] = true; + _features[(int)Feature::FORMAT_ETC2] = true; compressedFmts += "etc2 "; } if (deviceFeatures.textureCompressionASTC_LDR) { - _features[(int)GFXFeature::FORMAT_ASTC] = true; + _features[(int)Feature::FORMAT_ASTC] = true; compressedFmts += "astc "; } @@ -257,25 +257,25 @@ bool CCVKDevice::initialize(const GFXDeviceInfo &info) { _gpuSemaphorePool = CC_NEW(CCVKGPUSemaphorePool(_gpuDevice)); _gpuFencePool = CC_NEW(CCVKGPUFencePool(_gpuDevice)); - GFXBufferInfo stagingBufferInfo; - stagingBufferInfo.usage = GFXBufferUsage::TRANSFER_SRC; - stagingBufferInfo.memUsage = GFXMemoryUsage::HOST; + BufferInfo stagingBufferInfo; + stagingBufferInfo.usage = BufferUsage::TRANSFER_SRC; + stagingBufferInfo.memUsage = MemoryUsage::HOST; stagingBufferInfo.stride = _defaultStagingBufferSize; stagingBufferInfo.size = _defaultStagingBufferSize; _stagingBuffer = (CCVKBuffer *)createBuffer(stagingBufferInfo); - GFXQueueInfo queueInfo; - queueInfo.type = GFXQueueType::GRAPHICS; + QueueInfo queueInfo; + queueInfo.type = QueueType::GRAPHICS; queueInfo.forceSync = true; _queue = createQueue(queueInfo); - GFXCommandAllocatorInfo cmdAllocInfo; + CommandAllocatorInfo cmdAllocInfo; _cmdAllocator = createCommandAllocator(cmdAllocInfo); for (uint i = 0u; i < gpuContext->swapchainCreateInfo.minImageCount; i++) { - GFXTextureInfo depthStencilTexInfo; - depthStencilTexInfo.type = GFXTextureType::TEX2D; - depthStencilTexInfo.usage = GFXTextureUsageBit::DEPTH_STENCIL_ATTACHMENT | GFXTextureUsageBit::SAMPLED; + TextureInfo depthStencilTexInfo; + depthStencilTexInfo.type = TextureType::TEX2D; + depthStencilTexInfo.usage = TextureUsageBit::DEPTH_STENCIL_ATTACHMENT | TextureUsageBit::SAMPLED; depthStencilTexInfo.format = _context->getDepthStencilFormat(); depthStencilTexInfo.width = 1; depthStencilTexInfo.height = 1; @@ -283,17 +283,17 @@ bool CCVKDevice::initialize(const GFXDeviceInfo &info) { _depthStencilTextures.push_back(texture); } - GFXTextureInfo textureInfo; - GFXTextureViewInfo texViewInfo; + TextureInfo textureInfo; + TextureViewInfo texViewInfo; - textureInfo.usage = GFXTextureUsageBit::SAMPLED; - textureInfo.format = GFXFormat::RGBA8; + textureInfo.usage = TextureUsageBit::SAMPLED; + textureInfo.format = Format::RGBA8; textureInfo.width = 2; textureInfo.height = 2; nullTexture2D = (CCVKTexture *)createTexture(textureInfo); textureInfo.arrayLayer = 6; - textureInfo.flags = GFXTextureFlagBit::CUBEMAP; + textureInfo.flags = TextureFlagBit::CUBEMAP; nullTextureCube = (CCVKTexture *)createTexture(textureInfo); _gpuSwapchain = CC_NEW(CCVKGPUSwapchain); @@ -528,8 +528,8 @@ void CCVKDevice::present() { VK_CHECK(vkQueuePresentKHR(queue->gpuQueue()->vkQueue, &presentInfo)); } -GFXFence *CCVKDevice::createFence(const GFXFenceInfo &info) { - GFXFence *fence = CC_NEW(CCVKFence(this)); +Fence *CCVKDevice::createFence(const FenceInfo &info) { + Fence *fence = CC_NEW(CCVKFence(this)); if (fence->initialize(info)) return fence; @@ -537,8 +537,8 @@ GFXFence *CCVKDevice::createFence(const GFXFenceInfo &info) { return nullptr; } -GFXQueue *CCVKDevice::createQueue(const GFXQueueInfo &info) { - GFXQueue *queue = CC_NEW(CCVKQueue(this)); +Queue *CCVKDevice::createQueue(const QueueInfo &info) { + Queue *queue = CC_NEW(CCVKQueue(this)); if (queue->initialize(info)) return queue; @@ -546,8 +546,8 @@ GFXQueue *CCVKDevice::createQueue(const GFXQueueInfo &info) { return nullptr; } -GFXCommandAllocator *CCVKDevice::createCommandAllocator(const GFXCommandAllocatorInfo &info) { - GFXCommandAllocator *cmdAllocator = CC_NEW(CCVKCommandAllocator(this)); +CommandAllocator *CCVKDevice::createCommandAllocator(const CommandAllocatorInfo &info) { + CommandAllocator *cmdAllocator = CC_NEW(CCVKCommandAllocator(this)); if (cmdAllocator->initialize(info)) return cmdAllocator; @@ -555,8 +555,8 @@ GFXCommandAllocator *CCVKDevice::createCommandAllocator(const GFXCommandAllocato return nullptr; } -GFXCommandBuffer *CCVKDevice::createCommandBuffer(const GFXCommandBufferInfo &info) { - GFXCommandBuffer *gfx_cmd_buff = CC_NEW(CCVKCommandBuffer(this)); +CommandBuffer *CCVKDevice::createCommandBuffer(const CommandBufferInfo &info) { + CommandBuffer *gfx_cmd_buff = CC_NEW(CCVKCommandBuffer(this)); if (gfx_cmd_buff->initialize(info)) return gfx_cmd_buff; @@ -564,8 +564,8 @@ GFXCommandBuffer *CCVKDevice::createCommandBuffer(const GFXCommandBufferInfo &in return nullptr; } -GFXBuffer *CCVKDevice::createBuffer(const GFXBufferInfo &info) { - GFXBuffer *buffer = CC_NEW(CCVKBuffer(this)); +Buffer *CCVKDevice::createBuffer(const BufferInfo &info) { + Buffer *buffer = CC_NEW(CCVKBuffer(this)); if (buffer->initialize(info)) return buffer; @@ -573,8 +573,8 @@ GFXBuffer *CCVKDevice::createBuffer(const GFXBufferInfo &info) { return nullptr; } -GFXTexture *CCVKDevice::createTexture(const GFXTextureInfo &info) { - GFXTexture *texture = CC_NEW(CCVKTexture(this)); +Texture *CCVKDevice::createTexture(const TextureInfo &info) { + Texture *texture = CC_NEW(CCVKTexture(this)); if (texture->initialize(info)) return texture; @@ -582,8 +582,8 @@ GFXTexture *CCVKDevice::createTexture(const GFXTextureInfo &info) { return nullptr; } -GFXTexture *CCVKDevice::createTexture(const GFXTextureViewInfo &info) { - GFXTexture *texture = CC_NEW(CCVKTexture(this)); +Texture *CCVKDevice::createTexture(const TextureViewInfo &info) { + Texture *texture = CC_NEW(CCVKTexture(this)); if (texture->initialize(info)) return texture; @@ -591,8 +591,8 @@ GFXTexture *CCVKDevice::createTexture(const GFXTextureViewInfo &info) { return nullptr; } -GFXSampler *CCVKDevice::createSampler(const GFXSamplerInfo &info) { - GFXSampler *sampler = CC_NEW(CCVKSampler(this)); +Sampler *CCVKDevice::createSampler(const SamplerInfo &info) { + Sampler *sampler = CC_NEW(CCVKSampler(this)); if (sampler->initialize(info)) return sampler; @@ -600,8 +600,8 @@ GFXSampler *CCVKDevice::createSampler(const GFXSamplerInfo &info) { return nullptr; } -GFXShader *CCVKDevice::createShader(const GFXShaderInfo &info) { - GFXShader *shader = CC_NEW(CCVKShader(this)); +Shader *CCVKDevice::createShader(const ShaderInfo &info) { + Shader *shader = CC_NEW(CCVKShader(this)); if (shader->initialize(info)) return shader; @@ -609,8 +609,8 @@ GFXShader *CCVKDevice::createShader(const GFXShaderInfo &info) { return nullptr; } -GFXInputAssembler *CCVKDevice::createInputAssembler(const GFXInputAssemblerInfo &info) { - GFXInputAssembler *inputAssembler = CC_NEW(CCVKInputAssembler(this)); +InputAssembler *CCVKDevice::createInputAssembler(const InputAssemblerInfo &info) { + InputAssembler *inputAssembler = CC_NEW(CCVKInputAssembler(this)); if (inputAssembler->initialize(info)) return inputAssembler; @@ -618,8 +618,8 @@ GFXInputAssembler *CCVKDevice::createInputAssembler(const GFXInputAssemblerInfo return nullptr; } -GFXRenderPass *CCVKDevice::createRenderPass(const GFXRenderPassInfo &info) { - GFXRenderPass *renderPass = CC_NEW(CCVKRenderPass(this)); +RenderPass *CCVKDevice::createRenderPass(const RenderPassInfo &info) { + RenderPass *renderPass = CC_NEW(CCVKRenderPass(this)); if (renderPass->initialize(info)) return renderPass; @@ -627,8 +627,8 @@ GFXRenderPass *CCVKDevice::createRenderPass(const GFXRenderPassInfo &info) { return nullptr; } -GFXFramebuffer *CCVKDevice::createFramebuffer(const GFXFramebufferInfo &info) { - GFXFramebuffer *framebuffer = CC_NEW(CCVKFramebuffer(this)); +Framebuffer *CCVKDevice::createFramebuffer(const FramebufferInfo &info) { + Framebuffer *framebuffer = CC_NEW(CCVKFramebuffer(this)); if (framebuffer->initialize(info)) return framebuffer; @@ -636,8 +636,8 @@ GFXFramebuffer *CCVKDevice::createFramebuffer(const GFXFramebufferInfo &info) { return nullptr; } -GFXBindingLayout *CCVKDevice::createBindingLayout(const GFXBindingLayoutInfo &info) { - GFXBindingLayout *bindingLayout = CC_NEW(CCVKBindingLayout(this)); +BindingLayout *CCVKDevice::createBindingLayout(const BindingLayoutInfo &info) { + BindingLayout *bindingLayout = CC_NEW(CCVKBindingLayout(this)); if (bindingLayout->initialize(info)) return bindingLayout; @@ -645,8 +645,8 @@ GFXBindingLayout *CCVKDevice::createBindingLayout(const GFXBindingLayoutInfo &in return nullptr; } -GFXPipelineState *CCVKDevice::createPipelineState(const GFXPipelineStateInfo &info) { - GFXPipelineState *pipelineState = CC_NEW(CCVKPipelineState(this)); +PipelineState *CCVKDevice::createPipelineState(const PipelineStateInfo &info) { + PipelineState *pipelineState = CC_NEW(CCVKPipelineState(this)); if (pipelineState->initialize(info)) return pipelineState; @@ -654,8 +654,8 @@ GFXPipelineState *CCVKDevice::createPipelineState(const GFXPipelineStateInfo &in return nullptr; } -GFXPipelineLayout *CCVKDevice::createPipelineLayout(const GFXPipelineLayoutInfo &info) { - GFXPipelineLayout *layout = CC_NEW(CCVKPipelineLayout(this)); +PipelineLayout *CCVKDevice::createPipelineLayout(const PipelineLayoutInfo &info) { + PipelineLayout *layout = CC_NEW(CCVKPipelineLayout(this)); if (layout->initialize(info)) return layout; @@ -663,7 +663,7 @@ GFXPipelineLayout *CCVKDevice::createPipelineLayout(const GFXPipelineLayoutInfo return nullptr; } -void CCVKDevice::copyBuffersToTexture(const GFXDataArray &buffers, GFXTexture *dst, const GFXBufferTextureCopyList ®ions) { +void CCVKDevice::copyBuffersToTexture(const DataArray &buffers, Texture *dst, const BufferTextureCopyList ®ions) { CCVKCmdFuncCopyBuffersToTexture(this, buffers.datas.data(), ((CCVKTexture *)dst)->gpuTexture(), regions); } diff --git a/native/cocos/renderer/gfx-vulkan/VKDevice.h b/native/cocos/renderer/gfx-vulkan/VKDevice.h index 594d4d2210..ec1ddb91b1 100644 --- a/native/cocos/renderer/gfx-vulkan/VKDevice.h +++ b/native/cocos/renderer/gfx-vulkan/VKDevice.h @@ -13,33 +13,33 @@ class CCVKTexture; class CCVKRenderPass; class CCVKBuffer; -class CC_VULKAN_API CCVKDevice : public GFXDevice { +class CC_VULKAN_API CCVKDevice : public Device { public: CCVKDevice(); ~CCVKDevice(); public: - virtual bool initialize(const GFXDeviceInfo &info) override; + virtual bool initialize(const DeviceInfo &info) override; virtual void destroy() override; virtual void resize(uint width, uint height) override; virtual void acquire() override; virtual void present() override; - virtual GFXFence *createFence(const GFXFenceInfo &info) override; - virtual GFXQueue *createQueue(const GFXQueueInfo &info) override; - virtual GFXCommandAllocator *createCommandAllocator(const GFXCommandAllocatorInfo &info) override; - virtual GFXCommandBuffer *createCommandBuffer(const GFXCommandBufferInfo &info) override; - virtual GFXBuffer *createBuffer(const GFXBufferInfo &info) override; - virtual GFXTexture *createTexture(const GFXTextureInfo &info) override; - virtual GFXTexture *createTexture(const GFXTextureViewInfo &info) override; - virtual GFXSampler *createSampler(const GFXSamplerInfo &info) override; - virtual GFXShader *createShader(const GFXShaderInfo &info) override; - virtual GFXInputAssembler *createInputAssembler(const GFXInputAssemblerInfo &info) override; - virtual GFXRenderPass *createRenderPass(const GFXRenderPassInfo &info) override; - virtual GFXFramebuffer *createFramebuffer(const GFXFramebufferInfo &info) override; - virtual GFXBindingLayout *createBindingLayout(const GFXBindingLayoutInfo &info) override; - virtual GFXPipelineState *createPipelineState(const GFXPipelineStateInfo &info) override; - virtual GFXPipelineLayout *createPipelineLayout(const GFXPipelineLayoutInfo &info) override; - virtual void copyBuffersToTexture(const GFXDataArray &buffers, GFXTexture *dst, const GFXBufferTextureCopyList ®ions) override; + virtual Fence *createFence(const FenceInfo &info) override; + virtual Queue *createQueue(const QueueInfo &info) override; + virtual CommandAllocator *createCommandAllocator(const CommandAllocatorInfo &info) override; + virtual CommandBuffer *createCommandBuffer(const CommandBufferInfo &info) override; + virtual Buffer *createBuffer(const BufferInfo &info) override; + virtual Texture *createTexture(const TextureInfo &info) override; + virtual Texture *createTexture(const TextureViewInfo &info) override; + virtual Sampler *createSampler(const SamplerInfo &info) override; + virtual Shader *createShader(const ShaderInfo &info) override; + virtual InputAssembler *createInputAssembler(const InputAssemblerInfo &info) override; + virtual RenderPass *createRenderPass(const RenderPassInfo &info) override; + virtual Framebuffer *createFramebuffer(const FramebufferInfo &info) override; + virtual BindingLayout *createBindingLayout(const BindingLayoutInfo &info) override; + virtual PipelineState *createPipelineState(const PipelineStateInfo &info) override; + virtual PipelineLayout *createPipelineLayout(const PipelineLayoutInfo &info) override; + virtual void copyBuffersToTexture(const DataArray &buffers, Texture *dst, const BufferTextureCopyList ®ions) override; CC_INLINE bool checkExtension(const String &extension) const { return std::find_if(_extensions.begin(), _extensions.end(), diff --git a/native/cocos/renderer/gfx-vulkan/VKFence.cc b/native/cocos/renderer/gfx-vulkan/VKFence.cc index 31a3704da2..19d29e08d3 100644 --- a/native/cocos/renderer/gfx-vulkan/VKFence.cc +++ b/native/cocos/renderer/gfx-vulkan/VKFence.cc @@ -7,14 +7,14 @@ namespace cc { namespace gfx { -CCVKFence::CCVKFence(GFXDevice *device) -: GFXFence(device) { +CCVKFence::CCVKFence(Device *device) +: Fence(device) { } CCVKFence::~CCVKFence() { } -bool CCVKFence::initialize(const GFXFenceInfo &info) { +bool CCVKFence::initialize(const FenceInfo &info) { _gpuFence = CC_NEW(CCVKGPUFence); if (!_gpuFence) { CC_LOG_ERROR("GLES2Fence: CC_NEW CCVKGPUFence failed."); @@ -24,7 +24,7 @@ bool CCVKFence::initialize(const GFXFenceInfo &info) { VkFenceCreateInfo createInfo{VK_STRUCTURE_TYPE_FENCE_CREATE_INFO}; VK_CHECK(vkCreateFence(((CCVKDevice *)_device)->gpuDevice()->vkDevice, &createInfo, nullptr, &_gpuFence->vkFence)); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -35,7 +35,7 @@ void CCVKFence::destroy() { CC_DELETE(_gpuFence); _gpuFence = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void CCVKFence::wait() { diff --git a/native/cocos/renderer/gfx-vulkan/VKFence.h b/native/cocos/renderer/gfx-vulkan/VKFence.h index a5d29d439a..9e1485ea83 100644 --- a/native/cocos/renderer/gfx-vulkan/VKFence.h +++ b/native/cocos/renderer/gfx-vulkan/VKFence.h @@ -6,13 +6,13 @@ namespace gfx { class CCVKGPUFence; -class CC_VULKAN_API CCVKFence : public GFXFence { +class CC_VULKAN_API CCVKFence : public Fence { public: - CCVKFence(GFXDevice *device); + CCVKFence(Device *device); virtual ~CCVKFence() override; public: - virtual bool initialize(const GFXFenceInfo &info) override; + virtual bool initialize(const FenceInfo &info) override; virtual void destroy() override; virtual void wait() override; virtual void reset() override; diff --git a/native/cocos/renderer/gfx-vulkan/VKFramebuffer.cc b/native/cocos/renderer/gfx-vulkan/VKFramebuffer.cc index 6ab06ef153..038bb4197e 100644 --- a/native/cocos/renderer/gfx-vulkan/VKFramebuffer.cc +++ b/native/cocos/renderer/gfx-vulkan/VKFramebuffer.cc @@ -9,14 +9,14 @@ namespace cc { namespace gfx { -CCVKFramebuffer::CCVKFramebuffer(GFXDevice *device) -: GFXFramebuffer(device) { +CCVKFramebuffer::CCVKFramebuffer(Device *device) +: Framebuffer(device) { } CCVKFramebuffer::~CCVKFramebuffer() { } -bool CCVKFramebuffer::initialize(const GFXFramebufferInfo &info) { +bool CCVKFramebuffer::initialize(const FramebufferInfo &info) { _renderPass = info.renderPass; _colorTextures = info.colorTextures; _depthStencilTexture = info.depthStencilTexture; @@ -41,7 +41,7 @@ bool CCVKFramebuffer::initialize(const GFXFramebufferInfo &info) { CCVKCmdFuncCreateFramebuffer((CCVKDevice *)_device, _gpuFBO); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -55,7 +55,7 @@ void CCVKFramebuffer::destroy() { _gpuFBO = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-vulkan/VKFramebuffer.h b/native/cocos/renderer/gfx-vulkan/VKFramebuffer.h index f5cdc37abc..38366d6a8b 100644 --- a/native/cocos/renderer/gfx-vulkan/VKFramebuffer.h +++ b/native/cocos/renderer/gfx-vulkan/VKFramebuffer.h @@ -6,13 +6,13 @@ namespace gfx { class CCVKGPUFramebuffer; -class CC_VULKAN_API CCVKFramebuffer : public GFXFramebuffer { +class CC_VULKAN_API CCVKFramebuffer : public Framebuffer { public: - CCVKFramebuffer(GFXDevice *device); + CCVKFramebuffer(Device *device); ~CCVKFramebuffer(); public: - bool initialize(const GFXFramebufferInfo &info); + bool initialize(const FramebufferInfo &info); void destroy(); CC_INLINE CCVKGPUFramebuffer *gpuFBO() const { return _gpuFBO; } diff --git a/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h b/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h index d48cd22030..bf37120a01 100644 --- a/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h +++ b/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h @@ -37,26 +37,26 @@ public: class CCVKGPURenderPass : public Object { public: - GFXColorAttachmentList colorAttachments; - GFXDepthStencilAttachment depthStencilAttachment; - GFXSubPassList subPasses; + ColorAttachmentList colorAttachments; + DepthStencilAttachment depthStencilAttachment; + SubPassList subPasses; VkRenderPass vkRenderPass; vector clearValues; }; class CCVKGPUTexture : public Object { public: - GFXTextureType type = GFXTextureType::TEX2D; - GFXFormat format = GFXFormat::UNKNOWN; - GFXTextureUsage usage = GFXTextureUsageBit::NONE; + TextureType type = TextureType::TEX2D; + Format format = Format::UNKNOWN; + TextureUsage usage = TextureUsageBit::NONE; uint width = 0; uint height = 0; uint depth = 1; uint size = 0; uint arrayLayer = 1; uint mipLevel = 1; - GFXSampleCount samples = GFXSampleCount::X1; - GFXTextureFlags flags = GFXTextureFlagBit::NONE; + SampleCount samples = SampleCount::X1; + TextureFlags flags = TextureFlagBit::NONE; bool isPowerOf2 = false; VkImage vkImage = VK_NULL_HANDLE; @@ -70,8 +70,8 @@ public: class CCVKGPUTextureView : public Object { public: CCVKGPUTexture *gpuTexture = nullptr; - GFXTextureType type = GFXTextureType::TEX2D; - GFXFormat format = GFXFormat::UNKNOWN; + TextureType type = TextureType::TEX2D; + Format format = Format::UNKNOWN; uint baseLevel = 0; uint levelCount = 1; VkImageView vkImageView = VK_NULL_HANDLE; @@ -115,14 +115,14 @@ public: class CCVKGPUCommandBuffer : public Object { public: - GFXCommandBufferType type; + CommandBufferType type; CCVKGPUCommandPool *commandPool = nullptr; VkCommandBuffer vkCommandBuffer = VK_NULL_HANDLE; }; class CCVKGPUQueue : public Object { public: - GFXQueueType type; + QueueType type; VkQueue vkQueue; uint queueFamilyIndex; VkSemaphore nextWaitSemaphore = VK_NULL_HANDLE; @@ -133,8 +133,8 @@ public: class CCVKGPUBuffer : public Object { public: - GFXBufferUsage usage = GFXBufferUsage::NONE; - GFXMemoryUsage memUsage = GFXMemoryUsage::NONE; + BufferUsage usage = BufferUsage::NONE; + MemoryUsage memUsage = MemoryUsage::NONE; uint size = 0; uint stride = 0; uint count = 0; @@ -153,15 +153,15 @@ typedef vector CCVKGPUBufferList; class CCVKGPUSampler : public Object { public: - GFXFilter minFilter = GFXFilter::LINEAR; - GFXFilter magFilter = GFXFilter::LINEAR; - GFXFilter mipFilter = GFXFilter::NONE; - GFXAddress addressU = GFXAddress::WRAP; - GFXAddress addressV = GFXAddress::WRAP; - GFXAddress addressW = GFXAddress::WRAP; + Filter minFilter = Filter::LINEAR; + Filter magFilter = Filter::LINEAR; + Filter mipFilter = Filter::NONE; + Address addressU = Address::WRAP; + Address addressV = Address::WRAP; + Address addressW = Address::WRAP; uint maxAnisotropy = 16; - GFXComparisonFunc cmpFunc = GFXComparisonFunc::NEVER; - GFXColor borderColor; + ComparisonFunc cmpFunc = ComparisonFunc::NEVER; + Color borderColor; uint minLOD = 0; uint maxLOD = 1000; float mipLODBias = 0.0f; @@ -169,12 +169,12 @@ public: }; struct CCVKGPUShaderStage { - CCVKGPUShaderStage(GFXShaderType t, String s, GFXShaderMacroList m) + CCVKGPUShaderStage(ShaderType t, String s, ShaderMacroList m) : type(t), source(s), macros(m) { } - GFXShaderType type; + ShaderType type; String source; - GFXShaderMacroList macros; + ShaderMacroList macros; VkShaderModule vkShader = VK_NULL_HANDLE; }; typedef vector CCVKGPUShaderStageList; @@ -182,15 +182,15 @@ typedef vector CCVKGPUShaderStageList; class CCVKGPUShader : public Object { public: String name; - GFXAttributeList attributes; - GFXUniformBlockList blocks; - GFXUniformSamplerList samplers; + AttributeList attributes; + UniformBlockList blocks; + UniformSamplerList samplers; CCVKGPUShaderStageList gpuStages; }; class CCVKGPUInputAssembler : public Object { public: - GFXAttributeList attributes; + AttributeList attributes; CCVKGPUBufferList gpuVertexBuffers; CCVKGPUBuffer *gpuIndexBuffer = nullptr; CCVKGPUBuffer *gpuIndirectBuffer = nullptr; @@ -208,20 +208,20 @@ public: class CCVKGPUPipelineLayout : public Object { public: - GFXPushConstantRangeList pushConstantRanges; + PushConstantRangeList pushConstantRanges; vector gpuBindingLayouts; VkPipelineLayout vkPipelineLayout; }; class CCVKGPUPipelineState : public Object { public: - GFXPrimitiveMode primitive = GFXPrimitiveMode::TRIANGLE_LIST; + PrimitiveMode primitive = PrimitiveMode::TRIANGLE_LIST; CCVKGPUShader *gpuShader = nullptr; - GFXInputState inputState; - GFXRasterizerState rs; - GFXDepthStencilState dss; - GFXBlendState bs; - GFXDynamicStateList dynamicStates; + InputState inputState; + RasterizerState rs; + DepthStencilState dss; + BlendState bs; + DynamicStateList dynamicStates; CCVKGPUPipelineLayout *gpuLayout = nullptr; CCVKGPURenderPass *gpuRenderPass = nullptr; VkPipeline vkPipeline = VK_NULL_HANDLE; diff --git a/native/cocos/renderer/gfx-vulkan/VKInputAssembler.cc b/native/cocos/renderer/gfx-vulkan/VKInputAssembler.cc index 82c017e76e..ee4768732b 100644 --- a/native/cocos/renderer/gfx-vulkan/VKInputAssembler.cc +++ b/native/cocos/renderer/gfx-vulkan/VKInputAssembler.cc @@ -7,14 +7,14 @@ namespace cc { namespace gfx { -CCVKInputAssembler::CCVKInputAssembler(GFXDevice *device) -: GFXInputAssembler(device) { +CCVKInputAssembler::CCVKInputAssembler(Device *device) +: InputAssembler(device) { } CCVKInputAssembler::~CCVKInputAssembler() { } -bool CCVKInputAssembler::initialize(const GFXInputAssemblerInfo &info) { +bool CCVKInputAssembler::initialize(const InputAssemblerInfo &info) { _attributes = info.attributes; _vertexBuffers = info.vertexBuffers; _indexBuffer = info.indexBuffer; @@ -45,7 +45,7 @@ bool CCVKInputAssembler::initialize(const GFXInputAssemblerInfo &info) { CCVKCmdFuncCreateInputAssembler((CCVKDevice *)_device, _gpuInputAssembler); _attributesHash = computeAttributesHash(); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -57,7 +57,7 @@ void CCVKInputAssembler::destroy() { _gpuInputAssembler = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-vulkan/VKInputAssembler.h b/native/cocos/renderer/gfx-vulkan/VKInputAssembler.h index 64473f7cf1..f6a97f0bf1 100644 --- a/native/cocos/renderer/gfx-vulkan/VKInputAssembler.h +++ b/native/cocos/renderer/gfx-vulkan/VKInputAssembler.h @@ -6,13 +6,13 @@ namespace gfx { class CCVKGPUInputAssembler; -class CC_VULKAN_API CCVKInputAssembler : public GFXInputAssembler { +class CC_VULKAN_API CCVKInputAssembler : public InputAssembler { public: - CCVKInputAssembler(GFXDevice *device); + CCVKInputAssembler(Device *device); ~CCVKInputAssembler(); public: - bool initialize(const GFXInputAssemblerInfo &info); + bool initialize(const InputAssemblerInfo &info); void destroy(); CC_INLINE CCVKGPUInputAssembler *gpuInputAssembler() const { return _gpuInputAssembler; } diff --git a/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.cc b/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.cc index 1e8d9f4696..b309f34c2b 100644 --- a/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.cc +++ b/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.cc @@ -7,14 +7,14 @@ namespace cc { namespace gfx { -CCVKPipelineLayout::CCVKPipelineLayout(GFXDevice *device) -: GFXPipelineLayout(device) { +CCVKPipelineLayout::CCVKPipelineLayout(Device *device) +: PipelineLayout(device) { } CCVKPipelineLayout::~CCVKPipelineLayout() { } -bool CCVKPipelineLayout::initialize(const GFXPipelineLayoutInfo &info) { +bool CCVKPipelineLayout::initialize(const PipelineLayoutInfo &info) { _layouts = info.layouts; _pushConstantsRanges = info.pushConstantsRanges; @@ -29,7 +29,7 @@ bool CCVKPipelineLayout::initialize(const GFXPipelineLayoutInfo &info) { CCVKCmdFuncCreatePipelineLayout((CCVKDevice *)_device, _gpuPipelineLayout); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -39,7 +39,7 @@ void CCVKPipelineLayout::destroy() { CC_DELETE(_gpuPipelineLayout); _gpuPipelineLayout = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.h b/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.h index 0b7227634c..5b90f835aa 100644 --- a/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.h +++ b/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.h @@ -6,13 +6,13 @@ namespace gfx { class CCVKGPUPipelineLayout; -class CC_VULKAN_API CCVKPipelineLayout : public GFXPipelineLayout { +class CC_VULKAN_API CCVKPipelineLayout : public PipelineLayout { public: - CCVKPipelineLayout(GFXDevice *device); + CCVKPipelineLayout(Device *device); ~CCVKPipelineLayout(); public: - bool initialize(const GFXPipelineLayoutInfo &info); + bool initialize(const PipelineLayoutInfo &info); void destroy(); CC_INLINE CCVKGPUPipelineLayout *gpuPipelineLayout() const { return _gpuPipelineLayout; } diff --git a/native/cocos/renderer/gfx-vulkan/VKPipelineState.cc b/native/cocos/renderer/gfx-vulkan/VKPipelineState.cc index 6f7497b66b..7eb6af7236 100644 --- a/native/cocos/renderer/gfx-vulkan/VKPipelineState.cc +++ b/native/cocos/renderer/gfx-vulkan/VKPipelineState.cc @@ -9,14 +9,14 @@ namespace cc { namespace gfx { -CCVKPipelineState::CCVKPipelineState(GFXDevice *device) -: GFXPipelineState(device) { +CCVKPipelineState::CCVKPipelineState(Device *device) +: PipelineState(device) { } CCVKPipelineState::~CCVKPipelineState() { } -bool CCVKPipelineState::initialize(const GFXPipelineStateInfo &info) { +bool CCVKPipelineState::initialize(const PipelineStateInfo &info) { _primitive = info.primitive; _shader = info.shader; _inputState = info.inputState; @@ -40,7 +40,7 @@ bool CCVKPipelineState::initialize(const GFXPipelineStateInfo &info) { CCVKCmdFuncCreatePipelineState((CCVKDevice *)_device, _gpuPipelineState); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -51,7 +51,7 @@ void CCVKPipelineState::destroy() { CC_DELETE(_gpuPipelineState); _gpuPipelineState = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-vulkan/VKPipelineState.h b/native/cocos/renderer/gfx-vulkan/VKPipelineState.h index 676b960651..24953044fb 100644 --- a/native/cocos/renderer/gfx-vulkan/VKPipelineState.h +++ b/native/cocos/renderer/gfx-vulkan/VKPipelineState.h @@ -6,13 +6,13 @@ namespace gfx { class CCVKGPUPipelineState; -class CC_VULKAN_API CCVKPipelineState : public GFXPipelineState { +class CC_VULKAN_API CCVKPipelineState : public PipelineState { public: - CCVKPipelineState(GFXDevice *device); + CCVKPipelineState(Device *device); ~CCVKPipelineState(); public: - bool initialize(const GFXPipelineStateInfo &info); + bool initialize(const PipelineStateInfo &info); void destroy(); CC_INLINE CCVKGPUPipelineState *gpuPipelineState() const { return _gpuPipelineState; } diff --git a/native/cocos/renderer/gfx-vulkan/VKQueue.cc b/native/cocos/renderer/gfx-vulkan/VKQueue.cc index e01701075b..41bcf4d142 100644 --- a/native/cocos/renderer/gfx-vulkan/VKQueue.cc +++ b/native/cocos/renderer/gfx-vulkan/VKQueue.cc @@ -9,14 +9,14 @@ namespace cc { namespace gfx { -CCVKQueue::CCVKQueue(GFXDevice *device) -: GFXQueue(device) { +CCVKQueue::CCVKQueue(Device *device) +: Queue(device) { } CCVKQueue::~CCVKQueue() { } -bool CCVKQueue::initialize(const GFXQueueInfo &info) { +bool CCVKQueue::initialize(const QueueInfo &info) { _type = info.type; _isAsync = !info.forceSync; @@ -24,7 +24,7 @@ bool CCVKQueue::initialize(const GFXQueueInfo &info) { _gpuQueue->type = _type; CCVKCmdFuncGetDeviceQueue((CCVKDevice *)_device, _gpuQueue); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -34,10 +34,10 @@ void CCVKQueue::destroy() { CC_DELETE(_gpuQueue); _gpuQueue = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } -void CCVKQueue::submit(const vector &cmdBuffs, GFXFence *fence) { +void CCVKQueue::submit(const vector &cmdBuffs, Fence *fence) { CCVKDevice *device = (CCVKDevice *)_device; _gpuQueue->commandBuffers.clear(); diff --git a/native/cocos/renderer/gfx-vulkan/VKQueue.h b/native/cocos/renderer/gfx-vulkan/VKQueue.h index 5e8513578b..e26338f181 100644 --- a/native/cocos/renderer/gfx-vulkan/VKQueue.h +++ b/native/cocos/renderer/gfx-vulkan/VKQueue.h @@ -6,17 +6,17 @@ namespace gfx { class CCVKGPUQueue; -class CC_VULKAN_API CCVKQueue : public GFXQueue { +class CC_VULKAN_API CCVKQueue : public Queue { public: - CCVKQueue(GFXDevice *device); + CCVKQueue(Device *device); ~CCVKQueue(); friend class CCVKDevice; public: - bool initialize(const GFXQueueInfo &info); + bool initialize(const QueueInfo &info); void destroy(); - void submit(const vector &cmdBuffs, GFXFence *fence); + void submit(const vector &cmdBuffs, Fence *fence); CC_INLINE CCVKGPUQueue *gpuQueue() const { return _gpuQueue; } diff --git a/native/cocos/renderer/gfx-vulkan/VKRenderPass.cc b/native/cocos/renderer/gfx-vulkan/VKRenderPass.cc index 7c8ca80c40..cf53d7e3b3 100644 --- a/native/cocos/renderer/gfx-vulkan/VKRenderPass.cc +++ b/native/cocos/renderer/gfx-vulkan/VKRenderPass.cc @@ -6,14 +6,14 @@ namespace cc { namespace gfx { -CCVKRenderPass::CCVKRenderPass(GFXDevice *device) -: GFXRenderPass(device) { +CCVKRenderPass::CCVKRenderPass(Device *device) +: RenderPass(device) { } CCVKRenderPass::~CCVKRenderPass() { } -bool CCVKRenderPass::initialize(const GFXRenderPassInfo &info) { +bool CCVKRenderPass::initialize(const RenderPassInfo &info) { _colorAttachments = info.colorAttachments; _depthStencilAttachment = info.depthStencilAttachment; _subPasses = info.subPasses; @@ -25,7 +25,7 @@ bool CCVKRenderPass::initialize(const GFXRenderPassInfo &info) { CCVKCmdFuncCreateRenderPass((CCVKDevice *)_device, _gpuRenderPass); _hash = computeHash(); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -37,7 +37,7 @@ void CCVKRenderPass::destroy() { _gpuRenderPass = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-vulkan/VKRenderPass.h b/native/cocos/renderer/gfx-vulkan/VKRenderPass.h index c6eecdf434..813261c151 100644 --- a/native/cocos/renderer/gfx-vulkan/VKRenderPass.h +++ b/native/cocos/renderer/gfx-vulkan/VKRenderPass.h @@ -6,13 +6,13 @@ namespace gfx { class CCVKGPURenderPass; -class CC_VULKAN_API CCVKRenderPass : public GFXRenderPass { +class CC_VULKAN_API CCVKRenderPass : public RenderPass { public: - CCVKRenderPass(GFXDevice *device); + CCVKRenderPass(Device *device); ~CCVKRenderPass(); public: - bool initialize(const GFXRenderPassInfo &info); + bool initialize(const RenderPassInfo &info); void destroy(); CC_INLINE CCVKGPURenderPass *gpuRenderPass() const { return _gpuRenderPass; } diff --git a/native/cocos/renderer/gfx-vulkan/VKSPIRV.h b/native/cocos/renderer/gfx-vulkan/VKSPIRV.h index f4f6a994e9..374c28aa90 100644 --- a/native/cocos/renderer/gfx-vulkan/VKSPIRV.h +++ b/native/cocos/renderer/gfx-vulkan/VKSPIRV.h @@ -9,16 +9,16 @@ namespace cc { namespace gfx { namespace { -EShLanguage getShaderStage(GFXShaderType type) { +EShLanguage getShaderStage(ShaderType type) { switch (type) { - case GFXShaderType::VERTEX: return EShLangVertex; - case GFXShaderType::CONTROL: return EShLangTessControl; - case GFXShaderType::EVALUATION: return EShLangTessEvaluation; - case GFXShaderType::GEOMETRY: return EShLangGeometry; - case GFXShaderType::FRAGMENT: return EShLangFragment; - case GFXShaderType::COMPUTE: return EShLangCompute; + case ShaderType::VERTEX: return EShLangVertex; + case ShaderType::CONTROL: return EShLangTessControl; + case ShaderType::EVALUATION: return EShLangTessEvaluation; + case ShaderType::GEOMETRY: return EShLangGeometry; + case ShaderType::FRAGMENT: return EShLangFragment; + case ShaderType::COMPUTE: return EShLangCompute; default: { - CCASSERT(false, "Unsupported GFXShaderType, convert to EShLanguage failed."); + CCASSERT(false, "Unsupported ShaderType, convert to EShLanguage failed."); return EShLangVertex; } } @@ -50,7 +50,7 @@ glslang::EShTargetLanguageVersion getTargetVersion(int vulkanMinorVersion) { bool glslangInitialized = false; -const vector GLSL2SPIRV(GFXShaderType type, const String &source, int vulkanMinorVersion = 0) { +const vector GLSL2SPIRV(ShaderType type, const String &source, int vulkanMinorVersion = 0) { if (!glslangInitialized) { glslang::InitializeProcess(); glslangInitialized = true; diff --git a/native/cocos/renderer/gfx-vulkan/VKSampler.cc b/native/cocos/renderer/gfx-vulkan/VKSampler.cc index f6b9bbe97d..0bf9b3871b 100644 --- a/native/cocos/renderer/gfx-vulkan/VKSampler.cc +++ b/native/cocos/renderer/gfx-vulkan/VKSampler.cc @@ -6,14 +6,14 @@ namespace cc { namespace gfx { -CCVKSampler::CCVKSampler(GFXDevice *device) -: GFXSampler(device) { +CCVKSampler::CCVKSampler(Device *device) +: Sampler(device) { } CCVKSampler::~CCVKSampler() { } -bool CCVKSampler::initialize(const GFXSamplerInfo &info) { +bool CCVKSampler::initialize(const SamplerInfo &info) { _name = info.name; _minFilter = info.minFilter; _magFilter = info.magFilter; @@ -44,7 +44,7 @@ bool CCVKSampler::initialize(const GFXSamplerInfo &info) { CCVKCmdFuncCreateSampler((CCVKDevice *)_device, _gpuSampler); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -55,7 +55,7 @@ void CCVKSampler::destroy() { CC_DELETE(_gpuSampler); _gpuSampler = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-vulkan/VKSampler.h b/native/cocos/renderer/gfx-vulkan/VKSampler.h index 344ea29108..c909b23f81 100644 --- a/native/cocos/renderer/gfx-vulkan/VKSampler.h +++ b/native/cocos/renderer/gfx-vulkan/VKSampler.h @@ -6,13 +6,13 @@ namespace gfx { class CCVKGPUSampler; -class CC_VULKAN_API CCVKSampler : public GFXSampler { +class CC_VULKAN_API CCVKSampler : public Sampler { public: - CCVKSampler(GFXDevice *device); + CCVKSampler(Device *device); ~CCVKSampler(); public: - bool initialize(const GFXSamplerInfo &info); + bool initialize(const SamplerInfo &info); void destroy(); CC_INLINE CCVKGPUSampler *gpuSampler() const { return _gpuSampler; } diff --git a/native/cocos/renderer/gfx-vulkan/VKShader.cc b/native/cocos/renderer/gfx-vulkan/VKShader.cc index 28408bb08a..cc1809e396 100644 --- a/native/cocos/renderer/gfx-vulkan/VKShader.cc +++ b/native/cocos/renderer/gfx-vulkan/VKShader.cc @@ -6,14 +6,14 @@ namespace cc { namespace gfx { -CCVKShader::CCVKShader(GFXDevice *device) -: GFXShader(device) { +CCVKShader::CCVKShader(Device *device) +: Shader(device) { } CCVKShader::~CCVKShader() { } -bool CCVKShader::initialize(const GFXShaderInfo &info) { +bool CCVKShader::initialize(const ShaderInfo &info) { _name = info.name; _stages = info.stages; _attributes = info.attributes; @@ -25,13 +25,13 @@ bool CCVKShader::initialize(const GFXShaderInfo &info) { _gpuShader->attributes = _attributes; _gpuShader->blocks = _blocks; _gpuShader->samplers = _samplers; - for (GFXShaderStage &stage : _stages) { + for (ShaderStage &stage : _stages) { _gpuShader->gpuStages.push_back({stage.type, stage.source, stage.macros}); } CCVKCmdFuncCreateShader((CCVKDevice *)_device, _gpuShader); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } @@ -43,7 +43,7 @@ void CCVKShader::destroy() { _gpuShader = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-vulkan/VKShader.h b/native/cocos/renderer/gfx-vulkan/VKShader.h index fa8d026aef..733688a2d7 100644 --- a/native/cocos/renderer/gfx-vulkan/VKShader.h +++ b/native/cocos/renderer/gfx-vulkan/VKShader.h @@ -6,13 +6,13 @@ namespace gfx { class CCVKGPUShader; -class CC_VULKAN_API CCVKShader : public GFXShader { +class CC_VULKAN_API CCVKShader : public Shader { public: - CCVKShader(GFXDevice *device); + CCVKShader(Device *device); ~CCVKShader(); public: - bool initialize(const GFXShaderInfo &info); + bool initialize(const ShaderInfo &info); void destroy(); CC_INLINE CCVKGPUShader *gpuShader() const { return _gpuShader; } diff --git a/native/cocos/renderer/gfx-vulkan/VKTexture.cc b/native/cocos/renderer/gfx-vulkan/VKTexture.cc index d5369fc7a8..cd39c9303a 100644 --- a/native/cocos/renderer/gfx-vulkan/VKTexture.cc +++ b/native/cocos/renderer/gfx-vulkan/VKTexture.cc @@ -6,14 +6,14 @@ namespace cc { namespace gfx { -CCVKTexture::CCVKTexture(GFXDevice *device) -: GFXTexture(device) { +CCVKTexture::CCVKTexture(Device *device) +: Texture(device) { } CCVKTexture::~CCVKTexture() { } -bool CCVKTexture::initialize(const GFXTextureInfo &info) { +bool CCVKTexture::initialize(const TextureInfo &info) { _type = info.type; _usage = info.usage; _format = info.format; @@ -24,42 +24,42 @@ bool CCVKTexture::initialize(const GFXTextureInfo &info) { _mipLevel = info.mipLevel; _samples = info.samples; _flags = info.flags; - _size = GFXFormatSize(_format, _width, _height, _depth); + _size = FormatSize(_format, _width, _height, _depth); #if COCOS2D_DEBUG > 0 switch (_format) { // device feature validation - case GFXFormat::D16: - if (_device->hasFeature(GFXFeature::FORMAT_D16)) break; + case Format::D16: + if (_device->hasFeature(Feature::FORMAT_D16)) break; CC_LOG_ERROR("D16 texture format is not supported on this backend"); return false; - case GFXFormat::D16S8: - if (_device->hasFeature(GFXFeature::FORMAT_D16S8)) break; + case Format::D16S8: + if (_device->hasFeature(Feature::FORMAT_D16S8)) break; CC_LOG_WARNING("D16S8 texture format is not supported on this backend"); return false; - case GFXFormat::D24: - if (_device->hasFeature(GFXFeature::FORMAT_D24)) break; + case Format::D24: + if (_device->hasFeature(Feature::FORMAT_D24)) break; CC_LOG_WARNING("D24 texture format is not supported on this backend"); return false; - case GFXFormat::D24S8: - if (_device->hasFeature(GFXFeature::FORMAT_D24S8)) break; + case Format::D24S8: + if (_device->hasFeature(Feature::FORMAT_D24S8)) break; CC_LOG_WARNING("D24S8 texture format is not supported on this backend"); return false; - case GFXFormat::D32F: - if (_device->hasFeature(GFXFeature::FORMAT_D32F)) break; + case Format::D32F: + if (_device->hasFeature(Feature::FORMAT_D32F)) break; CC_LOG_WARNING("D32F texture format is not supported on this backend"); return false; - case GFXFormat::D32F_S8: - if (_device->hasFeature(GFXFeature::FORMAT_D32FS8)) break; + case Format::D32F_S8: + if (_device->hasFeature(Feature::FORMAT_D32FS8)) break; CC_LOG_WARNING("D32FS8 texture format is not supported on this backend"); return false; - case GFXFormat::RGB8: - if (_device->hasFeature(GFXFeature::FORMAT_RGB8)) break; + case Format::RGB8: + if (_device->hasFeature(Feature::FORMAT_RGB8)) break; CC_LOG_WARNING("RGB8 texture format is not supported on this backend"); return false; } #endif - if (_flags & GFXTextureFlags::BAKUP_BUFFER) { + if (_flags & TextureFlags::BAKUP_BUFFER) { _buffer = (uint8_t *)CC_MALLOC(_size); _device->getMemoryStatus().textureSize += _size; } @@ -81,7 +81,7 @@ bool CCVKTexture::initialize(const GFXTextureInfo &info) { CCVKCmdFuncCreateTexture((CCVKDevice *)_device, _gpuTexture); _device->getMemoryStatus().textureSize += _size; - GFXTextureViewInfo textureViewInfo; + TextureViewInfo textureViewInfo; textureViewInfo.texture = this; textureViewInfo.type = _type; textureViewInfo.format = _format; @@ -91,11 +91,11 @@ bool CCVKTexture::initialize(const GFXTextureInfo &info) { textureViewInfo.layerCount = _arrayLayer; createTextureView(textureViewInfo); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } -bool CCVKTexture::initialize(const GFXTextureViewInfo &info) { +bool CCVKTexture::initialize(const TextureViewInfo &info) { if (info.texture) { _type = info.texture->getType(); _format = info.texture->getFormat(); @@ -107,16 +107,16 @@ bool CCVKTexture::initialize(const GFXTextureViewInfo &info) { _depth = info.texture->getDepth(); _samples = info.texture->getSamples(); _flags = info.texture->getFlags(); - _size = GFXFormatSize(_format, _width, _height, _depth); + _size = FormatSize(_format, _width, _height, _depth); } createTextureView(info); - _status = GFXStatus::SUCCESS; + _status = Status::SUCCESS; return true; } -void CCVKTexture::createTextureView(const GFXTextureViewInfo &info) { +void CCVKTexture::createTextureView(const TextureViewInfo &info) { if (!_gpuTextureView) { _gpuTextureView = CC_NEW(CCVKGPUTextureView); } @@ -147,18 +147,18 @@ void CCVKTexture::destroy() { _device->getMemoryStatus().textureSize -= _size; _buffer = nullptr; } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } void CCVKTexture::resize(uint width, uint height) { - uint size = GFXFormatSize(_format, width, height, _depth); + uint size = FormatSize(_format, width, height, _depth); if (_size != size) { const uint old_size = _size; _width = width; _height = height; _size = size; - GFXMemoryStatus &status = _device->getMemoryStatus(); + MemoryStatus &status = _device->getMemoryStatus(); _gpuTexture->width = _width; _gpuTexture->height = _height; _gpuTexture->size = _size; @@ -181,7 +181,7 @@ void CCVKTexture::resize(uint width, uint height) { } } - _status = GFXStatus::UNREADY; + _status = Status::UNREADY; } } // namespace gfx diff --git a/native/cocos/renderer/gfx-vulkan/VKTexture.h b/native/cocos/renderer/gfx-vulkan/VKTexture.h index d2867a7e79..7075087427 100644 --- a/native/cocos/renderer/gfx-vulkan/VKTexture.h +++ b/native/cocos/renderer/gfx-vulkan/VKTexture.h @@ -7,14 +7,14 @@ namespace gfx { class CCVKGPUTexture; class CCVKGPUTextureView; -class CC_VULKAN_API CCVKTexture : public GFXTexture { +class CC_VULKAN_API CCVKTexture : public Texture { public: - CCVKTexture(GFXDevice *device); + CCVKTexture(Device *device); ~CCVKTexture(); public: - bool initialize(const GFXTextureInfo &info); - bool initialize(const GFXTextureViewInfo &info); + bool initialize(const TextureInfo &info); + bool initialize(const TextureViewInfo &info); void destroy(); void resize(uint width, uint height); @@ -22,7 +22,7 @@ public: CC_INLINE CCVKGPUTextureView *gpuTextureView() const { return _gpuTextureView; } private: - void createTextureView(const GFXTextureViewInfo &info); + void createTextureView(const TextureViewInfo &info); CCVKGPUTexture *_gpuTexture = nullptr; CCVKGPUTextureView *_gpuTextureView = nullptr; diff --git a/native/cocos/renderer/gfx-vulkan/VKUtils.h b/native/cocos/renderer/gfx-vulkan/VKUtils.h index d482b06fab..dbf547fad4 100644 --- a/native/cocos/renderer/gfx-vulkan/VKUtils.h +++ b/native/cocos/renderer/gfx-vulkan/VKUtils.h @@ -12,100 +12,100 @@ namespace cc { namespace gfx { namespace { -VkFormat MapVkFormat(GFXFormat format) { +VkFormat MapVkFormat(Format format) { switch (format) { - case GFXFormat::R8: return VK_FORMAT_R8_UNORM; - case GFXFormat::R8SN: return VK_FORMAT_R8_SNORM; - case GFXFormat::R8UI: return VK_FORMAT_R8_UINT; - case GFXFormat::R8I: return VK_FORMAT_R8_SINT; - case GFXFormat::RG8: return VK_FORMAT_R8G8_UNORM; - case GFXFormat::RG8SN: return VK_FORMAT_R8G8_SNORM; - case GFXFormat::RG8UI: return VK_FORMAT_R8G8_UINT; - case GFXFormat::RG8I: return VK_FORMAT_R8G8_SINT; - case GFXFormat::RGB8: return VK_FORMAT_R8G8B8_UNORM; - case GFXFormat::RGB8SN: return VK_FORMAT_R8G8B8_SNORM; - case GFXFormat::RGB8UI: return VK_FORMAT_R8G8B8_UINT; - case GFXFormat::RGB8I: return VK_FORMAT_R8G8B8_SINT; - case GFXFormat::RGBA8: return VK_FORMAT_R8G8B8A8_UNORM; - case GFXFormat::BGRA8: return VK_FORMAT_B8G8R8A8_UNORM; - case GFXFormat::RGBA8SN: return VK_FORMAT_R8G8B8A8_SNORM; - case GFXFormat::RGBA8UI: return VK_FORMAT_R8G8B8A8_UINT; - case GFXFormat::RGBA8I: return VK_FORMAT_R8G8B8A8_SINT; - case GFXFormat::R16I: return VK_FORMAT_R16_SINT; - case GFXFormat::R16UI: return VK_FORMAT_R16_UINT; - case GFXFormat::R16F: return VK_FORMAT_R16_SFLOAT; - case GFXFormat::RG16I: return VK_FORMAT_R16G16_SINT; - case GFXFormat::RG16UI: return VK_FORMAT_R16G16_UINT; - case GFXFormat::RG16F: return VK_FORMAT_R16G16_SFLOAT; - case GFXFormat::RGB16I: return VK_FORMAT_R16G16B16_SINT; - case GFXFormat::RGB16UI: return VK_FORMAT_R16G16B16_UINT; - case GFXFormat::RGB16F: return VK_FORMAT_R16G16B16_SFLOAT; - case GFXFormat::RGBA16I: return VK_FORMAT_R16G16B16A16_SINT; - case GFXFormat::RGBA16UI: return VK_FORMAT_R16G16B16A16_UINT; - case GFXFormat::RGBA16F: return VK_FORMAT_R16G16B16A16_SFLOAT; - case GFXFormat::R32I: return VK_FORMAT_R32_SINT; - case GFXFormat::R32UI: return VK_FORMAT_R32_UINT; - case GFXFormat::R32F: return VK_FORMAT_R32_SFLOAT; - case GFXFormat::RG32I: return VK_FORMAT_R32G32_SINT; - case GFXFormat::RG32UI: return VK_FORMAT_R32G32_UINT; - case GFXFormat::RG32F: return VK_FORMAT_R32G32_SFLOAT; - case GFXFormat::RGB32I: return VK_FORMAT_R32G32B32_SINT; - case GFXFormat::RGB32UI: return VK_FORMAT_R32G32B32_UINT; - case GFXFormat::RGB32F: return VK_FORMAT_R32G32B32_SFLOAT; - case GFXFormat::RGBA32I: return VK_FORMAT_R32G32B32A32_SINT; - case GFXFormat::RGBA32UI: return VK_FORMAT_R32G32B32A32_UINT; - case GFXFormat::RGBA32F: return VK_FORMAT_R32G32B32A32_SFLOAT; + case Format::R8: return VK_FORMAT_R8_UNORM; + case Format::R8SN: return VK_FORMAT_R8_SNORM; + case Format::R8UI: return VK_FORMAT_R8_UINT; + case Format::R8I: return VK_FORMAT_R8_SINT; + case Format::RG8: return VK_FORMAT_R8G8_UNORM; + case Format::RG8SN: return VK_FORMAT_R8G8_SNORM; + case Format::RG8UI: return VK_FORMAT_R8G8_UINT; + case Format::RG8I: return VK_FORMAT_R8G8_SINT; + case Format::RGB8: return VK_FORMAT_R8G8B8_UNORM; + case Format::RGB8SN: return VK_FORMAT_R8G8B8_SNORM; + case Format::RGB8UI: return VK_FORMAT_R8G8B8_UINT; + case Format::RGB8I: return VK_FORMAT_R8G8B8_SINT; + case Format::RGBA8: return VK_FORMAT_R8G8B8A8_UNORM; + case Format::BGRA8: return VK_FORMAT_B8G8R8A8_UNORM; + case Format::RGBA8SN: return VK_FORMAT_R8G8B8A8_SNORM; + case Format::RGBA8UI: return VK_FORMAT_R8G8B8A8_UINT; + case Format::RGBA8I: return VK_FORMAT_R8G8B8A8_SINT; + case Format::R16I: return VK_FORMAT_R16_SINT; + case Format::R16UI: return VK_FORMAT_R16_UINT; + case Format::R16F: return VK_FORMAT_R16_SFLOAT; + case Format::RG16I: return VK_FORMAT_R16G16_SINT; + case Format::RG16UI: return VK_FORMAT_R16G16_UINT; + case Format::RG16F: return VK_FORMAT_R16G16_SFLOAT; + case Format::RGB16I: return VK_FORMAT_R16G16B16_SINT; + case Format::RGB16UI: return VK_FORMAT_R16G16B16_UINT; + case Format::RGB16F: return VK_FORMAT_R16G16B16_SFLOAT; + case Format::RGBA16I: return VK_FORMAT_R16G16B16A16_SINT; + case Format::RGBA16UI: return VK_FORMAT_R16G16B16A16_UINT; + case Format::RGBA16F: return VK_FORMAT_R16G16B16A16_SFLOAT; + case Format::R32I: return VK_FORMAT_R32_SINT; + case Format::R32UI: return VK_FORMAT_R32_UINT; + case Format::R32F: return VK_FORMAT_R32_SFLOAT; + case Format::RG32I: return VK_FORMAT_R32G32_SINT; + case Format::RG32UI: return VK_FORMAT_R32G32_UINT; + case Format::RG32F: return VK_FORMAT_R32G32_SFLOAT; + case Format::RGB32I: return VK_FORMAT_R32G32B32_SINT; + case Format::RGB32UI: return VK_FORMAT_R32G32B32_UINT; + case Format::RGB32F: return VK_FORMAT_R32G32B32_SFLOAT; + case Format::RGBA32I: return VK_FORMAT_R32G32B32A32_SINT; + case Format::RGBA32UI: return VK_FORMAT_R32G32B32A32_UINT; + case Format::RGBA32F: return VK_FORMAT_R32G32B32A32_SFLOAT; - case GFXFormat::R5G6B5: return VK_FORMAT_R5G6B5_UNORM_PACK16; - case GFXFormat::R11G11B10F: return VK_FORMAT_B10G11R11_UFLOAT_PACK32; - case GFXFormat::RGB5A1: return VK_FORMAT_R5G5B5A1_UNORM_PACK16; - case GFXFormat::RGBA4: return VK_FORMAT_R4G4B4A4_UNORM_PACK16; - case GFXFormat::RGB10A2: return VK_FORMAT_A2B10G10R10_UNORM_PACK32; - case GFXFormat::RGB10A2UI: return VK_FORMAT_A2B10G10R10_UINT_PACK32; - case GFXFormat::RGB9E5: return VK_FORMAT_E5B9G9R9_UFLOAT_PACK32; - case GFXFormat::D16: return VK_FORMAT_D16_UNORM; - case GFXFormat::D16S8: return VK_FORMAT_D16_UNORM_S8_UINT; - case GFXFormat::D24: return VK_FORMAT_X8_D24_UNORM_PACK32; - case GFXFormat::D24S8: return VK_FORMAT_D24_UNORM_S8_UINT; - case GFXFormat::D32F: return VK_FORMAT_D32_SFLOAT; - case GFXFormat::D32F_S8: return VK_FORMAT_D32_SFLOAT_S8_UINT; + case Format::R5G6B5: return VK_FORMAT_R5G6B5_UNORM_PACK16; + case Format::R11G11B10F: return VK_FORMAT_B10G11R11_UFLOAT_PACK32; + case Format::RGB5A1: return VK_FORMAT_R5G5B5A1_UNORM_PACK16; + case Format::RGBA4: return VK_FORMAT_R4G4B4A4_UNORM_PACK16; + case Format::RGB10A2: return VK_FORMAT_A2B10G10R10_UNORM_PACK32; + case Format::RGB10A2UI: return VK_FORMAT_A2B10G10R10_UINT_PACK32; + case Format::RGB9E5: return VK_FORMAT_E5B9G9R9_UFLOAT_PACK32; + case Format::D16: return VK_FORMAT_D16_UNORM; + case Format::D16S8: return VK_FORMAT_D16_UNORM_S8_UINT; + case Format::D24: return VK_FORMAT_X8_D24_UNORM_PACK32; + case Format::D24S8: return VK_FORMAT_D24_UNORM_S8_UINT; + case Format::D32F: return VK_FORMAT_D32_SFLOAT; + case Format::D32F_S8: return VK_FORMAT_D32_SFLOAT_S8_UINT; - case GFXFormat::BC1: return VK_FORMAT_BC1_RGB_UNORM_BLOCK; - case GFXFormat::BC1_ALPHA: return VK_FORMAT_BC1_RGBA_UNORM_BLOCK; - case GFXFormat::BC1_SRGB: return VK_FORMAT_BC1_RGB_SRGB_BLOCK; - case GFXFormat::BC1_SRGB_ALPHA: return VK_FORMAT_BC1_RGBA_SRGB_BLOCK; - case GFXFormat::BC2: return VK_FORMAT_BC2_UNORM_BLOCK; - case GFXFormat::BC2_SRGB: return VK_FORMAT_BC2_SRGB_BLOCK; - case GFXFormat::BC3: return VK_FORMAT_BC3_UNORM_BLOCK; - case GFXFormat::BC3_SRGB: return VK_FORMAT_BC3_SRGB_BLOCK; - case GFXFormat::BC4: return VK_FORMAT_BC4_UNORM_BLOCK; - case GFXFormat::BC4_SNORM: return VK_FORMAT_BC4_SNORM_BLOCK; - case GFXFormat::BC5: return VK_FORMAT_BC5_UNORM_BLOCK; - case GFXFormat::BC5_SNORM: return VK_FORMAT_BC5_SNORM_BLOCK; - case GFXFormat::BC6H_UF16: return VK_FORMAT_BC6H_UFLOAT_BLOCK; - case GFXFormat::BC6H_SF16: return VK_FORMAT_BC6H_SFLOAT_BLOCK; - case GFXFormat::BC7: return VK_FORMAT_BC7_UNORM_BLOCK; - case GFXFormat::BC7_SRGB: return VK_FORMAT_BC7_SRGB_BLOCK; + case Format::BC1: return VK_FORMAT_BC1_RGB_UNORM_BLOCK; + case Format::BC1_ALPHA: return VK_FORMAT_BC1_RGBA_UNORM_BLOCK; + case Format::BC1_SRGB: return VK_FORMAT_BC1_RGB_SRGB_BLOCK; + case Format::BC1_SRGB_ALPHA: return VK_FORMAT_BC1_RGBA_SRGB_BLOCK; + case Format::BC2: return VK_FORMAT_BC2_UNORM_BLOCK; + case Format::BC2_SRGB: return VK_FORMAT_BC2_SRGB_BLOCK; + case Format::BC3: return VK_FORMAT_BC3_UNORM_BLOCK; + case Format::BC3_SRGB: return VK_FORMAT_BC3_SRGB_BLOCK; + case Format::BC4: return VK_FORMAT_BC4_UNORM_BLOCK; + case Format::BC4_SNORM: return VK_FORMAT_BC4_SNORM_BLOCK; + case Format::BC5: return VK_FORMAT_BC5_UNORM_BLOCK; + case Format::BC5_SNORM: return VK_FORMAT_BC5_SNORM_BLOCK; + case Format::BC6H_UF16: return VK_FORMAT_BC6H_UFLOAT_BLOCK; + case Format::BC6H_SF16: return VK_FORMAT_BC6H_SFLOAT_BLOCK; + case Format::BC7: return VK_FORMAT_BC7_UNORM_BLOCK; + case Format::BC7_SRGB: return VK_FORMAT_BC7_SRGB_BLOCK; - case GFXFormat::ETC2_RGB8: return VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK; - case GFXFormat::ETC2_SRGB8: return VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK; - case GFXFormat::ETC2_RGB8_A1: return VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK; - case GFXFormat::ETC2_SRGB8_A1: return VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK; - case GFXFormat::ETC2_RGBA8: return VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK; - case GFXFormat::ETC2_SRGB8_A8: return VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK; - case GFXFormat::EAC_R11: return VK_FORMAT_EAC_R11_UNORM_BLOCK; - case GFXFormat::EAC_R11SN: return VK_FORMAT_EAC_R11_SNORM_BLOCK; - case GFXFormat::EAC_RG11: return VK_FORMAT_EAC_R11G11_UNORM_BLOCK; - case GFXFormat::EAC_RG11SN: return VK_FORMAT_EAC_R11G11_SNORM_BLOCK; + case Format::ETC2_RGB8: return VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK; + case Format::ETC2_SRGB8: return VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK; + case Format::ETC2_RGB8_A1: return VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK; + case Format::ETC2_SRGB8_A1: return VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK; + case Format::ETC2_RGBA8: return VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK; + case Format::ETC2_SRGB8_A8: return VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK; + case Format::EAC_R11: return VK_FORMAT_EAC_R11_UNORM_BLOCK; + case Format::EAC_R11SN: return VK_FORMAT_EAC_R11_SNORM_BLOCK; + case Format::EAC_RG11: return VK_FORMAT_EAC_R11G11_UNORM_BLOCK; + case Format::EAC_RG11SN: return VK_FORMAT_EAC_R11G11_SNORM_BLOCK; - case GFXFormat::PVRTC_RGB2: return VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG; - case GFXFormat::PVRTC_RGBA2: return VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG; - case GFXFormat::PVRTC_RGB4: return VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG; - case GFXFormat::PVRTC_RGBA4: return VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG; - case GFXFormat::PVRTC2_2BPP: return VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG; - case GFXFormat::PVRTC2_4BPP: return VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG; + case Format::PVRTC_RGB2: return VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG; + case Format::PVRTC_RGBA2: return VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG; + case Format::PVRTC_RGB4: return VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG; + case Format::PVRTC_RGBA4: return VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG; + case Format::PVRTC2_2BPP: return VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG; + case Format::PVRTC2_4BPP: return VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG; default: { - CCASSERT(false, "Unsupported GFXFormat, convert to VkFormat failed."); + CCASSERT(false, "Unsupported Format, convert to VkFormat failed."); return VK_FORMAT_B8G8R8A8_UNORM; } } @@ -130,172 +130,172 @@ VkSampleCountFlagBits MapVkSampleCount(uint sampleCount) { return VK_SAMPLE_COUNT_1_BIT; } -VkAttachmentLoadOp MapVkLoadOp(GFXLoadOp loadOp) { +VkAttachmentLoadOp MapVkLoadOp(LoadOp loadOp) { switch (loadOp) { - case GFXLoadOp::CLEAR: return VK_ATTACHMENT_LOAD_OP_CLEAR; - case GFXLoadOp::LOAD: return VK_ATTACHMENT_LOAD_OP_LOAD; - case GFXLoadOp::DISCARD: return VK_ATTACHMENT_LOAD_OP_DONT_CARE; + case LoadOp::CLEAR: return VK_ATTACHMENT_LOAD_OP_CLEAR; + case LoadOp::LOAD: return VK_ATTACHMENT_LOAD_OP_LOAD; + case LoadOp::DISCARD: return VK_ATTACHMENT_LOAD_OP_DONT_CARE; default: { - CCASSERT(false, "Unsupported GFXLoadOp, convert to VkLoadOp failed."); + CCASSERT(false, "Unsupported LoadOp, convert to VkLoadOp failed."); return VK_ATTACHMENT_LOAD_OP_LOAD; } } } -VkAttachmentStoreOp MapVkStoreOp(GFXStoreOp storeOp) { +VkAttachmentStoreOp MapVkStoreOp(StoreOp storeOp) { switch (storeOp) { - case GFXStoreOp::STORE: return VK_ATTACHMENT_STORE_OP_STORE; - case GFXStoreOp::DISCARD: return VK_ATTACHMENT_STORE_OP_DONT_CARE; + case StoreOp::STORE: return VK_ATTACHMENT_STORE_OP_STORE; + case StoreOp::DISCARD: return VK_ATTACHMENT_STORE_OP_DONT_CARE; default: { - CCASSERT(false, "Unsupported GFXStoreOp, convert to VkStoreOp failed."); + CCASSERT(false, "Unsupported StoreOp, convert to VkStoreOp failed."); return VK_ATTACHMENT_STORE_OP_STORE; } } } -VkImageLayout MapVkImageLayout(GFXTextureLayout layout) { +VkImageLayout MapVkImageLayout(TextureLayout layout) { switch (layout) { - case GFXTextureLayout::UNDEFINED: return VK_IMAGE_LAYOUT_UNDEFINED; - case GFXTextureLayout::GENERAL: return VK_IMAGE_LAYOUT_GENERAL; - case GFXTextureLayout::COLOR_ATTACHMENT_OPTIMAL: return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - case GFXTextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL: return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - case GFXTextureLayout::DEPTH_STENCIL_READONLY_OPTIMAL: return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL; - case GFXTextureLayout::SHADER_READONLY_OPTIMAL: return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - case GFXTextureLayout::TRANSFER_SRC_OPTIMAL: return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; - case GFXTextureLayout::TRANSFER_DST_OPTIMAL: return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; - case GFXTextureLayout::PREINITIALIZED: return VK_IMAGE_LAYOUT_PREINITIALIZED; - case GFXTextureLayout::PRESENT_SRC: return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; + case TextureLayout::UNDEFINED: return VK_IMAGE_LAYOUT_UNDEFINED; + case TextureLayout::GENERAL: return VK_IMAGE_LAYOUT_GENERAL; + case TextureLayout::COLOR_ATTACHMENT_OPTIMAL: return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + case TextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL: return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + case TextureLayout::DEPTH_STENCIL_READONLY_OPTIMAL: return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL; + case TextureLayout::SHADER_READONLY_OPTIMAL: return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + case TextureLayout::TRANSFER_SRC_OPTIMAL: return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; + case TextureLayout::TRANSFER_DST_OPTIMAL: return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; + case TextureLayout::PREINITIALIZED: return VK_IMAGE_LAYOUT_PREINITIALIZED; + case TextureLayout::PRESENT_SRC: return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; default: { - CCASSERT(false, "Unsupported GFXTextureLayout, convert to VkImageLayout failed."); + CCASSERT(false, "Unsupported TextureLayout, convert to VkImageLayout failed."); return VK_IMAGE_LAYOUT_GENERAL; } } } -VkAccessFlags MapVkAccessFlags(GFXTextureLayout layout) { +VkAccessFlags MapVkAccessFlags(TextureLayout layout) { switch (layout) { - case GFXTextureLayout::UNDEFINED: return 0; - case GFXTextureLayout::GENERAL: return 0; - case GFXTextureLayout::COLOR_ATTACHMENT_OPTIMAL: return VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; - case GFXTextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; - case GFXTextureLayout::DEPTH_STENCIL_READONLY_OPTIMAL: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT; - case GFXTextureLayout::SHADER_READONLY_OPTIMAL: return VK_ACCESS_SHADER_READ_BIT; - case GFXTextureLayout::TRANSFER_SRC_OPTIMAL: return VK_ACCESS_TRANSFER_READ_BIT; - case GFXTextureLayout::TRANSFER_DST_OPTIMAL: return VK_ACCESS_TRANSFER_WRITE_BIT; - case GFXTextureLayout::PREINITIALIZED: return 0; - case GFXTextureLayout::PRESENT_SRC: return 0; + case TextureLayout::UNDEFINED: return 0; + case TextureLayout::GENERAL: return 0; + case TextureLayout::COLOR_ATTACHMENT_OPTIMAL: return VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + case TextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; + case TextureLayout::DEPTH_STENCIL_READONLY_OPTIMAL: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT; + case TextureLayout::SHADER_READONLY_OPTIMAL: return VK_ACCESS_SHADER_READ_BIT; + case TextureLayout::TRANSFER_SRC_OPTIMAL: return VK_ACCESS_TRANSFER_READ_BIT; + case TextureLayout::TRANSFER_DST_OPTIMAL: return VK_ACCESS_TRANSFER_WRITE_BIT; + case TextureLayout::PREINITIALIZED: return 0; + case TextureLayout::PRESENT_SRC: return 0; default: { - CCASSERT(false, "Unsupported GFXTextureLayout, convert to VkImageLayout failed."); + CCASSERT(false, "Unsupported TextureLayout, convert to VkImageLayout failed."); return 0; } } } -VkAccessFlags MapVkAccessFlags(GFXTextureUsage usage, GFXFormat format) { - if (usage & GFXTextureUsage::COLOR_ATTACHMENT) return VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; - if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; - if (usage & GFXTextureUsage::INPUT_ATTACHMENT) return VK_ACCESS_INPUT_ATTACHMENT_READ_BIT; - if (usage & GFXTextureUsage::SAMPLED) { +VkAccessFlags MapVkAccessFlags(TextureUsage usage, Format format) { + if (usage & TextureUsage::COLOR_ATTACHMENT) return VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + if (usage & TextureUsage::DEPTH_STENCIL_ATTACHMENT) return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; + if (usage & TextureUsage::INPUT_ATTACHMENT) return VK_ACCESS_INPUT_ATTACHMENT_READ_BIT; + if (usage & TextureUsage::SAMPLED) { if (GFX_FORMAT_INFOS[(uint)format].hasDepth) return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT; else return VK_ACCESS_SHADER_READ_BIT; } - if (usage & GFXTextureUsage::TRANSFER_SRC) return VK_ACCESS_TRANSFER_READ_BIT; - if (usage & GFXTextureUsage::TRANSFER_DST) return VK_ACCESS_TRANSFER_WRITE_BIT; + if (usage & TextureUsage::TRANSFER_SRC) return VK_ACCESS_TRANSFER_READ_BIT; + if (usage & TextureUsage::TRANSFER_DST) return VK_ACCESS_TRANSFER_WRITE_BIT; return VK_ACCESS_SHADER_READ_BIT; } -VkPipelineBindPoint MapVkPipelineBindPoint(GFXPipelineBindPoint bindPoint) { +VkPipelineBindPoint MapVkPipelineBindPoint(PipelineBindPoint bindPoint) { switch (bindPoint) { - case GFXPipelineBindPoint::GRAPHICS: return VK_PIPELINE_BIND_POINT_GRAPHICS; - case GFXPipelineBindPoint::COMPUTE: return VK_PIPELINE_BIND_POINT_COMPUTE; - case GFXPipelineBindPoint::RAY_TRACING: return VK_PIPELINE_BIND_POINT_RAY_TRACING_NV; + case PipelineBindPoint::GRAPHICS: return VK_PIPELINE_BIND_POINT_GRAPHICS; + case PipelineBindPoint::COMPUTE: return VK_PIPELINE_BIND_POINT_COMPUTE; + case PipelineBindPoint::RAY_TRACING: return VK_PIPELINE_BIND_POINT_RAY_TRACING_NV; default: { - CCASSERT(false, "Unsupported GFXPipelineBindPoint, convert to VkPipelineBindPoint failed."); + CCASSERT(false, "Unsupported PipelineBindPoint, convert to VkPipelineBindPoint failed."); return VK_PIPELINE_BIND_POINT_GRAPHICS; } } } -VkBufferUsageFlagBits MapVkBufferUsageFlagBits(GFXBufferUsage usage) { +VkBufferUsageFlagBits MapVkBufferUsageFlagBits(BufferUsage usage) { uint flags = 0u; - if (usage & GFXBufferUsage::TRANSFER_SRC) flags |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT; - if (usage & GFXBufferUsage::TRANSFER_DST) flags |= VK_BUFFER_USAGE_TRANSFER_DST_BIT; - if (usage & GFXBufferUsage::INDEX) flags |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT; - if (usage & GFXBufferUsage::VERTEX) flags |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; - if (usage & GFXBufferUsage::UNIFORM) flags |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; - if (usage & GFXBufferUsage::STORAGE) flags |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; - if (usage & GFXBufferUsage::INDIRECT) flags |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT; + if (usage & BufferUsage::TRANSFER_SRC) flags |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT; + if (usage & BufferUsage::TRANSFER_DST) flags |= VK_BUFFER_USAGE_TRANSFER_DST_BIT; + if (usage & BufferUsage::INDEX) flags |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT; + if (usage & BufferUsage::VERTEX) flags |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; + if (usage & BufferUsage::UNIFORM) flags |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; + if (usage & BufferUsage::STORAGE) flags |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; + if (usage & BufferUsage::INDIRECT) flags |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT; return (VkBufferUsageFlagBits)flags; } -VkImageType MapVkImageType(GFXTextureType type) { +VkImageType MapVkImageType(TextureType type) { switch (type) { - case GFXTextureType::TEX1D: - case GFXTextureType::TEX1D_ARRAY: return VK_IMAGE_TYPE_1D; - case GFXTextureType::CUBE: - case GFXTextureType::TEX2D: - case GFXTextureType::TEX2D_ARRAY: return VK_IMAGE_TYPE_2D; - case GFXTextureType::TEX3D: return VK_IMAGE_TYPE_3D; + case TextureType::TEX1D: + case TextureType::TEX1D_ARRAY: return VK_IMAGE_TYPE_1D; + case TextureType::CUBE: + case TextureType::TEX2D: + case TextureType::TEX2D_ARRAY: return VK_IMAGE_TYPE_2D; + case TextureType::TEX3D: return VK_IMAGE_TYPE_3D; default: { - CCASSERT(false, "Unsupported GFXTextureType, convert to VkImageType failed."); + CCASSERT(false, "Unsupported TextureType, convert to VkImageType failed."); return VK_IMAGE_TYPE_2D; } } } -VkSampleCountFlagBits MapVkSampleCount(GFXSampleCount count) { +VkSampleCountFlagBits MapVkSampleCount(SampleCount count) { switch (count) { - case GFXSampleCount::X1: return VK_SAMPLE_COUNT_1_BIT; - case GFXSampleCount::X2: return VK_SAMPLE_COUNT_2_BIT; - case GFXSampleCount::X4: return VK_SAMPLE_COUNT_4_BIT; - case GFXSampleCount::X8: return VK_SAMPLE_COUNT_8_BIT; - case GFXSampleCount::X16: return VK_SAMPLE_COUNT_16_BIT; - case GFXSampleCount::X32: return VK_SAMPLE_COUNT_32_BIT; + case SampleCount::X1: return VK_SAMPLE_COUNT_1_BIT; + case SampleCount::X2: return VK_SAMPLE_COUNT_2_BIT; + case SampleCount::X4: return VK_SAMPLE_COUNT_4_BIT; + case SampleCount::X8: return VK_SAMPLE_COUNT_8_BIT; + case SampleCount::X16: return VK_SAMPLE_COUNT_16_BIT; + case SampleCount::X32: return VK_SAMPLE_COUNT_32_BIT; default: { - CCASSERT(false, "Unsupported GFXTextureType, convert to VkImageType failed."); + CCASSERT(false, "Unsupported TextureType, convert to VkImageType failed."); return VK_SAMPLE_COUNT_1_BIT; } } } -VkFormatFeatureFlags MapVkFormatFeatureFlags(GFXTextureUsage usage) { +VkFormatFeatureFlags MapVkFormatFeatureFlags(TextureUsage usage) { uint flags = 0u; - if (usage & GFXTextureUsage::TRANSFER_SRC) flags |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT; - if (usage & GFXTextureUsage::TRANSFER_DST) flags |= VK_FORMAT_FEATURE_TRANSFER_DST_BIT; - if (usage & GFXTextureUsage::SAMPLED) flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; - if (usage & GFXTextureUsage::STORAGE) flags |= VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT; - if (usage & GFXTextureUsage::COLOR_ATTACHMENT) flags |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; - if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) flags |= VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT; - if (usage & GFXTextureUsage::TRANSIENT_ATTACHMENT) flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; - if (usage & GFXTextureUsage::INPUT_ATTACHMENT) flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; + if (usage & TextureUsage::TRANSFER_SRC) flags |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT; + if (usage & TextureUsage::TRANSFER_DST) flags |= VK_FORMAT_FEATURE_TRANSFER_DST_BIT; + if (usage & TextureUsage::SAMPLED) flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; + if (usage & TextureUsage::STORAGE) flags |= VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT; + if (usage & TextureUsage::COLOR_ATTACHMENT) flags |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; + if (usage & TextureUsage::DEPTH_STENCIL_ATTACHMENT) flags |= VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT; + if (usage & TextureUsage::TRANSIENT_ATTACHMENT) flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; + if (usage & TextureUsage::INPUT_ATTACHMENT) flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; return (VkFormatFeatureFlags)flags; } -VkImageUsageFlagBits MapVkImageUsageFlagBits(GFXTextureUsage usage) { +VkImageUsageFlagBits MapVkImageUsageFlagBits(TextureUsage usage) { uint flags = 0u; - if (usage & GFXTextureUsage::TRANSFER_SRC) flags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT; - if (usage & GFXTextureUsage::TRANSFER_DST) flags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT; - if (usage & GFXTextureUsage::SAMPLED) flags |= VK_IMAGE_USAGE_SAMPLED_BIT; - if (usage & GFXTextureUsage::STORAGE) flags |= VK_IMAGE_USAGE_STORAGE_BIT; - if (usage & GFXTextureUsage::COLOR_ATTACHMENT) flags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; - if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) flags |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; - if (usage & GFXTextureUsage::TRANSIENT_ATTACHMENT) flags |= VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT; - if (usage & GFXTextureUsage::INPUT_ATTACHMENT) flags |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; + if (usage & TextureUsage::TRANSFER_SRC) flags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT; + if (usage & TextureUsage::TRANSFER_DST) flags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT; + if (usage & TextureUsage::SAMPLED) flags |= VK_IMAGE_USAGE_SAMPLED_BIT; + if (usage & TextureUsage::STORAGE) flags |= VK_IMAGE_USAGE_STORAGE_BIT; + if (usage & TextureUsage::COLOR_ATTACHMENT) flags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + if (usage & TextureUsage::DEPTH_STENCIL_ATTACHMENT) flags |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; + if (usage & TextureUsage::TRANSIENT_ATTACHMENT) flags |= VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT; + if (usage & TextureUsage::INPUT_ATTACHMENT) flags |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; return (VkImageUsageFlagBits)flags; } -VkImageLayout MapVkImageLayout(GFXTextureUsage usage, GFXFormat format) { - const GFXFormatInfo &info = GFX_FORMAT_INFOS[(uint)format]; - if (usage & GFXTextureUsage::COLOR_ATTACHMENT) return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) { +VkImageLayout MapVkImageLayout(TextureUsage usage, Format format) { + const FormatInfo &info = GFX_FORMAT_INFOS[(uint)format]; + if (usage & TextureUsage::COLOR_ATTACHMENT) return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + if (usage & TextureUsage::DEPTH_STENCIL_ATTACHMENT) { if (info.hasStencil) return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; else return VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL; } - if (usage & GFXTextureUsage::SAMPLED) { + if (usage & TextureUsage::SAMPLED) { if (info.hasDepth && info.hasStencil) return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL; else if (info.hasDepth) @@ -303,14 +303,14 @@ VkImageLayout MapVkImageLayout(GFXTextureUsage usage, GFXFormat format) { else return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; } - if (usage & GFXTextureUsage::TRANSFER_SRC) return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; - if (usage & GFXTextureUsage::TRANSFER_DST) return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; + if (usage & TextureUsage::TRANSFER_SRC) return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; + if (usage & TextureUsage::TRANSFER_DST) return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; return VK_IMAGE_LAYOUT_UNDEFINED; } -VkImageAspectFlags MapVkImageAspectFlags(GFXFormat format) { +VkImageAspectFlags MapVkImageAspectFlags(Format format) { VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; - const GFXFormatInfo &info = GFX_FORMAT_INFOS[(uint)format]; + const FormatInfo &info = GFX_FORMAT_INFOS[(uint)format]; if (info.hasDepth) { aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; } @@ -320,12 +320,12 @@ VkImageAspectFlags MapVkImageAspectFlags(GFXFormat format) { return aspectMask; } -VkPipelineStageFlags MapVkPipelineStageFlags(GFXTextureUsage usage) { - if (usage & GFXTextureUsage::COLOR_ATTACHMENT) return VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; - if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) return VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT; - if (usage & GFXTextureUsage::SAMPLED) return VK_PIPELINE_STAGE_VERTEX_SHADER_BIT; - if (usage & GFXTextureUsage::TRANSFER_SRC) return VK_PIPELINE_STAGE_TRANSFER_BIT; - if (usage & GFXTextureUsage::TRANSFER_DST) return VK_PIPELINE_STAGE_TRANSFER_BIT; +VkPipelineStageFlags MapVkPipelineStageFlags(TextureUsage usage) { + if (usage & TextureUsage::COLOR_ATTACHMENT) return VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + if (usage & TextureUsage::DEPTH_STENCIL_ATTACHMENT) return VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT; + if (usage & TextureUsage::SAMPLED) return VK_PIPELINE_STAGE_VERTEX_SHADER_BIT; + if (usage & TextureUsage::TRANSFER_SRC) return VK_PIPELINE_STAGE_TRANSFER_BIT; + if (usage & TextureUsage::TRANSFER_DST) return VK_PIPELINE_STAGE_TRANSFER_BIT; return VK_PIPELINE_STAGE_VERTEX_SHADER_BIT; } @@ -338,86 +338,86 @@ uint selectMemoryType(const VkPhysicalDeviceMemoryProperties &memoryProperties, return ~0u; } -VkImageCreateFlags MapVkImageCreateFlags(GFXTextureType type) { +VkImageCreateFlags MapVkImageCreateFlags(TextureType type) { uint res = 0u; switch (type) { - case GFXTextureType::CUBE: res |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; break; - case GFXTextureType::TEX2D_ARRAY: res |= VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT; break; + case TextureType::CUBE: res |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; break; + case TextureType::TEX2D_ARRAY: res |= VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT; break; } return (VkImageCreateFlags)res; } -VkImageViewType MapVkImageViewType(GFXTextureType viewType) { +VkImageViewType MapVkImageViewType(TextureType viewType) { switch (viewType) { - case GFXTextureType::TEX1D: return VK_IMAGE_VIEW_TYPE_1D; - case GFXTextureType::TEX1D_ARRAY: return VK_IMAGE_VIEW_TYPE_1D_ARRAY; - case GFXTextureType::TEX2D: return VK_IMAGE_VIEW_TYPE_2D; - case GFXTextureType::TEX2D_ARRAY: return VK_IMAGE_VIEW_TYPE_2D_ARRAY; - case GFXTextureType::TEX3D: return VK_IMAGE_VIEW_TYPE_3D; - case GFXTextureType::CUBE: return VK_IMAGE_VIEW_TYPE_CUBE; + case TextureType::TEX1D: return VK_IMAGE_VIEW_TYPE_1D; + case TextureType::TEX1D_ARRAY: return VK_IMAGE_VIEW_TYPE_1D_ARRAY; + case TextureType::TEX2D: return VK_IMAGE_VIEW_TYPE_2D; + case TextureType::TEX2D_ARRAY: return VK_IMAGE_VIEW_TYPE_2D_ARRAY; + case TextureType::TEX3D: return VK_IMAGE_VIEW_TYPE_3D; + case TextureType::CUBE: return VK_IMAGE_VIEW_TYPE_CUBE; default: { - CCASSERT(false, "Unsupported GFXTextureViewType, convert to VkImageViewType failed."); + CCASSERT(false, "Unsupported TextureViewType, convert to VkImageViewType failed."); return VK_IMAGE_VIEW_TYPE_2D; } } } -VkCommandBufferLevel MapVkCommandBufferLevel(GFXCommandBufferType type) { +VkCommandBufferLevel MapVkCommandBufferLevel(CommandBufferType type) { switch (type) { - case GFXCommandBufferType::PRIMARY: return VK_COMMAND_BUFFER_LEVEL_PRIMARY; - case GFXCommandBufferType::SECONDARY: return VK_COMMAND_BUFFER_LEVEL_SECONDARY; + case CommandBufferType::PRIMARY: return VK_COMMAND_BUFFER_LEVEL_PRIMARY; + case CommandBufferType::SECONDARY: return VK_COMMAND_BUFFER_LEVEL_SECONDARY; default: { - CCASSERT(false, "Unsupported GFXCommandBufferType, convert to VkCommandBufferLevel failed."); + CCASSERT(false, "Unsupported CommandBufferType, convert to VkCommandBufferLevel failed."); return VK_COMMAND_BUFFER_LEVEL_SECONDARY; } } } -VkDescriptorType MapVkDescriptorType(GFXBindingType type) { +VkDescriptorType MapVkDescriptorType(BindingType type) { switch (type) { - case GFXBindingType::UNIFORM_BUFFER: return VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; - case GFXBindingType::SAMPLER: return VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; - case GFXBindingType::STORAGE_BUFFER: return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + case BindingType::UNIFORM_BUFFER: return VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + case BindingType::SAMPLER: return VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + case BindingType::STORAGE_BUFFER: return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; default: { - CCASSERT(false, "Unsupported GFXBindingType, convert to VkDescriptorType failed."); + CCASSERT(false, "Unsupported BindingType, convert to VkDescriptorType failed."); return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; } } } -VkColorComponentFlags MapVkColorComponentFlags(GFXColorMask colorMask) { +VkColorComponentFlags MapVkColorComponentFlags(ColorMask colorMask) { uint flags = 0u; - if (colorMask & GFXColorMask::R) flags |= VK_COLOR_COMPONENT_R_BIT; - if (colorMask & GFXColorMask::G) flags |= VK_COLOR_COMPONENT_G_BIT; - if (colorMask & GFXColorMask::B) flags |= VK_COLOR_COMPONENT_B_BIT; - if (colorMask & GFXColorMask::A) flags |= VK_COLOR_COMPONENT_A_BIT; - if (colorMask & GFXColorMask::ALL) flags |= VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; + if (colorMask & ColorMask::R) flags |= VK_COLOR_COMPONENT_R_BIT; + if (colorMask & ColorMask::G) flags |= VK_COLOR_COMPONENT_G_BIT; + if (colorMask & ColorMask::B) flags |= VK_COLOR_COMPONENT_B_BIT; + if (colorMask & ColorMask::A) flags |= VK_COLOR_COMPONENT_A_BIT; + if (colorMask & ColorMask::ALL) flags |= VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; return (VkColorComponentFlags)flags; } -VkShaderStageFlagBits MapVkShaderStageFlagBits(GFXShaderType stage) { +VkShaderStageFlagBits MapVkShaderStageFlagBits(ShaderType stage) { switch (stage) { - case GFXShaderType::VERTEX: return VK_SHADER_STAGE_VERTEX_BIT; - case GFXShaderType::CONTROL: return VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT; - case GFXShaderType::EVALUATION: return VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT; - case GFXShaderType::GEOMETRY: return VK_SHADER_STAGE_GEOMETRY_BIT; - case GFXShaderType::FRAGMENT: return VK_SHADER_STAGE_FRAGMENT_BIT; - case GFXShaderType::COMPUTE: return VK_SHADER_STAGE_COMPUTE_BIT; + case ShaderType::VERTEX: return VK_SHADER_STAGE_VERTEX_BIT; + case ShaderType::CONTROL: return VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT; + case ShaderType::EVALUATION: return VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT; + case ShaderType::GEOMETRY: return VK_SHADER_STAGE_GEOMETRY_BIT; + case ShaderType::FRAGMENT: return VK_SHADER_STAGE_FRAGMENT_BIT; + case ShaderType::COMPUTE: return VK_SHADER_STAGE_COMPUTE_BIT; default: { - CCASSERT(false, "Unsupported GFXShaderType, convert to VkShaderStageFlagBits failed."); + CCASSERT(false, "Unsupported ShaderType, convert to VkShaderStageFlagBits failed."); return VK_SHADER_STAGE_VERTEX_BIT; } } } -VkShaderStageFlags MapVkShaderStageFlags(GFXShaderType stages) { +VkShaderStageFlags MapVkShaderStageFlags(ShaderType stages) { uint flags = 0u; - if (stages & GFXShaderType::VERTEX) flags |= VK_SHADER_STAGE_VERTEX_BIT; - if (stages & GFXShaderType::CONTROL) flags |= VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT; - if (stages & GFXShaderType::EVALUATION) flags |= VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT; - if (stages & GFXShaderType::GEOMETRY) flags |= VK_SHADER_STAGE_GEOMETRY_BIT; - if (stages & GFXShaderType::FRAGMENT) flags |= VK_SHADER_STAGE_FRAGMENT_BIT; - if (stages & GFXShaderType::COMPUTE) flags |= VK_SHADER_STAGE_COMPUTE_BIT; + if (stages & ShaderType::VERTEX) flags |= VK_SHADER_STAGE_VERTEX_BIT; + if (stages & ShaderType::CONTROL) flags |= VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT; + if (stages & ShaderType::EVALUATION) flags |= VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT; + if (stages & ShaderType::GEOMETRY) flags |= VK_SHADER_STAGE_GEOMETRY_BIT; + if (stages & ShaderType::FRAGMENT) flags |= VK_SHADER_STAGE_FRAGMENT_BIT; + if (stages & ShaderType::COMPUTE) flags |= VK_SHADER_STAGE_COMPUTE_BIT; return (VkShaderStageFlags)flags; } @@ -433,29 +433,29 @@ const char *MapVendorName(uint32_t vendorID) { return "Unknown"; } -void MapDepthStencilBits(GFXFormat format, uint &depthBits, uint &stencilBits) { +void MapDepthStencilBits(Format format, uint &depthBits, uint &stencilBits) { switch (format) { - case GFXFormat::D16: + case Format::D16: depthBits = 16; stencilBits = 0; break; - case GFXFormat::D16S8: + case Format::D16S8: depthBits = 16; stencilBits = 8; break; - case GFXFormat::D24: + case Format::D24: depthBits = 24; stencilBits = 0; break; - case GFXFormat::D24S8: + case Format::D24S8: depthBits = 24; stencilBits = 8; break; - case GFXFormat::D32F: + case Format::D32F: depthBits = 32; stencilBits = 0; break; - case GFXFormat::D32F_S8: + case Format::D32F_S8: depthBits = 32; stencilBits = 8; break; diff --git a/native/cocos/renderer/pipeline/BatchedBuffer.h b/native/cocos/renderer/pipeline/BatchedBuffer.h index 63a0366310..166d04dbb4 100644 --- a/native/cocos/renderer/pipeline/BatchedBuffer.h +++ b/native/cocos/renderer/pipeline/BatchedBuffer.h @@ -9,13 +9,13 @@ class SubModel; namespace pipeline { struct CC_DLL BatchedItem { - gfx::GFXBufferList vbs; + gfx::BufferList vbs; uint8_t *vbDatas = nullptr; - gfx::GFXBuffer *vbIdx = nullptr; + gfx::Buffer *vbIdx = nullptr; float *vbIdxData = nullptr; uint mergCount = 0; - gfx::GFXInputAssembler *ia = nullptr; - gfx::GFXBuffer *ubo = nullptr; + gfx::InputAssembler *ia = nullptr; + gfx::Buffer *ubo = nullptr; cc::PSOCreateInfo *psoCreatedInfo = nullptr; }; typedef vector BatchedItemList; diff --git a/native/cocos/renderer/pipeline/InstancedBuffer.h b/native/cocos/renderer/pipeline/InstancedBuffer.h index 317daef152..79af7700e3 100644 --- a/native/cocos/renderer/pipeline/InstancedBuffer.h +++ b/native/cocos/renderer/pipeline/InstancedBuffer.h @@ -11,9 +11,9 @@ class SubModel; namespace pipeline { struct CC_DLL InstancedItem { - gfx::GFXBuffer *vb = nullptr; + gfx::Buffer *vb = nullptr; uint8_t *data = nullptr; - gfx::GFXInputAssembler *ia = nullptr; + gfx::InputAssembler *ia = nullptr; uint count = 0; uint capacity = 0; uint stride = 0; diff --git a/native/cocos/renderer/pipeline/PipelineStateManager.h b/native/cocos/renderer/pipeline/PipelineStateManager.h index 2fdd29ff7c..c986a18361 100644 --- a/native/cocos/renderer/pipeline/PipelineStateManager.h +++ b/native/cocos/renderer/pipeline/PipelineStateManager.h @@ -6,23 +6,23 @@ namespace cc { struct PSOCreateInfo; namespace gfx { -class GFXDevice; -class GFXInputAssembler; -class GFXPipelineState; -class GFXRenderPass; +class Device; +class InputAssembler; +class PipelineState; +class RenderPass; }; namespace pipeline { class CC_DLL PipelineStateManager { public: - static gfx::GFXPipelineState *getOrCreatePipelineStage(gfx::GFXDevice *device, + static gfx::PipelineState *getOrCreatePipelineStage(gfx::Device *device, const PSOCreateInfo &PSOInfo, - gfx::GFXRenderPass *renderPass, - gfx::GFXInputAssembler *inputAssembler); + gfx::RenderPass *renderPass, + gfx::InputAssembler *inputAssembler); private: - static map _PSOHashMap; + static map _PSOHashMap; }; } // namespace pipeline diff --git a/native/cocos/renderer/pipeline/RenderAdditiveLightQueue.h b/native/cocos/renderer/pipeline/RenderAdditiveLightQueue.h index 156ad1913a..3d115128b6 100644 --- a/native/cocos/renderer/pipeline/RenderAdditiveLightQueue.h +++ b/native/cocos/renderer/pipeline/RenderAdditiveLightQueue.h @@ -19,19 +19,19 @@ public: void add(RenderObject *renderObj, uint subModelIdx, Pass *pass, uint beginIdx, uint endIdx); void clear(const vector &validLights, - const vector &lightBuffers, + const vector &lightBuffers, const vector &lightIndices); - void recordCommandBuffer(gfx::GFXDevice *device, gfx::GFXRenderPass *renderPass, gfx::GFXCommandBuffer *cmdBuff); + void recordCommandBuffer(gfx::Device *device, gfx::RenderPass *renderPass, gfx::CommandBuffer *cmdBuff); private: - void attach(RenderObject *renderObj, uint subModelIdx, gfx::GFXBuffer *lightBuffer, + void attach(RenderObject *renderObj, uint subModelIdx, gfx::Buffer *lightBuffer, uint lightIdx, Pass *pass, vector patches); private: vector> _sortedSubModelsArray; vector> _sortedPSOCIArray; vector _validLights; - vector _lightBuffers; + vector _lightBuffers; vector _lightIndices; uint _phaseID = 0; }; diff --git a/native/cocos/renderer/pipeline/RenderBatchedQueue.h b/native/cocos/renderer/pipeline/RenderBatchedQueue.h index 8aa8d7722a..0903de3359 100644 --- a/native/cocos/renderer/pipeline/RenderBatchedQueue.h +++ b/native/cocos/renderer/pipeline/RenderBatchedQueue.h @@ -13,7 +13,7 @@ public: ~RenderBatchedQueue() = default; void clear(); - void recordCommandBuffer(gfx::GFXDevice *, gfx::GFXRenderPass *, gfx::GFXCommandBuffer *); + void recordCommandBuffer(gfx::Device *, gfx::RenderPass *, gfx::CommandBuffer *); CC_INLINE const set &getQueue() const { return _queue; } diff --git a/native/cocos/renderer/pipeline/RenderFlow.h b/native/cocos/renderer/pipeline/RenderFlow.h index 300e12ad5f..e6e3afac7e 100644 --- a/native/cocos/renderer/pipeline/RenderFlow.h +++ b/native/cocos/renderer/pipeline/RenderFlow.h @@ -28,7 +28,7 @@ public: void destroyStages(); - CC_INLINE const gfx::GFXDevice *getDevice() const { return _device; } + CC_INLINE const gfx::Device *getDevice() const { return _device; } CC_INLINE const RenderPipeline *getPipeline() const { return _pipeline; } CC_INLINE const String &getName() const { return _name; } CC_INLINE int getPriority() const { return _priority; } @@ -40,7 +40,7 @@ protected: void activateStages(); protected: - gfx::GFXDevice *_device = nullptr; + gfx::Device *_device = nullptr; RenderPipeline *_pipeline = nullptr; String _name; int _priority = 0; diff --git a/native/cocos/renderer/pipeline/RenderInstancedQueue.h b/native/cocos/renderer/pipeline/RenderInstancedQueue.h index 02551d7042..b3654c039a 100644 --- a/native/cocos/renderer/pipeline/RenderInstancedQueue.h +++ b/native/cocos/renderer/pipeline/RenderInstancedQueue.h @@ -13,7 +13,7 @@ public: ~RenderInstancedQueue() = default; void clear(); - void recordCommandBuffer(gfx::GFXDevice *, gfx::GFXRenderPass *, gfx::GFXCommandBuffer *); + void recordCommandBuffer(gfx::Device *, gfx::RenderPass *, gfx::CommandBuffer *); CC_INLINE const set &getQueue() const { return _queue; } diff --git a/native/cocos/renderer/pipeline/RenderPipeline.h b/native/cocos/renderer/pipeline/RenderPipeline.h index cc3fb5430f..128924c6e1 100644 --- a/native/cocos/renderer/pipeline/RenderPipeline.h +++ b/native/cocos/renderer/pipeline/RenderPipeline.h @@ -10,11 +10,11 @@ class Model; class Camera; namespace gfx { -class GFXDevice; -class GFXInputAssembler; -class GFXTexture; -class GFXBuffer; -class GFXRenderPass; +class Device; +class InputAssembler; +class Texture; +class Buffer; +class RenderPass; } // namespace gfx namespace pipeline { @@ -33,7 +33,7 @@ public: virtual vector &getValidLights() const = 0; virtual vector &getLightIndexOffsets() const = 0; virtual vector &getLightIndices() const = 0; - virtual vector &getLightBuffers() const = 0; + virtual vector &getLightBuffers() const = 0; virtual bool activate(cc::Root *root); virtual bool initialize(const RenderPipelineInfo &info); @@ -43,14 +43,14 @@ public: virtual void sceneCulling(); virtual void updateUBOs(RenderView *view); - void addRenderPass(uint stage, gfx::GFXRenderPass *renderPass); + void addRenderPass(uint stage, gfx::RenderPass *renderPass); void clearRenderPasses(); void destroyFlows(); RenderFlow *getFlow(const String &name) const; - gfx::GFXBuffer *getFrameBuffer(const String &name) const; - gfx::GFXRenderPass *getRenderPass(uint stage) const; - gfx::GFXTexture *getRenderTexture(const String &name) const; - gfx::GFXTexture *getTexture(const String &name) const; + gfx::Buffer *getFrameBuffer(const String &name) const; + gfx::RenderPass *getRenderPass(uint stage) const; + gfx::Texture *getRenderTexture(const String &name) const; + gfx::Texture *getTexture(const String &name) const; void removeRenderPass(uint stage); void swapFBOS(); void updateMacros(); @@ -60,14 +60,14 @@ public: CC_INLINE const RenderFlowList &getFlows() const { return _flows; } CC_INLINE const String &getCurrentShading() const { return _currIdx; } CC_INLINE const String &getPreviousShading() const { return _prevIdx; } - CC_INLINE gfx::GFXDevice *getDevice() const { return _device; } - CC_INLINE gfx::GFXTexture *getDefaultTexture() const { return _defaultTexture; } + CC_INLINE gfx::Device *getDevice() const { return _device; } + CC_INLINE gfx::Texture *getDefaultTexture() const { return _defaultTexture; } CC_INLINE float getLightMeterScale() const { return _lightMeterScale; } CC_INLINE float getFpScale() const { return _fpScale; } CC_INLINE float getFpScaleInv() const { return _fpScaleInv; } CC_INLINE const RenderObjectList &getRenderObjects() const { return _renderObjects; } CC_INLINE float getShadingScale() const { return _shadingScale; } - CC_INLINE gfx::GFXInputAssembler *getQuadIA() const { return _quadIA; } + CC_INLINE gfx::InputAssembler *getQuadIA() const { return _quadIA; } CC_INLINE const String &getName() const { return _name; } CC_INLINE bool isHDRSupported() const { return _isHDRSupported; } @@ -91,7 +91,7 @@ protected: private: void activateFlow(RenderFlow *flow); - gfx::GFXFormat getTextureFormat(gfx::GFXFormat format, gfx::GFXTextureUsageBit usage) const; + gfx::Format getTextureFormat(gfx::Format format, gfx::TextureUsageBit usage) const; protected: String _name; @@ -100,9 +100,9 @@ protected: RenderObjectList _renderObjects; RenderFlowList _flows; RenderFlowList _activeFlows; - gfx::GFXDevice *_device = nullptr; - gfx::GFXInputAssembler *_quadIA = nullptr; - gfx::GFXTexture *_defaultTexture = nullptr; + gfx::Device *_device = nullptr; + gfx::InputAssembler *_quadIA = nullptr; + gfx::Texture *_defaultTexture = nullptr; float _shadingScale = 1.f; float _lightMeterScale = 1000.f; float _fpScale = 1.f / 1024; diff --git a/native/cocos/renderer/pipeline/RenderQueue.h b/native/cocos/renderer/pipeline/RenderQueue.h index 4719c2794b..3c8ca1a6c2 100644 --- a/native/cocos/renderer/pipeline/RenderQueue.h +++ b/native/cocos/renderer/pipeline/RenderQueue.h @@ -11,7 +11,7 @@ public: void clear(); bool insertRenderPass(RenderObject *renderObj, uint subModelIdx, uint passIdx); - void recordCommandBuffer(gfx::GFXDevice *device, gfx::GFXRenderPass *renderPass, gfx::GFXCommandBuffer *cmdBuff); + void recordCommandBuffer(gfx::Device *device, gfx::RenderPass *renderPass, gfx::CommandBuffer *cmdBuff); void sort(); private: diff --git a/native/cocos/renderer/pipeline/RenderStage.h b/native/cocos/renderer/pipeline/RenderStage.h index b7133f3342..26fd508404 100644 --- a/native/cocos/renderer/pipeline/RenderStage.h +++ b/native/cocos/renderer/pipeline/RenderStage.h @@ -5,7 +5,7 @@ namespace cc { namespace gfx { -class GFXFramebuffer; +class Framebuffer; } // namespace gfx namespace pipeline { @@ -36,22 +36,22 @@ public: void createBuffer(); void executeCommandBuffer(RenderView *view); - void setClearColor(/*color: IGFXColor*/); - void setClearColors(/*colors: IGFXColor[]*/); + void setClearColor(/*color: IColor*/); + void setClearColors(/*colors: IColor[]*/); void setClearDepth(float depth); void setClearStencil(float stencil); void setRenderArea(size_t width, size_t height); void sortRenderQueue(); CC_INLINE RenderFlow *getFlow() const { return _flow; } - CC_INLINE gfx::GFXFramebuffer *getFrameBuffer() const { return _frameBuffer; } + CC_INLINE gfx::Framebuffer *getFrameBuffer() const { return _frameBuffer; } CC_INLINE RenderPipeline *getPipeline() const { return _pipeline; } CC_INLINE int getPriority() const { return _priority; } protected: RenderFlow *_flow = nullptr; RenderPipeline *_pipeline = nullptr; - gfx::GFXFramebuffer *_frameBuffer = nullptr; + gfx::Framebuffer *_frameBuffer = nullptr; int _priority = 0; }; diff --git a/native/cocos/renderer/pipeline/RenderWindow.h b/native/cocos/renderer/pipeline/RenderWindow.h index 08159d0298..349e2aab7c 100644 --- a/native/cocos/renderer/pipeline/RenderWindow.h +++ b/native/cocos/renderer/pipeline/RenderWindow.h @@ -13,7 +13,7 @@ struct CC_DLL RenderWindowInfo { uint top = 0; uint width = 0; uint height = 0; - gfx::GFXRenderPassInfo *renderPassInfo = nullptr; + gfx::RenderPassInfo *renderPassInfo = nullptr; bool isOffscreen = false; }; @@ -28,10 +28,10 @@ public: CC_INLINE uint getWidth() const { return _width; } CC_INLINE uint geiHeight() const { return _height; } CC_INLINE bool isOffscreen() const { return _isOffscreen; } - CC_INLINE gfx::GFXRenderPass *getRenderPass() const { return _renderPass; } - CC_INLINE const gfx::GFXTextureList &getColorTextures() const { return _colorTexs; } - CC_INLINE gfx::GFXTexture *getDepthStencilTexture() const { return _depthStencilTex; } - CC_INLINE gfx::GFXFramebuffer *getFramebuffer() const { return _frameBuffer; } + CC_INLINE gfx::RenderPass *getRenderPass() const { return _renderPass; } + CC_INLINE const gfx::TextureList &getColorTextures() const { return _colorTexs; } + CC_INLINE gfx::Texture *getDepthStencilTexture() const { return _depthStencilTex; } + CC_INLINE gfx::Framebuffer *getFramebuffer() const { return _frameBuffer; } private: RenderWindow() = default; @@ -39,10 +39,10 @@ private: private: String title; - gfx::GFXTextureList _colorTexs; - gfx::GFXTexture *_depthStencilTex = nullptr; - gfx::GFXFramebuffer *_frameBuffer = nullptr; - gfx::GFXRenderPass *_renderPass = nullptr; + gfx::TextureList _colorTexs; + gfx::Texture *_depthStencilTex = nullptr; + gfx::Framebuffer *_frameBuffer = nullptr; + gfx::RenderPass *_renderPass = nullptr; Root *_root = nullptr; uint _width = 0; uint _height = 0; diff --git a/native/cocos/renderer/pipeline/forward/ForwardPipeline.h b/native/cocos/renderer/pipeline/forward/ForwardPipeline.h index 9c505cfde5..1f6b415ae7 100644 --- a/native/cocos/renderer/pipeline/forward/ForwardPipeline.h +++ b/native/cocos/renderer/pipeline/forward/ForwardPipeline.h @@ -18,15 +18,15 @@ public: virtual void sceneCulling() override; virtual vector &getLightIndices() const override; virtual vector &getLightIndexOffsets() const override; - virtual vector &getLightBuffers() const override; + virtual vector &getLightBuffers() const override; - CC_INLINE gfx::GFXBuffer *getLightsUBO() { return _lightsUBO; } + CC_INLINE gfx::Buffer *getLightsUBO() { return _lightsUBO; } private: void cullLightPerModel(cc::Model *model); private: - gfx::GFXBuffer *_lightsUBO = nullptr; + gfx::Buffer *_lightsUBO = nullptr; }; } // namespace pipeline diff --git a/native/cocos/scripting/js-bindings/manual/jsb_gfx_manual.cpp b/native/cocos/scripting/js-bindings/manual/jsb_gfx_manual.cpp index 158344859c..ce5c0a34a8 100644 --- a/native/cocos/scripting/js-bindings/manual/jsb_gfx_manual.cpp +++ b/native/cocos/scripting/js-bindings/manual/jsb_gfx_manual.cpp @@ -49,15 +49,15 @@ #define GFX_INVALID_BINDING ((uint8_t)-1) #define GFX_INVALID_HANDLE ((uint)-1) -bool js_GFXDevice_copyBuffersToTexture(se::State& s, cc::gfx::GFXDevice* cobj) +bool js_Device_copyBuffersToTexture(se::State& s, cc::gfx::Device* cobj) { const auto& args = s.args(); size_t argc = args.size(); CC_UNUSED bool ok = true; if (argc == 3) { - cc::gfx::GFXDataArray arg0; - cc::gfx::GFXTexture* arg1 = nullptr; - std::vector arg2; + cc::gfx::DataArray arg0; + cc::gfx::Texture* arg1 = nullptr; + std::vector arg2; if (args[0].isObject()) { se::Object* dataObj = args[0].toObject(); @@ -94,7 +94,7 @@ bool js_GFXDevice_copyBuffersToTexture(se::State& s, cc::gfx::GFXDevice* cobj) } ok &= seval_to_native_ptr(args[1], &arg1); ok &= seval_to_std_vector(args[2], &arg2); - SE_PRECONDITION2(ok, false, "js_gfx_GFXDevice_copyBuffersToTexture : Error processing arguments"); + SE_PRECONDITION2(ok, false, "js_gfx_Device_copyBuffersToTexture : Error processing arguments"); cobj->copyBuffersToTexture(arg0, arg1, arg2); return true; } @@ -103,15 +103,15 @@ bool js_GFXDevice_copyBuffersToTexture(se::State& s, cc::gfx::GFXDevice* cobj) return false; } -bool js_GFXDevice_copyTexImagesToTexture(se::State& s, cc::gfx::GFXDevice* cobj) +bool js_Device_copyTexImagesToTexture(se::State& s, cc::gfx::Device* cobj) { const auto& args = s.args(); size_t argc = args.size(); CC_UNUSED bool ok = true; if (argc == 3) { - cc::gfx::GFXDataArray arg0; - cc::gfx::GFXTexture* arg1 = nullptr; - std::vector arg2; + cc::gfx::DataArray arg0; + cc::gfx::Texture* arg1 = nullptr; + std::vector arg2; if (args[0].isObject()) { se::Object* dataObj = args[0].toObject(); @@ -138,7 +138,7 @@ bool js_GFXDevice_copyTexImagesToTexture(se::State& s, cc::gfx::GFXDevice* cobj) } ok &= seval_to_native_ptr(args[1], &arg1); ok &= seval_to_std_vector(args[2], &arg2); - SE_PRECONDITION2(ok, false, "js_gfx_GFXDevice_copyBuffersToTexture : Error processing arguments"); + SE_PRECONDITION2(ok, false, "js_gfx_Device_copyBuffersToTexture : Error processing arguments"); cobj->copyBuffersToTexture(arg0, arg1, arg2); return true; } @@ -146,45 +146,45 @@ bool js_GFXDevice_copyTexImagesToTexture(se::State& s, cc::gfx::GFXDevice* cobj) return false; } -static bool js_gfx_GFXDevice_createTexture(se::State& s) +static bool js_gfx_Device_createTexture(se::State& s) { - cc::gfx::GFXDevice* cobj = (cc::gfx::GFXDevice*)s.nativeThisObject(); - SE_PRECONDITION2( cobj, false, "js_gfx_GFXDevice_createTexture : Invalid Native Object"); + cc::gfx::Device* cobj = (cc::gfx::Device*)s.nativeThisObject(); + SE_PRECONDITION2( cobj, false, "js_gfx_Device_createTexture : Invalid Native Object"); const auto& args = s.args(); size_t argc = args.size(); if (argc == 2) { - cc::gfx::GFXTexture* texture = nullptr; + cc::gfx::Texture* texture = nullptr; bool createTextureView = false; seval_to_boolean(args[1], &createTextureView); if (createTextureView) { - auto textureViewInfo = (cc::gfx::GFXTextureViewInfo*)(args[0].toObject()->getPrivateData()); + auto textureViewInfo = (cc::gfx::TextureViewInfo*)(args[0].toObject()->getPrivateData()); texture = cobj->createTexture(*textureViewInfo); } else { - auto textureInfo = (cc::gfx::GFXTextureInfo*)(args[0].toObject()->getPrivateData()); + auto textureInfo = (cc::gfx::TextureInfo*)(args[0].toObject()->getPrivateData()); texture = cobj->createTexture(*textureInfo); } CC_UNUSED bool ok = native_ptr_to_seval(texture, &s.rval()); - SE_PRECONDITION2(ok, false, "js_gfx_GFXDevice_createTexture : Error processing arguments"); + SE_PRECONDITION2(ok, false, "js_gfx_Device_createTexture : Error processing arguments"); return true; } SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); return false; } -SE_BIND_FUNC(js_gfx_GFXDevice_createTexture) +SE_BIND_FUNC(js_gfx_Device_createTexture) -static bool js_gfx_GFXTexture_initialize(se::State& s) +static bool js_gfx_Texture_initialize(se::State& s) { CC_UNUSED bool ok = true; - cc::gfx::GFXTexture* cobj = (cc::gfx::GFXTexture*)s.nativeThisObject(); - SE_PRECONDITION2( cobj, false, "js_gfx_GFXTexture_initialize : Invalid Native Object"); + cc::gfx::Texture* cobj = (cc::gfx::Texture*)s.nativeThisObject(); + SE_PRECONDITION2( cobj, false, "js_gfx_Texture_initialize : Invalid Native Object"); const auto& args = s.args(); size_t argc = args.size(); @@ -194,31 +194,31 @@ static bool js_gfx_GFXTexture_initialize(se::State& s) if (initWithTextureViewInfo) { - auto textureViewInfo = (cc::gfx::GFXTextureViewInfo*)(args[0].toObject()->getPrivateData()); + auto textureViewInfo = (cc::gfx::TextureViewInfo*)(args[0].toObject()->getPrivateData()); ok &= cobj->initialize(*textureViewInfo); } else { - auto textureInfo = (cc::gfx::GFXTextureInfo*)(args[0].toObject()->getPrivateData()); + auto textureInfo = (cc::gfx::TextureInfo*)(args[0].toObject()->getPrivateData()); ok &= cobj->initialize(*textureInfo); } ok &= boolean_to_seval(ok, &s.rval()); - SE_PRECONDITION2(ok, false, "js_gfx_GFXTexture_initialize : Error processing arguments"); + SE_PRECONDITION2(ok, false, "js_gfx_Texture_initialize : Error processing arguments"); return true; } SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); return false; } -SE_BIND_FUNC(js_gfx_GFXTexture_initialize) +SE_BIND_FUNC(js_gfx_Texture_initialize) #ifdef USE_VULKAN static bool js_gfx_CCVKDevice_copyBuffersToTexture(se::State& s) { cc::gfx::CCVKDevice* cobj = (cc::gfx::CCVKDevice*)s.nativeThisObject(); SE_PRECONDITION2(cobj, false, "js_gfx_CCVKDevice_copyBuffersToTexture : Invalid Native Object"); - return js_GFXDevice_copyBuffersToTexture(s, cobj); + return js_Device_copyBuffersToTexture(s, cobj); } SE_BIND_FUNC(js_gfx_CCVKDevice_copyBuffersToTexture) @@ -226,7 +226,7 @@ static bool js_gfx_CCVKDevice_copyTexImagesToTexture(se::State& s) { cc::gfx::CCVKDevice* cobj = (cc::gfx::CCVKDevice*)s.nativeThisObject(); SE_PRECONDITION2(cobj, false, "js_gfx_CCVKDevice_copyTexImagesToTexture : Invalid Native Object"); - return js_GFXDevice_copyTexImagesToTexture(s, cobj); + return js_Device_copyTexImagesToTexture(s, cobj); } SE_BIND_FUNC(js_gfx_CCVKDevice_copyTexImagesToTexture); #endif // USE_GLES3 @@ -236,7 +236,7 @@ static bool js_gfx_CCMTLDevice_copyBuffersToTexture(se::State& s) { cc::gfx::CCMTLDevice* cobj = (cc::gfx::CCMTLDevice*)s.nativeThisObject(); SE_PRECONDITION2(cobj, false, "js_gfx_CCMTLDevice_copyBuffersToTexture : Invalid Native Object"); - return js_GFXDevice_copyBuffersToTexture(s, cobj); + return js_Device_copyBuffersToTexture(s, cobj); } SE_BIND_FUNC(js_gfx_CCMTLDevice_copyBuffersToTexture) @@ -244,7 +244,7 @@ static bool js_gfx_CCMTLDevice_copyTexImagesToTexture(se::State& s) { cc::gfx::CCMTLDevice* cobj = (cc::gfx::CCMTLDevice*)s.nativeThisObject(); SE_PRECONDITION2(cobj, false, "js_gfx_CCMTLDevice_copyTexImagesToTexture : Invalid Native Object"); - return js_GFXDevice_copyTexImagesToTexture(s, cobj); + return js_Device_copyTexImagesToTexture(s, cobj); } SE_BIND_FUNC(js_gfx_CCMTLDevice_copyTexImagesToTexture); #endif // USE_METAL @@ -254,7 +254,7 @@ static bool js_gfx_GLES3Device_copyBuffersToTexture(se::State& s) { cc::gfx::GLES3Device* cobj = (cc::gfx::GLES3Device*)s.nativeThisObject(); SE_PRECONDITION2(cobj, false, "js_gfx_GLES3Device_copyBuffersToTexture : Invalid Native Object"); - return js_GFXDevice_copyBuffersToTexture(s, cobj); + return js_Device_copyBuffersToTexture(s, cobj); } SE_BIND_FUNC(js_gfx_GLES3Device_copyBuffersToTexture) @@ -262,7 +262,7 @@ static bool js_gfx_GLES3Device_copyTexImagesToTexture(se::State& s) { cc::gfx::GLES3Device* cobj = (cc::gfx::GLES3Device*)s.nativeThisObject(); SE_PRECONDITION2(cobj, false, "js_gfx_GLES3Device_copyTexImagesToTexture : Invalid Native Object"); - return js_GFXDevice_copyTexImagesToTexture(s, cobj); + return js_Device_copyTexImagesToTexture(s, cobj); } SE_BIND_FUNC(js_gfx_GLES3Device_copyTexImagesToTexture); #endif // USE_GLES3 @@ -272,7 +272,7 @@ static bool js_gfx_GLES2Device_copyBuffersToTexture(se::State& s) { cc::gfx::GLES2Device* cobj = (cc::gfx::GLES2Device*)s.nativeThisObject(); SE_PRECONDITION2(cobj, false, "js_gfx_GLES2Device_copyBuffersToTexture : Invalid Native Object"); - return js_GFXDevice_copyBuffersToTexture(s, cobj); + return js_Device_copyBuffersToTexture(s, cobj); } SE_BIND_FUNC(js_gfx_GLES2Device_copyBuffersToTexture) @@ -280,14 +280,14 @@ static bool js_gfx_GLES2Device_copyTexImagesToTexture(se::State& s) { cc::gfx::GLES2Device* cobj = (cc::gfx::GLES2Device*)s.nativeThisObject(); SE_PRECONDITION2(cobj, false, "js_gfx_GLES2Device_copyTexImagesToTexture : Invalid Native Object"); - return js_GFXDevice_copyTexImagesToTexture(s, cobj); + return js_Device_copyTexImagesToTexture(s, cobj); } SE_BIND_FUNC(js_gfx_GLES2Device_copyTexImagesToTexture); #endif // USE_GLES2 static bool js_gfx_GFXBuffer_update(se::State& s) { - cc::gfx::GFXBuffer* cobj = (cc::gfx::GFXBuffer*)s.nativeThisObject(); + cc::gfx::Buffer* cobj = (cc::gfx::Buffer*)s.nativeThisObject(); SE_PRECONDITION2(cobj, false, "js_gfx_GFXBuffer_update : Invalid Native Object"); const auto& args = s.args(); size_t argc = args.size(); @@ -337,13 +337,13 @@ static bool js_gfx_GFXBuffer_update(se::State& s) } SE_BIND_FUNC(js_gfx_GFXBuffer_update) -se::Object* __jsb_cocos2d_GFXSubPass_proto = nullptr; -se::Class* __jsb_cocos2d_GFXSubPass_class = nullptr; +se::Object* __jsb_cocos2d_SubPass_proto = nullptr; +se::Class* __jsb_cocos2d_SubPass_class = nullptr; -static bool js_gfx_GFXSubPass_get_bind_point(se::State& s) +static bool js_gfx_SubPass_get_bind_point(se::State& s) { - cc::gfx::GFXSubPass* cobj = (cc::gfx::GFXSubPass*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_gfx_GFXSubPass_get_bind_point : Invalid Native Object"); + cc::gfx::SubPass* cobj = (cc::gfx::SubPass*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_gfx_SubPass_get_bind_point : Invalid Native Object"); CC_UNUSED bool ok = true; se::Value jsret; @@ -351,27 +351,27 @@ static bool js_gfx_GFXSubPass_get_bind_point(se::State& s) s.rval() = jsret; return true; } -SE_BIND_PROP_GET(js_gfx_GFXSubPass_get_bind_point) +SE_BIND_PROP_GET(js_gfx_SubPass_get_bind_point) -static bool js_gfx_GFXSubPass_set_bind_point(se::State& s) +static bool js_gfx_SubPass_set_bind_point(se::State& s) { const auto& args = s.args(); - cc::gfx::GFXSubPass* cobj = (cc::gfx::GFXSubPass*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_gfx_GFXSubPass_set_bind_point : Invalid Native Object"); + cc::gfx::SubPass* cobj = (cc::gfx::SubPass*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_gfx_SubPass_set_bind_point : Invalid Native Object"); CC_UNUSED bool ok = true; - cc::gfx::GFXPipelineBindPoint arg0 = cc::gfx::GFXPipelineBindPoint::GRAPHICS; - do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cc::gfx::GFXPipelineBindPoint)tmp; } while(false); - SE_PRECONDITION2(ok, false, "js_gfx_GFXSubPass_set_bind_point : Error processing new value"); + cc::gfx::PipelineBindPoint arg0 = cc::gfx::PipelineBindPoint::GRAPHICS; + do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cc::gfx::PipelineBindPoint)tmp; } while(false); + SE_PRECONDITION2(ok, false, "js_gfx_SubPass_set_bind_point : Error processing new value"); cobj->bindPoint = arg0; return true; } -SE_BIND_PROP_SET(js_gfx_GFXSubPass_set_bind_point) +SE_BIND_PROP_SET(js_gfx_SubPass_set_bind_point) -static bool js_gfx_GFXSubPass_get_inputs(se::State& s) +static bool js_gfx_SubPass_get_inputs(se::State& s) { - cc::gfx::GFXSubPass* cobj = (cc::gfx::GFXSubPass*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_gfx_GFXSubPass_get_inputs : Invalid Native Object"); + cc::gfx::SubPass* cobj = (cc::gfx::SubPass*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_gfx_SubPass_get_inputs : Invalid Native Object"); se::Value jsret; se::HandleObject obj(se::Object::createArrayObject(GFX_MAX_ATTACHMENTS)); @@ -382,25 +382,25 @@ static bool js_gfx_GFXSubPass_get_inputs(se::State& s) jsret.setObject(obj); return true; } -SE_BIND_PROP_GET(js_gfx_GFXSubPass_get_inputs) +SE_BIND_PROP_GET(js_gfx_SubPass_get_inputs) -static bool js_gfx_GFXSubPass_set_inputs(se::State& s) +static bool js_gfx_SubPass_set_inputs(se::State& s) { const auto& args = s.args(); - cc::gfx::GFXSubPass* cobj = (cc::gfx::GFXSubPass*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_gfx_GFXSubPass_set_inputs : Invalid Native Object"); + cc::gfx::SubPass* cobj = (cc::gfx::SubPass*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_gfx_SubPass_set_inputs : Invalid Native Object"); CC_UNUSED bool ok = true; ok &= seval_to_Uint8Array(args[0], cobj->inputs); - SE_PRECONDITION2(ok, false, "js_gfx_GFXSubPass_set_inputs : Error processing new value"); + SE_PRECONDITION2(ok, false, "js_gfx_SubPass_set_inputs : Error processing new value"); return true; } -SE_BIND_PROP_SET(js_gfx_GFXSubPass_set_inputs) +SE_BIND_PROP_SET(js_gfx_SubPass_set_inputs) -static bool js_gfx_GFXSubPass_get_colors(se::State& s) +static bool js_gfx_SubPass_get_colors(se::State& s) { - cc::gfx::GFXSubPass* cobj = (cc::gfx::GFXSubPass*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_gfx_GFXSubPass_get_colors : Invalid Native Object"); + cc::gfx::SubPass* cobj = (cc::gfx::SubPass*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_gfx_SubPass_get_colors : Invalid Native Object"); se::Value jsret; se::HandleObject obj(se::Object::createArrayObject(GFX_MAX_ATTACHMENTS)); @@ -411,25 +411,25 @@ static bool js_gfx_GFXSubPass_get_colors(se::State& s) jsret.setObject(obj); return true; } -SE_BIND_PROP_GET(js_gfx_GFXSubPass_get_colors) +SE_BIND_PROP_GET(js_gfx_SubPass_get_colors) -static bool js_gfx_GFXSubPass_set_colors(se::State& s) +static bool js_gfx_SubPass_set_colors(se::State& s) { const auto& args = s.args(); - cc::gfx::GFXSubPass* cobj = (cc::gfx::GFXSubPass*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_gfx_GFXSubPass_set_colors : Invalid Native Object"); + cc::gfx::SubPass* cobj = (cc::gfx::SubPass*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_gfx_SubPass_set_colors : Invalid Native Object"); CC_UNUSED bool ok = true; ok &= seval_to_Uint8Array(args[0], cobj->colors); - SE_PRECONDITION2(ok, false, "js_gfx_GFXSubPass_set_colors : Error processing new value"); + SE_PRECONDITION2(ok, false, "js_gfx_SubPass_set_colors : Error processing new value"); return true; } -SE_BIND_PROP_SET(js_gfx_GFXSubPass_set_colors) +SE_BIND_PROP_SET(js_gfx_SubPass_set_colors) -static bool js_gfx_GFXSubPass_get_resolves(se::State& s) +static bool js_gfx_SubPass_get_resolves(se::State& s) { - cc::gfx::GFXSubPass* cobj = (cc::gfx::GFXSubPass*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_gfx_GFXSubPass_get_resolves : Invalid Native Object"); + cc::gfx::SubPass* cobj = (cc::gfx::SubPass*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_gfx_SubPass_get_resolves : Invalid Native Object"); se::Value jsret; se::HandleObject obj(se::Object::createArrayObject(GFX_MAX_ATTACHMENTS)); @@ -440,26 +440,26 @@ static bool js_gfx_GFXSubPass_get_resolves(se::State& s) jsret.setObject(obj); return true; } -SE_BIND_PROP_GET(js_gfx_GFXSubPass_get_resolves) +SE_BIND_PROP_GET(js_gfx_SubPass_get_resolves) -static bool js_gfx_GFXSubPass_set_resolves(se::State& s) +static bool js_gfx_SubPass_set_resolves(se::State& s) { const auto& args = s.args(); - cc::gfx::GFXSubPass* cobj = (cc::gfx::GFXSubPass*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_gfx_GFXSubPass_set_resolves : Invalid Native Object"); + cc::gfx::SubPass* cobj = (cc::gfx::SubPass*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_gfx_SubPass_set_resolves : Invalid Native Object"); CC_UNUSED bool ok = true; ok &= seval_to_Uint8Array(args[0], cobj->resolves); - SE_PRECONDITION2(ok, false, "js_gfx_GFXSubPass_set_resolves : Error processing new value"); + SE_PRECONDITION2(ok, false, "js_gfx_SubPass_set_resolves : Error processing new value"); return true; } -SE_BIND_PROP_SET(js_gfx_GFXSubPass_set_resolves) +SE_BIND_PROP_SET(js_gfx_SubPass_set_resolves) -static bool js_gfx_GFXSubPass_get_depth_stencil(se::State& s) +static bool js_gfx_SubPass_get_depth_stencil(se::State& s) { - cc::gfx::GFXSubPass* cobj = (cc::gfx::GFXSubPass*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_gfx_GFXSubPass_get_depth_stencil : Invalid Native Object"); + cc::gfx::SubPass* cobj = (cc::gfx::SubPass*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_gfx_SubPass_get_depth_stencil : Invalid Native Object"); CC_UNUSED bool ok = true; se::Value jsret; @@ -467,27 +467,27 @@ static bool js_gfx_GFXSubPass_get_depth_stencil(se::State& s) s.rval() = jsret; return true; } -SE_BIND_PROP_GET(js_gfx_GFXSubPass_get_depth_stencil) +SE_BIND_PROP_GET(js_gfx_SubPass_get_depth_stencil) -static bool js_gfx_GFXSubPass_set_depth_stencil(se::State& s) +static bool js_gfx_SubPass_set_depth_stencil(se::State& s) { const auto& args = s.args(); - cc::gfx::GFXSubPass* cobj = (cc::gfx::GFXSubPass*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_gfx_GFXSubPass_set_depth_stencil : Invalid Native Object"); + cc::gfx::SubPass* cobj = (cc::gfx::SubPass*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_gfx_SubPass_set_depth_stencil : Invalid Native Object"); CC_UNUSED bool ok = true; uint8_t arg0; ok &= seval_to_uint8(args[0], (uint8_t*)&arg0); - SE_PRECONDITION2(ok, false, "js_gfx_GFXSubPass_set_depth_stencil : Error processing new value"); + SE_PRECONDITION2(ok, false, "js_gfx_SubPass_set_depth_stencil : Error processing new value"); cobj->depthStencil = arg0; return true; } -SE_BIND_PROP_SET(js_gfx_GFXSubPass_set_depth_stencil) +SE_BIND_PROP_SET(js_gfx_SubPass_set_depth_stencil) -static bool js_gfx_GFXSubPass_get_preserves(se::State& s) +static bool js_gfx_SubPass_get_preserves(se::State& s) { - cc::gfx::GFXSubPass* cobj = (cc::gfx::GFXSubPass*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_gfx_GFXSubPass_get_preserves : Invalid Native Object"); + cc::gfx::SubPass* cobj = (cc::gfx::SubPass*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_gfx_SubPass_get_preserves : Invalid Native Object"); se::Value jsret; se::HandleObject obj(se::Object::createArrayObject(GFX_MAX_ATTACHMENTS)); @@ -498,25 +498,25 @@ static bool js_gfx_GFXSubPass_get_preserves(se::State& s) jsret.setObject(obj); return true; } -SE_BIND_PROP_GET(js_gfx_GFXSubPass_get_preserves) +SE_BIND_PROP_GET(js_gfx_SubPass_get_preserves) -static bool js_gfx_GFXSubPass_set_preserves(se::State& s) +static bool js_gfx_SubPass_set_preserves(se::State& s) { const auto& args = s.args(); - cc::gfx::GFXSubPass* cobj = (cc::gfx::GFXSubPass*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_gfx_GFXSubPass_set_preserves : Invalid Native Object"); + cc::gfx::SubPass* cobj = (cc::gfx::SubPass*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_gfx_SubPass_set_preserves : Invalid Native Object"); CC_UNUSED bool ok = true; ok &= seval_to_Uint8Array(args[0], cobj->preserves); - SE_PRECONDITION2(ok, false, "js_gfx_GFXSubPass_set_preserves : Error processing new value"); + SE_PRECONDITION2(ok, false, "js_gfx_SubPass_set_preserves : Error processing new value"); return true; } -SE_BIND_PROP_SET(js_gfx_GFXSubPass_set_preserves) +SE_BIND_PROP_SET(js_gfx_SubPass_set_preserves) -SE_DECLARE_FINALIZE_FUNC(js_cocos2d_GFXSubPass_finalize) +SE_DECLARE_FINALIZE_FUNC(js_cocos2d_SubPass_finalize) -static bool js_gfx_GFXSubPass_constructor(se::State& s) +static bool js_gfx_SubPass_constructor(se::State& s) { CC_UNUSED bool ok = true; const auto& args = s.args(); @@ -524,7 +524,7 @@ static bool js_gfx_GFXSubPass_constructor(se::State& s) if(argc == 0) { - cc::gfx::GFXSubPass* cobj = new (std::nothrow) cc::gfx::GFXSubPass(); + cc::gfx::SubPass* cobj = new (std::nothrow) cc::gfx::SubPass(); s.thisObject()->setPrivateData(cobj); se::NonRefNativePtrCreatedByCtorMap::emplace(cobj); return true; @@ -534,17 +534,17 @@ static bool js_gfx_GFXSubPass_constructor(se::State& s) se::Object *json = args[0].toObject(); se::Value field; - cc::gfx::GFXSubPass* cobj = new (std::nothrow) cc::gfx::GFXSubPass(); + cc::gfx::SubPass* cobj = new (std::nothrow) cc::gfx::SubPass(); s.thisObject()->setPrivateData(cobj); se::NonRefNativePtrCreatedByCtorMap::emplace(cobj); - cc::gfx::GFXPipelineBindPoint arg0 = cc::gfx::GFXPipelineBindPoint::GRAPHICS; + cc::gfx::PipelineBindPoint arg0 = cc::gfx::PipelineBindPoint::GRAPHICS; json->getProperty("bind_point", &field); if(field.isUndefined()) { SE_REPORT_ERROR("argument Field \".bind_point\" is undefined!"); return false; } - do { int32_t tmp = 0; ok &= seval_to_int32(field, &tmp); arg0 = (cc::gfx::GFXPipelineBindPoint)tmp; } while(false); + do { int32_t tmp = 0; ok &= seval_to_int32(field, &tmp); arg0 = (cc::gfx::PipelineBindPoint)tmp; } while(false); cobj->bindPoint = arg0; json->getProperty("inputs", &field); @@ -553,7 +553,7 @@ static bool js_gfx_GFXSubPass_constructor(se::State& s) return false; } ok &= seval_to_Uint8Array(field, cobj->inputs); - SE_PRECONDITION2(ok, false, "js_gfx_GFXSubPass_constructor : Error processing inputs value"); + SE_PRECONDITION2(ok, false, "js_gfx_SubPass_constructor : Error processing inputs value"); json->getProperty("colors", &field); if(field.isUndefined()) { @@ -561,7 +561,7 @@ static bool js_gfx_GFXSubPass_constructor(se::State& s) return false; } ok &= seval_to_Uint8Array(field, cobj->colors); - SE_PRECONDITION2(ok, false, "js_gfx_GFXSubPass_constructor : Error processing colors value"); + SE_PRECONDITION2(ok, false, "js_gfx_SubPass_constructor : Error processing colors value"); json->getProperty("resolves", &field); if(field.isUndefined()) { @@ -569,7 +569,7 @@ static bool js_gfx_GFXSubPass_constructor(se::State& s) return false; } ok &= seval_to_Uint8Array(field, cobj->resolves); - SE_PRECONDITION2(ok, false, "js_gfx_GFXSubPass_constructor : Error processing resolves value"); + SE_PRECONDITION2(ok, false, "js_gfx_SubPass_constructor : Error processing resolves value"); json->getProperty("depth_stencil", &field); if(field.isUndefined()) { @@ -577,7 +577,7 @@ static bool js_gfx_GFXSubPass_constructor(se::State& s) return false; } ok &= seval_to_uint8(field, (uint8_t*)&cobj->depthStencil); - SE_PRECONDITION2(ok, false, "js_gfx_GFXSubPass_constructor : Error processing depth_stencil value"); + SE_PRECONDITION2(ok, false, "js_gfx_SubPass_constructor : Error processing depth_stencil value"); json->getProperty("preserves", &field); if(field.isUndefined()) { @@ -585,34 +585,34 @@ static bool js_gfx_GFXSubPass_constructor(se::State& s) return false; } ok &= seval_to_Uint8Array(field, cobj->preserves); - SE_PRECONDITION2(ok, false, "js_gfx_GFXSubPass_constructor : Error processing preserves value"); + SE_PRECONDITION2(ok, false, "js_gfx_SubPass_constructor : Error processing preserves value"); return true; } else if(argc == 6) { - cc::gfx::GFXSubPass* cobj = new (std::nothrow) cc::gfx::GFXSubPass(); + cc::gfx::SubPass* cobj = new (std::nothrow) cc::gfx::SubPass(); s.thisObject()->setPrivateData(cobj); se::NonRefNativePtrCreatedByCtorMap::emplace(cobj); - cc::gfx::GFXPipelineBindPoint arg0 = cc::gfx::GFXPipelineBindPoint::GRAPHICS; - do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cc::gfx::GFXPipelineBindPoint)tmp; } while(false); + cc::gfx::PipelineBindPoint arg0 = cc::gfx::PipelineBindPoint::GRAPHICS; + do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cc::gfx::PipelineBindPoint)tmp; } while(false); cobj->bindPoint = arg0; ok &= seval_to_Uint8Array(args[1], (uint8_t*)&cobj->inputs); - SE_PRECONDITION2(ok, false, "js_gfx_GFXSubPass_constructor : Error processing inputs value"); + SE_PRECONDITION2(ok, false, "js_gfx_SubPass_constructor : Error processing inputs value"); ok &= seval_to_Uint8Array(args[2], (uint8_t*)&cobj->colors); - SE_PRECONDITION2(ok, false, "js_gfx_GFXSubPass_constructor : Error processing colors value"); + SE_PRECONDITION2(ok, false, "js_gfx_SubPass_constructor : Error processing colors value"); ok &= seval_to_Uint8Array(args[3], (uint8_t*)&cobj->resolves); - SE_PRECONDITION2(ok, false, "js_gfx_GFXSubPass_constructor : Error processing resolves value"); + SE_PRECONDITION2(ok, false, "js_gfx_SubPass_constructor : Error processing resolves value"); ok &= seval_to_uint8(args[4], (uint8_t*)&cobj->depthStencil); - SE_PRECONDITION2(ok, false, "js_gfx_GFXSubPass_constructor : Error processing depth_stencil value"); + SE_PRECONDITION2(ok, false, "js_gfx_SubPass_constructor : Error processing depth_stencil value"); ok &= seval_to_Uint8Array(args[5], (uint8_t*)&cobj->preserves); - SE_PRECONDITION2(ok, false, "js_gfx_GFXSubPass_constructor : Error processing preserves value"); + SE_PRECONDITION2(ok, false, "js_gfx_SubPass_constructor : Error processing preserves value"); return true; } @@ -620,51 +620,51 @@ static bool js_gfx_GFXSubPass_constructor(se::State& s) SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); return false; } -SE_BIND_CTOR(js_gfx_GFXSubPass_constructor, __jsb_cocos2d_GFXSubPass_class, js_cocos2d_GFXSubPass_finalize) +SE_BIND_CTOR(js_gfx_SubPass_constructor, __jsb_cocos2d_SubPass_class, js_cocos2d_SubPass_finalize) -static bool js_cocos2d_GFXSubPass_finalize(se::State& s) +static bool js_cocos2d_SubPass_finalize(se::State& s) { - CC_LOG_INFO("jsbindings: finalizing JS object %p (cc::GFXSubPass)", s.nativeThisObject()); + CC_LOG_INFO("jsbindings: finalizing JS object %p (cc::SubPass)", s.nativeThisObject()); auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject()); if (iter != se::NonRefNativePtrCreatedByCtorMap::end()) { se::NonRefNativePtrCreatedByCtorMap::erase(iter); - cc::gfx::GFXSubPass* cobj = (cc::gfx::GFXSubPass*)s.nativeThisObject(); + cc::gfx::SubPass* cobj = (cc::gfx::SubPass*)s.nativeThisObject(); JSB_FREE(cobj); } return true; } -SE_BIND_FINALIZE_FUNC(js_cocos2d_GFXSubPass_finalize) +SE_BIND_FINALIZE_FUNC(js_cocos2d_SubPass_finalize) -bool js_register_gfx_GFXSubPass(se::Object* obj) +bool js_register_gfx_SubPass(se::Object* obj) { - auto cls = se::Class::create("GFXSubPass", obj, nullptr, _SE(js_gfx_GFXSubPass_constructor)); + auto cls = se::Class::create("SubPass", obj, nullptr, _SE(js_gfx_SubPass_constructor)); - cls->defineProperty("bindPoint", _SE(js_gfx_GFXSubPass_get_bind_point), _SE(js_gfx_GFXSubPass_set_bind_point)); - cls->defineProperty("inputs", _SE(js_gfx_GFXSubPass_get_inputs), _SE(js_gfx_GFXSubPass_set_inputs)); - cls->defineProperty("colors", _SE(js_gfx_GFXSubPass_get_colors), _SE(js_gfx_GFXSubPass_set_colors)); - cls->defineProperty("resolves", _SE(js_gfx_GFXSubPass_get_resolves), _SE(js_gfx_GFXSubPass_set_resolves)); - cls->defineProperty("depthStencil", _SE(js_gfx_GFXSubPass_get_depth_stencil), _SE(js_gfx_GFXSubPass_set_depth_stencil)); - cls->defineProperty("preserves", _SE(js_gfx_GFXSubPass_get_preserves), _SE(js_gfx_GFXSubPass_set_preserves)); - cls->defineFinalizeFunction(_SE(js_cocos2d_GFXSubPass_finalize)); + cls->defineProperty("bindPoint", _SE(js_gfx_SubPass_get_bind_point), _SE(js_gfx_SubPass_set_bind_point)); + cls->defineProperty("inputs", _SE(js_gfx_SubPass_get_inputs), _SE(js_gfx_SubPass_set_inputs)); + cls->defineProperty("colors", _SE(js_gfx_SubPass_get_colors), _SE(js_gfx_SubPass_set_colors)); + cls->defineProperty("resolves", _SE(js_gfx_SubPass_get_resolves), _SE(js_gfx_SubPass_set_resolves)); + cls->defineProperty("depthStencil", _SE(js_gfx_SubPass_get_depth_stencil), _SE(js_gfx_SubPass_set_depth_stencil)); + cls->defineProperty("preserves", _SE(js_gfx_SubPass_get_preserves), _SE(js_gfx_SubPass_set_preserves)); + cls->defineFinalizeFunction(_SE(js_cocos2d_SubPass_finalize)); cls->install(); - JSBClassType::registerClass(cls); + JSBClassType::registerClass(cls); - __jsb_cocos2d_GFXSubPass_proto = cls->getProto(); - __jsb_cocos2d_GFXSubPass_class = cls; + __jsb_cocos2d_SubPass_proto = cls->getProto(); + __jsb_cocos2d_SubPass_class = cls; se::ScriptEngine::getInstance()->clearException(); return true; } -static bool js_gfx_GFXPipelineLayout_get_layouts(se::State& s) +static bool js_gfx_PipelineLayout_get_layouts(se::State& s) { - cc::gfx::GFXPipelineLayout* cobj = (cc::gfx::GFXPipelineLayout*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_gfx_GFXPipelineLayout_layouts : Invalid Native Object"); + cc::gfx::PipelineLayout* cobj = (cc::gfx::PipelineLayout*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_gfx_PipelineLayout_layouts : Invalid Native Object"); const auto& args = s.args(); size_t argc = args.size(); if (argc == 0) { - const std::vector& result = cobj->getLayouts(); + const std::vector& result = cobj->getLayouts(); se::Value *layouts = &s.rval(); se::HandleObject arr(se::Object::createArrayObject(result.size())); @@ -684,17 +684,17 @@ static bool js_gfx_GFXPipelineLayout_get_layouts(se::State& s) SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); return false; } -SE_BIND_PROP_GET(js_gfx_GFXPipelineLayout_get_layouts) +SE_BIND_PROP_GET(js_gfx_PipelineLayout_get_layouts) -static bool js_gfx_GFXBlendState_get_targets(se::State& s) +static bool js_gfx_BlendState_get_targets(se::State& s) { - cc::gfx::GFXBlendState* cobj = (cc::gfx::GFXBlendState*)s.nativeThisObject(); + cc::gfx::BlendState* cobj = (cc::gfx::BlendState*)s.nativeThisObject(); SE_PRECONDITION2(cobj, false, "js_gfx_GFXBlendState_get_targets : Invalid Native Object"); CC_UNUSED bool ok = true; se::Value *jsTargets = &s.rval(); - const std::vector& targets = cobj->targets; + const std::vector& targets = cobj->targets; se::HandleObject arr(se::Object::createArrayObject(targets.size())); jsTargets->setObject(arr); @@ -709,32 +709,32 @@ static bool js_gfx_GFXBlendState_get_targets(se::State& s) } return true; } -SE_BIND_PROP_GET(js_gfx_GFXBlendState_get_targets) +SE_BIND_PROP_GET(js_gfx_BlendState_get_targets) -static bool js_gfx_GFXBlendState_set_targets(se::State& s) +static bool js_gfx_BlendState_set_targets(se::State& s) { const auto& args = s.args(); - cc::gfx::GFXBlendState* cobj = (cc::gfx::GFXBlendState*)s.nativeThisObject(); + cc::gfx::BlendState* cobj = (cc::gfx::BlendState*)s.nativeThisObject(); SE_PRECONDITION2(cobj, false, "js_gfx_GFXBlendState_set_targets : Invalid Native Object"); CC_UNUSED bool ok = true; - std::vector arg0; + std::vector arg0; ok &= seval_to_std_vector(args[0], &arg0); SE_PRECONDITION2(ok, false, "js_gfx_GFXBlendState_set_targets : Error processing new value"); cobj->targets = arg0; return true; } -SE_BIND_PROP_SET(js_gfx_GFXBlendState_set_targets) +SE_BIND_PROP_SET(js_gfx_BlendState_set_targets) -static bool js_gfx_GFXCommandBuffer_execute(se::State& s) +static bool js_gfx_CommandBuffer_execute(se::State& s) { - cc::gfx::GFXCommandBuffer* cobj = (cc::gfx::GFXCommandBuffer*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_gfx_GFXCommandBuffer_execute : Invalid Native Object"); + cc::gfx::CommandBuffer* cobj = (cc::gfx::CommandBuffer*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_gfx_CommandBuffer_execute : Invalid Native Object"); const auto& args = s.args(); size_t argc = args.size(); CC_UNUSED bool ok = true; if (argc == 2) { - std::vector cmdBufs; + std::vector cmdBufs; unsigned int count = 0; ok &= seval_to_uint32(args[1], (uint32_t*)&count); @@ -760,28 +760,28 @@ static bool js_gfx_GFXCommandBuffer_execute(se::State& s) break; } - cc::gfx::GFXCommandBuffer *cmdBuf = (cc::gfx::GFXCommandBuffer*)tmp.toObject()->getPrivateData(); + cc::gfx::CommandBuffer *cmdBuf = (cc::gfx::CommandBuffer*)tmp.toObject()->getPrivateData(); cmdBufs[i] = cmdBuf; } } - SE_PRECONDITION2(ok, false, "js_gfx_GFXCommandBuffer_execute : Error processing arguments"); + SE_PRECONDITION2(ok, false, "js_gfx_CommandBuffer_execute : Error processing arguments"); cobj->execute(cmdBufs, count); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); return false; } -SE_BIND_FUNC(js_gfx_GFXCommandBuffer_execute) +SE_BIND_FUNC(js_gfx_CommandBuffer_execute) -static bool js_gfx_GFXInputAssembler_extractDrawInfo(se::State& s) +static bool js_gfx_InputAssembler_extractDrawInfo(se::State& s) { - cc::gfx::GFXInputAssembler* cobj = (cc::gfx::GFXInputAssembler*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_gfx_GFXInputAssembler_extractDrawInfo : Invalid Native Object"); + cc::gfx::InputAssembler* cobj = (cc::gfx::InputAssembler*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_gfx_InputAssembler_extractDrawInfo : Invalid Native Object"); const auto& args = s.args(); size_t argc = args.size(); if (argc == 1) { - cc::gfx::GFXDrawInfo nativeDrawInfo; + cc::gfx::DrawInfo nativeDrawInfo; cobj->extractDrawInfo(nativeDrawInfo); se::Object* drawInfo = args[0].toObject(); @@ -811,21 +811,21 @@ static bool js_gfx_GFXInputAssembler_extractDrawInfo(se::State& s) SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); return false; } -SE_BIND_FUNC(js_gfx_GFXInputAssembler_extractDrawInfo) +SE_BIND_FUNC(js_gfx_InputAssembler_extractDrawInfo) bool register_all_gfx_manual(se::Object* obj) { - __jsb_cc_gfx_GFXBuffer_proto->defineFunction("update", _SE(js_gfx_GFXBuffer_update)); + __jsb_cc_gfx_Buffer_proto->defineFunction("update", _SE(js_gfx_GFXBuffer_update)); - __jsb_cc_gfx_GFXPipelineLayout_proto->defineProperty("layouts", _SE(js_gfx_GFXPipelineLayout_get_layouts), nullptr); + __jsb_cc_gfx_PipelineLayout_proto->defineProperty("layouts", _SE(js_gfx_PipelineLayout_get_layouts), nullptr); - __jsb_cc_gfx_GFXBlendState_proto->defineProperty("targets", _SE(js_gfx_GFXBlendState_get_targets), _SE(js_gfx_GFXBlendState_set_targets)); + __jsb_cc_gfx_BlendState_proto->defineProperty("targets", _SE(js_gfx_BlendState_get_targets), _SE(js_gfx_BlendState_set_targets)); - __jsb_cc_gfx_GFXCommandBuffer_proto->defineFunction("execute", _SE(js_gfx_GFXCommandBuffer_execute)); + __jsb_cc_gfx_CommandBuffer_proto->defineFunction("execute", _SE(js_gfx_CommandBuffer_execute)); - __jsb_cc_gfx_GFXInputAssembler_proto->defineFunction("extractDrawInfo", _SE(js_gfx_GFXInputAssembler_extractDrawInfo)); + __jsb_cc_gfx_InputAssembler_proto->defineFunction("extractDrawInfo", _SE(js_gfx_InputAssembler_extractDrawInfo)); - js_register_gfx_GFXSubPass(obj); + js_register_gfx_SubPass(obj); #if defined USE_VULKAN register_all_vk(obj); @@ -847,8 +847,8 @@ bool register_all_gfx_manual(se::Object* obj) __jsb_cc_gfx_CCMTLDevice_proto->defineFunction("copyBuffersToTexture", _SE(js_gfx_CCMTLDevice_copyBuffersToTexture)); __jsb_cc_gfx_CCMTLDevice_proto->defineFunction("copyTexImagesToTexture", _SE(js_gfx_CCMTLDevice_copyTexImagesToTexture)); #endif - __jsb_cc_gfx_GFXDevice_proto->defineFunction("createTexture", _SE(js_gfx_GFXDevice_createTexture)); - __jsb_cc_gfx_GFXTexture_proto->defineFunction("initialize", _SE(js_gfx_GFXTexture_initialize)); + __jsb_cc_gfx_Device_proto->defineFunction("createTexture", _SE(js_gfx_Device_createTexture)); + __jsb_cc_gfx_Texture_proto->defineFunction("initialize", _SE(js_gfx_Texture_initialize)); return true; } diff --git a/native/cocos/scripting/js-bindings/manual/jsb_global.cpp b/native/cocos/scripting/js-bindings/manual/jsb_global.cpp index 1876e549f0..3ac6298778 100644 --- a/native/cocos/scripting/js-bindings/manual/jsb_global.cpp +++ b/native/cocos/scripting/js-bindings/manual/jsb_global.cpp @@ -722,7 +722,7 @@ namespace uint32_t width = 0; uint32_t height = 0; uint8_t* data = nullptr; - cc::gfx::GFXFormat format = cc::gfx::GFXFormat::UNKNOWN; + cc::gfx::Format format = cc::gfx::Format::UNKNOWN; uint8_t bpp = 0; uint8_t numberOfMipmaps = 0; bool hasAlpha = false; @@ -783,22 +783,22 @@ namespace // will create a big texture, and update its content with small pictures. // The big texture is RGBA888, then the small picture should be the same // format, or it will cause 0x502 error on OpenGL ES 2. - if (!imgInfo->compressed && imgInfo->format != cc::gfx::GFXFormat::RGBA8) { + if (!imgInfo->compressed && imgInfo->format != cc::gfx::Format::RGBA8) { imgInfo->length = img->getWidth() * img->getHeight() * 4; uint8_t* dst = nullptr; uint32_t length = imgInfo->length; uint8_t* src = imgInfo->data; switch(imgInfo->format) { - case cc::gfx::GFXFormat::A8: - case cc::gfx::GFXFormat::LA8: + case cc::gfx::Format::A8: + case cc::gfx::Format::LA8: dst = convertIA2RGBA(length, src); break; - case cc::gfx::GFXFormat::L8: - case cc::gfx::GFXFormat::R8: - case cc::gfx::GFXFormat::R8I: + case cc::gfx::Format::L8: + case cc::gfx::Format::R8: + case cc::gfx::Format::R8I: dst = convertI2RGBA(length, src); break; - case cc::gfx::GFXFormat::RGB8: + case cc::gfx::Format::RGB8: dst = convertRGB2RGBA(length, src); break; default: diff --git a/native/tools/bindings-generator b/native/tools/bindings-generator index 8fcfe92fe5..04bd112b26 160000 --- a/native/tools/bindings-generator +++ b/native/tools/bindings-generator @@ -1 +1 @@ -Subproject commit 8fcfe92fe5beb8154f50b010433d50991b5f55fa +Subproject commit 04bd112b26b172f916a2d63a455e2c738bd0e51c diff --git a/native/tools/tojs/gfx.ini b/native/tools/tojs/gfx.ini index d9ec4710bf..cefcfc985e 100644 --- a/native/tools/tojs/gfx.ini +++ b/native/tools/tojs/gfx.ini @@ -33,7 +33,7 @@ replace_headers = # what classes to produce code for. You can use regular expressions here. When testing the regular # expression, it will be enclosed in "^$", like this: "^Menu.*$". -classes = GFXObject GFXDevice GFXBindingLayout GFXBuffer GFXCommandBuffer GFXFramebuffer GFXInputAssembler GFXPipelineLayout GFXPipelineState GFXFence GFXQueue GFXRenderPass GFXSampler GFXShader GFXTexture GFXAPI GFXFeature GFXFormat GFXFormatType GFXType GFXBufferUsageBit GFXBufferFlagBit GFXBufferAccessBit GFXMemoryUsageBit GFXTextureUsageBit GFXTextureFlagBit GFXSampleCount GFXFilter GFXAddress GFXComparisonFunc GFXStencilOp GFXBlendFactor GFXBlendOp GFXColorMask GFXShaderType GFXLoadOp GFXStoreOp GFXTextureLayout GFXPipelineBindPoint GFXPrimitiveMode GFXPolygonMode GFXShadeModel GFXCullMode GFXDynamicState GFXStencilFace GFXBindingType GFXQueueType GFXCommandBufferType GFXClearFlagBit GFXVsyncMode GFXOffset GFXRect GFXExtent GFXTextureSubres GFXTextureCopy GFXBufferTextureCopy GFXViewport GFXColor GFXDeviceInfo GFXContextInfo GFXBufferInfo GFXDrawInfo GFXIndirectBuffer GFXTextureInfo GFXTextureViewInfo GFXSamplerInfo GFXShaderMacro GFXUniform GFXUniformBlock GFXUniformSampler GFXShaderStage GFXShaderInfo GFXAttribute GFXInputAssemblerInfo GFXColorAttachment GFXDepthStencilAttachment GFXRenderPassInfo GFXFramebufferInfo GFXBinding GFXBindingLayoutInfo GFXBindingUnit GFXPushConstantRange GFXPipelineLayoutInfo GFXInputState GFXRasterizerState GFXDepthStencilState GFXBlendTarget GFXBlendState GFXPipelineStateInfo GFXCommandAllocator GFXCommandAllocatorInfo GFXCommandBufferInfo GFXQueueInfo GFXFormatInfo GFXObjectType GFXStatus GFXMemoryStatus +classes = GFXObject Device BindingLayout Buffer CommandBuffer Framebuffer InputAssembler PipelineLayout PipelineState Fence Queue RenderPass Sampler Shader Texture API Feature Format FormatType Type BufferUsageBit BufferFlagBit BufferAccessBit TextureUsageBit TextureFlagBit ShaderType TextureLayout QueueType CommandBufferType Offset Rect Extent TextureSubres TextureCopy BufferTextureCopy Viewport Color DeviceInfo ContextInfo BufferInfo DrawInfo IndirectBuffer TextureInfo TextureViewInfo SamplerInfo ShaderMacro Uniform UniformBlock UniformSampler ShaderStage ShaderInfo Attribute InputAssemblerInfo ColorAttachment DepthStencilAttachment RenderPassInfo FramebufferInfo Binding BindingLayoutInfo BindingUnit PushConstantRange PipelineLayoutInfo InputState RasterizerState DepthStencilState BlendTarget BlendState PipelineStateInfo CommandAllocator CommandAllocatorInfo CommandBufferInfo QueueInfo FormatInfo MemoryStatus classes_need_extend = @@ -44,43 +44,43 @@ classes_need_extend = # will apply to all class names. This is a convenience wildcard to be able to skip similar named # functions from all classes. -skip = GFXBindingLayout::[GFXBindingLayout], - GFXBuffer::[GFXBuffer update], - GFXCommandBuffer::[GFXCommandBuffer execute], - GFXCommandAllocator::[GFXCommandAllocator], - GFXFramebuffer::[GFXFramebuffer], - GFXInputAssembler::[GFXInputAssembler extractDrawInfo], - GFXPipelineLayout::[GFXPipelineLayout pushConstantsRanges layouts], - GFXPipelineState::[GFXPipelineState], - GFXFence::[GFXFence], - GFXQueue::[GFXQueue], - GFXRenderPass::[GFXRenderPass], - GFXSampler::[GFXSampler], - GFXShader::[GFXShader], - GFXTexture::[GFXTexture initialize], +skip = BindingLayout::[BindingLayout], + Buffer::[Buffer update], + CommandBuffer::[CommandBuffer execute], + CommandAllocator::[CommandAllocator], + Framebuffer::[Framebuffer], + InputAssembler::[InputAssembler extractDrawInfo], + PipelineLayout::[PipelineLayout pushConstantsRanges layouts], + PipelineState::[PipelineState], + Fence::[Fence], + Queue::[Queue], + RenderPass::[RenderPass], + Sampler::[Sampler], + Shader::[Shader], + Texture::[Texture initialize], CCMTLCommandAllocator::[clearCommands], - GFXDevice::[copyBuffersToTexture createTexture], - GFXBlendState::[targets] + Device::[copyBuffersToTexture createTexture], + BlendState::[targets] -getter_setter = GFXDevice::[gfxAPI deviceName width height nativeWidth nativeHeight memoryStatus context queue commandAllocator renderer vendor numDrawCalls numInstances numTris maxVertexAttributes maxVertexUniformVectors maxFragmentUniformVectors maxTextureUnits maxVertexTextureUnits maxUniformBufferBindings maxUniformBlockSize maxTextureSize maxCubeMapTextureSize depthBits stencilBits reverseCW shaderIdGen colorFormat depthStencilFormat minClipZ projectionSignY], - GFXShader::[device name hash stages attributes blocks samplers], - GFXTexture::[type usage format width height depth arrayLayer mipLevel size samples flags buffer], - GFXBindingLayout::[device bindingUnits], - GFXQueue::[device type], - GFXRenderPass::[device colorAttachments depthStencilAttachment subPasses hash], - GFXPipelineLayout::[device], - GFXPipelineState::[device shader primitive inputState rasterizerState depthStencilState blendState pipelineLayout renderPass], - GFXInputAssembler::[device vertexBuffers attributes indexBuffer indirectBuffer vertexCount firstVertex indexCount firstIndex vertexOffset instanceCount firstInstance attributesHash], - GFXCommanduffer::[device allocator type numDrawCalls numInstances numTris], - GFXContext::[device sharedContext/sharedContext vsyncMode colorFormat depthStencilFormat], - GFXFramebuffer::[device renderPass colorTextures depthStencilTexture isOffscreen/isOffscreen], - GFXBuffer::[device usage memUsage stride count size flags bufferView], - GFXSampler::[device name minFilter magFilter mipFilter addressU addressV addressW maxAnisotropy cmpFunc borderColor minLOD maxLOD mipLODBias], - GFXObject::[status gfxType/getType] +getter_setter = Device::[gfxAPI deviceName width height nativeWidth nativeHeight memoryStatus context queue commandAllocator renderer vendor numDrawCalls numInstances numTris maxVertexAttributes maxVertexUniformVectors maxFragmentUniformVectors maxTextureUnits maxVertexTextureUnits maxUniformBufferBindings maxUniformBlockSize maxTextureSize maxCubeMapTextureSize depthBits stencilBits reverseCW shaderIdGen colorFormat depthStencilFormat minClipZ projectionSignY], + Shader::[device name hash stages attributes blocks samplers], + Texture::[type usage format width height depth arrayLayer mipLevel size samples flags buffer], + BindingLayout::[device bindingUnits], + Queue::[device type], + RenderPass::[device colorAttachments depthStencilAttachment subPasses hash], + PipelineLayout::[device], + PipelineState::[device shader primitive inputState rasterizerState depthStencilState blendState pipelineLayout renderPass], + InputAssembler::[device vertexBuffers attributes indexBuffer indirectBuffer vertexCount firstVertex indexCount firstIndex vertexOffset instanceCount firstInstance attributesHash], + Commanduffer::[device allocator type numDrawCalls numInstances numTris], + Context::[device sharedContext/sharedContext vsyncMode colorFormat depthStencilFormat], + Framebuffer::[device renderPass colorTextures depthStencilTexture isOffscreen/isOffscreen], + Buffer::[device usage memUsage stride count size flags bufferView], + Sampler::[device name minFilter magFilter mipFilter addressU addressV addressW maxAnisotropy cmpFunc borderColor minLOD maxLOD mipLODBias], + GFXObject::[status Type/getType] rename_functions = -rename_classes = +rename_classes = Device::GFXDevice # for all class names, should we remove something when registering in the target VM? remove_prefix = @@ -93,7 +93,7 @@ base_classes_to_skip = Ref Clonable Object # classes that create no constructor # Set is special and we will use a hand-written constructor -abstract_classes = GFXDevice +abstract_classes = Device persistent_classes =