Lothario
/
axmol
mirror of https://github.com/axmolengine/axmol.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Feature/fix mipmap issues (#19753) 

* fix mipmap

* fix mipmap issues

* remove unneeded code

* fix

* remove Texture2D::PixelFormat, add backend::PixelFormat

* fix lua compile error

* reset *.tps files

* fix compile error

* fix compile error
This commit is contained in:
coulsonwang 2019-06-03 09:39:51 +08:00 committed by minggo
parent a67f729610
commit 10b2799051
51 changed files with 781 additions and 1212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cocos/2d/CCAutoPolygon.cpp
View File

@ -187,7 +187,7 @@ AutoPolygon::AutoPolygon(const std::string &filename)
_filename = filename;
_image = new (std::nothrow) Image();
_image->initWithImageFile(filename);
CCASSERT(_image->getPixelFormat()==Texture2D::PixelFormat::RGBA8888, "unsupported format, currently only supports rgba8888");
CCASSERT(_image->getPixelFormat()==backend::PixelFormat::RGBA8888, "unsupported format, currently only supports rgba8888");
_data = _image->getData();
_width = _image->getWidth();
_height = _image->getHeight();

12
cocos/2d/CCFontAtlas.cpp
View File

@ -144,18 +144,18 @@ FontAtlas::~FontAtlas()
void FontAtlas::initTextureWithZeros(Texture2D *texture)
{
char *zeros = nullptr;
Texture2D::PixelFormat pixelFormat;
backend::PixelFormat pixelFormat;
float outlineSize = _fontFreeType->getOutlineSize();
size_t zeroBytes = 0;
if (outlineSize > 0)
{
//metal do no support AI88 format
pixelFormat = Texture2D::PixelFormat::RGBA8888;
pixelFormat = backend::PixelFormat::RGBA8888;
zeroBytes = CacheTextureWidth * CacheTextureWidth * 4;
}
else
{
pixelFormat = Texture2D::PixelFormat::A8;
pixelFormat = backend::PixelFormat::A8;
zeroBytes = CacheTextureWidth * CacheTextureWidth;
}
zeros = new char[zeroBytes]();
@ -389,7 +389,7 @@ bool FontAtlas::prepareLetterDefinitions(const std::u32string& utf32Text)
FontLetterDefinition tempDef;
auto scaleFactor = CC_CONTENT_SCALE_FACTOR();
auto pixelFormat = _fontFreeType->getOutlineSize() > 0 ? Texture2D::PixelFormat::AI88 : Texture2D::PixelFormat::A8;
auto pixelFormat = _fontFreeType->getOutlineSize() > 0 ? backend::PixelFormat::AI88 : backend::PixelFormat::A8;
float startY = _currentPageOrigY;
@ -477,11 +477,11 @@ bool FontAtlas::prepareLetterDefinitions(const std::u32string& utf32Text)
return true;
}
void FontAtlas::updateTextureContent(Texture2D::PixelFormat format, int startY)
void FontAtlas::updateTextureContent(backend::PixelFormat format, int startY)
{
unsigned char *data = nullptr;
auto outlineSize = _fontFreeType->getOutlineSize();
if (outlineSize > 0 && format == Texture2D::PixelFormat::AI88)
if (outlineSize > 0 && format == backend::PixelFormat::AI88)
{
int nLen = CacheTextureWidth * (_currentPageOrigY - startY + _currLineHeight);
data = _currentPageData + CacheTextureWidth * (int)startY * 2;

2
cocos/2d/CCFontAtlas.h
View File

@ -131,7 +131,7 @@ protected:
*/
void scaleFontLetterDefinition(float scaleFactor);
void updateTextureContent(Texture2D::PixelFormat format, int startY);
void updateTextureContent(backend::PixelFormat format, int startY);
std::unordered_map<ssize_t, Texture2D*> _atlasTextures;
std::unordered_map<char32_t, FontLetterDefinition> _letterDefinitions;

2
cocos/2d/CCGrid.cpp
View File

@ -63,7 +63,7 @@ bool GridBase::initWithSize(const cocos2d::Size &gridSize, const cocos2d::Rect &
descriptor.width = POTWide;
descriptor.height = POTHigh;
descriptor.textureUsage = backend::TextureUsage::RENDER_TARGET;
descriptor.textureFormat = backend::TextureFormat::R8G8B8A8;
descriptor.textureFormat = backend::PixelFormat::RGBA8888;
auto backendTexture = backend::Device::getInstance()->newTexture(descriptor);
texture->initWithBackendTexture(backendTexture);
backendTexture->release();

25
cocos/2d/CCRenderTexture.cpp
View File

@ -38,7 +38,6 @@ THE SOFTWARE.
#include "renderer/CCTextureCache.h"
#include "renderer/backend/Device.h"
#include "renderer/backend/Texture.h"
#include "renderer/backend/StringUtils.h"
NS_CC_BEGIN
@ -77,11 +76,11 @@ void RenderTexture::listenToBackground(EventCustom* /*event*/)
_UITextureImage = uiTextureImage;
CC_SAFE_RETAIN(_UITextureImage);
const Size& s = _texture2D->getContentSizeInPixels();
VolatileTextureMgr::addDataTexture(_texture2D, uiTextureImage->getData(), s.width * s.height * 4, Texture2D::PixelFormat::RGBA8888, s);
VolatileTextureMgr::addDataTexture(_texture2D, uiTextureImage->getData(), s.width * s.height * 4, backend::PixelFormat::RGBA8888, s);
if ( _texture2DCopy )
{
VolatileTextureMgr::addDataTexture(_texture2DCopy, uiTextureImage->getData(), s.width * s.height * 4, Texture2D::PixelFormat::RGBA8888, s);
VolatileTextureMgr::addDataTexture(_texture2DCopy, uiTextureImage->getData(), s.width * s.height * 4, backend::PixelFormat::RGBA8888, s);
}
}
else
@ -114,7 +113,7 @@ void RenderTexture::listenToForeground(EventCustom* /*event*/)
#endif
}
RenderTexture * RenderTexture::create(int w, int h, Texture2D::PixelFormat eFormat)
RenderTexture * RenderTexture::create(int w, int h, backend::PixelFormat eFormat)
{
RenderTexture *ret = new (std::nothrow) RenderTexture();
@ -127,7 +126,7 @@ RenderTexture * RenderTexture::create(int w, int h, Texture2D::PixelFormat eForm
return nullptr;
}
RenderTexture * RenderTexture::create(int w ,int h, Texture2D::PixelFormat eFormat, TextureFormat uDepthStencilFormat)
RenderTexture * RenderTexture::create(int w ,int h, backend::PixelFormat eFormat, PixelFormat uDepthStencilFormat)
{
RenderTexture *ret = new (std::nothrow) RenderTexture();
@ -144,7 +143,7 @@ RenderTexture * RenderTexture::create(int w, int h)
{
RenderTexture *ret = new (std::nothrow) RenderTexture();
if(ret && ret->initWithWidthAndHeight(w, h, Texture2D::PixelFormat::RGBA8888, TextureFormat::NONE))
if(ret && ret->initWithWidthAndHeight(w, h, backend::PixelFormat::RGBA8888, PixelFormat::NONE))
{
ret->autorelease();
return ret;
@ -153,14 +152,14 @@ RenderTexture * RenderTexture::create(int w, int h)
return nullptr;
}
bool RenderTexture::initWithWidthAndHeight(int w, int h, Texture2D::PixelFormat eFormat)
bool RenderTexture::initWithWidthAndHeight(int w, int h, backend::PixelFormat eFormat)
{
return initWithWidthAndHeight(w, h, eFormat, TextureFormat::NONE);
return initWithWidthAndHeight(w, h, eFormat, PixelFormat::NONE);
}
bool RenderTexture::initWithWidthAndHeight(int w, int h, Texture2D::PixelFormat format, TextureFormat depthStencilFormat)
bool RenderTexture::initWithWidthAndHeight(int w, int h, backend::PixelFormat format, PixelFormat depthStencilFormat)
{
CCASSERT(format != Texture2D::PixelFormat::A8, "only RGB and RGBA formats are valid for a render texture");
CCASSERT(format != backend::PixelFormat::A8, "only RGB and RGBA formats are valid for a render texture");
bool ret = false;
do
@ -189,7 +188,7 @@ bool RenderTexture::initWithWidthAndHeight(int w, int h, Texture2D::PixelFormat
descriptor.width = powW;
descriptor.height = powH;
descriptor.textureUsage = TextureUsage::RENDER_TARGET;
descriptor.textureFormat = TextureFormat::R8G8B8A8;
descriptor.textureFormat = PixelFormat::RGBA8888;
auto texture = backend::Device::getInstance()->newTexture(descriptor);
if (! texture)
break;
@ -207,7 +206,7 @@ bool RenderTexture::initWithWidthAndHeight(int w, int h, Texture2D::PixelFormat
clearColorAttachment();
if (TextureFormat::D24S8 == depthStencilFormat)
if (PixelFormat::D24S8 == depthStencilFormat)
{
_renderTargetFlags = RenderTargetFlag::ALL;
descriptor.textureFormat = depthStencilFormat;
@ -411,7 +410,7 @@ void RenderTexture::onSaveToFile(const std::string& filename, bool isRGBA)
/* get buffer as Image */
void RenderTexture::newImage(std::function<void(Image*)> imageCallback, bool flipImage)
{
CCASSERT(_pixelFormat == Texture2D::PixelFormat::RGBA8888, "only RGBA8888 can be saved as image");
CCASSERT(_pixelFormat == backend::PixelFormat::RGBA8888, "only RGBA8888 can be saved as image");
if ((nullptr == _texture2D))
{

11
cocos/2d/CCRenderTexture.h
View File

@ -32,6 +32,7 @@ THE SOFTWARE.
#include "renderer/CCGroupCommand.h"
#include "renderer/CCCustomCommand.h"
#include "renderer/CCCallbackCommand.h"
#include "renderer/backend/Types.h"
NS_CC_BEGIN
@ -66,7 +67,7 @@ public:
* @param format In Points and a pixel format( only RGB and RGBA formats are valid ).
* @param depthStencilFormat The depthStencil format.
*/
static RenderTexture * create(int w ,int h, Texture2D::PixelFormat format, TextureFormat depthStencilFormat);
static RenderTexture * create(int w ,int h, backend::PixelFormat format, backend::PixelFormat depthStencilFormat);
/** Creates a RenderTexture object with width and height in Points and a pixel format, only RGB and RGBA formats are valid.
*
@ -74,7 +75,7 @@ public:
* @param h The RenderTexture object height.
* @param format In Points and a pixel format( only RGB and RGBA formats are valid ).
*/
static RenderTexture * create(int w, int h, Texture2D::PixelFormat format);
static RenderTexture * create(int w, int h, backend::PixelFormat format);
/** Creates a RenderTexture object with width and height in Points, pixel format is RGBA8888.
*
@ -303,7 +304,7 @@ public:
* @param format In Points and a pixel format( only RGB and RGBA formats are valid ).
* @return If succeed, it will return true.
*/
bool initWithWidthAndHeight(int w, int h, Texture2D::PixelFormat format);
bool initWithWidthAndHeight(int w, int h, backend::PixelFormat format);
/** Initializes a RenderTexture object with width and height in Points and a pixel format( only RGB and RGBA formats are valid ) and depthStencil format.
*
* @param w The RenderTexture object width.
@ -312,7 +313,7 @@ public:
* @param depthStencilFormat The depthStencil format.
* @return If succeed, it will return true.
*/
bool initWithWidthAndHeight(int w, int h, Texture2D::PixelFormat format, TextureFormat depthStencilFormat);
bool initWithWidthAndHeight(int w, int h, backend::PixelFormat format, backend::PixelFormat depthStencilFormat);
protected:
virtual void beginWithClear(float r, float g, float b, float a, float depthValue, int stencilValue, ClearFlag flags);
@ -339,7 +340,7 @@ protected:
RenderTargetFlag _renderTargetFlags;
RenderTargetFlag _oldRenderTargetFlag;
Image* _UITextureImage = nullptr;
Texture2D::PixelFormat _pixelFormat = Texture2D::PixelFormat::RGBA8888;
backend::PixelFormat _pixelFormat = backend::PixelFormat::RGBA8888;
Color4F _clearColor;
float _clearDepth = 1.f;

30
cocos/2d/CCSpriteFrameCache.cpp
View File

@ -307,26 +307,26 @@ void SpriteFrameCache::addSpriteFramesWithDictionary(ValueMap& dict, const std::
}
Texture2D *texture = nullptr;
static std::unordered_map<std::string, Texture2D::PixelFormat> pixelFormats = {
{"RGBA8888", Texture2D::PixelFormat::RGBA8888},
{"RGBA4444", Texture2D::PixelFormat::RGBA4444},
{"RGB5A1", Texture2D::PixelFormat::RGB5A1},
{"RGBA5551", Texture2D::PixelFormat::RGB5A1},
{"RGB565", Texture2D::PixelFormat::RGB565},
{"A8", Texture2D::PixelFormat::A8},
{"ALPHA", Texture2D::PixelFormat::A8},
{"I8", Texture2D::PixelFormat::I8},
{"AI88", Texture2D::PixelFormat::AI88},
{"ALPHA_INTENSITY", Texture2D::PixelFormat::AI88},
//{"BGRA8888", Texture2D::PixelFormat::BGRA8888}, no Image conversion RGBA -> BGRA
{"RGB888", Texture2D::PixelFormat::RGB888}
static std::unordered_map<std::string, backend::PixelFormat> pixelFormats = {
{"RGBA8888", backend::PixelFormat::RGBA8888},
{"RGBA4444", backend::PixelFormat::RGBA4444},
{"RGB5A1", backend::PixelFormat::RGB5A1},
{"RGBA5551", backend::PixelFormat::RGB5A1},
{"RGB565", backend::PixelFormat::RGB565},
{"A8", backend::PixelFormat::A8},
{"ALPHA", backend::PixelFormat::A8},
{"I8", backend::PixelFormat::I8},
{"AI88", backend::PixelFormat::AI88},
{"ALPHA_INTENSITY", backend::PixelFormat::AI88},
//{"BGRA8888", backend::PixelFormat::BGRA8888}, no Image conversion RGBA -> BGRA
{"RGB888", backend::PixelFormat::RGB888}
};
auto pixelFormatIt = pixelFormats.find(pixelFormatName);
if (pixelFormatIt != pixelFormats.end())
{
const Texture2D::PixelFormat pixelFormat = (*pixelFormatIt).second;
const Texture2D::PixelFormat currentPixelFormat = Texture2D::getDefaultAlphaPixelFormat();
const backend::PixelFormat pixelFormat = (*pixelFormatIt).second;
const backend::PixelFormat currentPixelFormat = Texture2D::getDefaultAlphaPixelFormat();
Texture2D::setDefaultAlphaPixelFormat(pixelFormat);
texture = Director::getInstance()->getTextureCache()->addImage(texturePath);
Texture2D::setDefaultAlphaPixelFormat(currentPixelFormat);

4
cocos/2d/CCTransition.cpp
View File

@ -1317,7 +1317,7 @@ void TransitionCrossFade::onEnter()
LayerColor* layer = LayerColor::create(color);
// create the first render texture for inScene
RenderTexture* inTexture = RenderTexture::create((int)size.width, (int)size.height,Texture2D::PixelFormat::RGBA8888, TextureFormat::D24S8);
RenderTexture* inTexture = RenderTexture::create((int)size.width, (int)size.height,backend::PixelFormat::RGBA8888, PixelFormat::D24S8);
if (nullptr == inTexture)
{
@ -1334,7 +1334,7 @@ void TransitionCrossFade::onEnter()
inTexture->end();
// create the second render texture for outScene
RenderTexture* outTexture = RenderTexture::create((int)size.width, (int)size.height,Texture2D::PixelFormat::RGBA8888, TextureFormat::D24S8);
RenderTexture* outTexture = RenderTexture::create((int)size.width, (int)size.height,backend::PixelFormat::RGBA8888, PixelFormat::D24S8);
outTexture->getSprite()->setAnchorPoint( Vec2(0.5f,0.5f) );
outTexture->setPosition(size.width/2, size.height/2);
outTexture->setAnchorPoint( Vec2(0.5f,0.5f) );

2
cocos/2d/CCTransitionProgress.cpp
View File

@ -72,7 +72,7 @@ void TransitionProgress::onEnter()
Size size = Director::getInstance()->getWinSize();
// create the second render texture for outScene
RenderTexture *texture = RenderTexture::create((int)size.width, (int)size.height,Texture2D::PixelFormat::RGBA8888, backend::TextureFormat::D24S8);
RenderTexture *texture = RenderTexture::create((int)size.width, (int)size.height,backend::PixelFormat::RGBA8888, backend::PixelFormat::D24S8);
texture->getSprite()->setAnchorPoint(Vec2(0.5f,0.5f));
texture->setPosition(size.width/2, size.height/2);
texture->setAnchorPoint(Vec2(0.5f,0.5f));

6
cocos/3d/CCTerrain.cpp
View File

@ -370,13 +370,13 @@ float Terrain::getImageHeight(int pixel_x, int pixel_y) const
int byte_stride = 1;
switch (_heightMapImage->getPixelFormat())
{
case Texture2D::PixelFormat::BGRA8888:
case backend::PixelFormat::BGRA8888:
byte_stride = 4;
break;
case Texture2D::PixelFormat::RGB888:
case backend::PixelFormat::RGB888:
byte_stride = 3;
break;
case Texture2D::PixelFormat::I8:
case backend::PixelFormat::I8:
byte_stride = 1;
break;
default:

10
cocos/base/CCDirector.cpp
View File

@ -223,11 +223,11 @@ void Director::setDefaultValues(void)
// Default pixel format for PNG images with alpha
std::string pixel_format = conf->getValue("cocos2d.x.texture.pixel_format_for_png", Value("rgba8888")).asString();
if (pixel_format == "rgba8888")
Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::RGBA8888);
Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat::RGBA8888);
else if(pixel_format == "rgba4444")
Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::RGBA4444);
Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat::RGBA4444);
else if(pixel_format == "rgba5551")
Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::RGB5A1);
Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat::RGB5A1);
// PVR v2 has alpha premultiplied ?
bool pvr_alpha_premultiplied = conf->getValue("cocos2d.x.texture.pvrv2_has_alpha_premultiplied", Value(false)).asBool();
@ -1250,8 +1250,8 @@ void Director::createStatsLabel()
FileUtils::getInstance()->purgeCachedEntries();
}
Texture2D::PixelFormat currentFormat = Texture2D::getDefaultAlphaPixelFormat();
Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::RGBA4444);
backend::PixelFormat currentFormat = Texture2D::getDefaultAlphaPixelFormat();
Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat::RGBA4444);
unsigned char *data = nullptr;
ssize_t dataLength = 0;
getFPSImageData(&data, &dataLength);

6
cocos/base/CCNinePatchImageParser.cpp
View File

@ -48,7 +48,7 @@ NinePatchImageParser::NinePatchImageParser(Image* image)
,_isRotated(false)
{
this->_imageFrame = Rect(0,0,image->getWidth(), image->getHeight());
CCASSERT(image->getPixelFormat()==Texture2D::PixelFormat::RGBA8888,
CCASSERT(image->getPixelFormat()==backend::PixelFormat::RGBA8888,
"unsupported format, currently only supports rgba8888");
}
@ -57,7 +57,7 @@ NinePatchImageParser::NinePatchImageParser(Image* image, const Rect& frame, bool
,_imageFrame(frame)
,_isRotated(rotated)
{
CCASSERT(image->getPixelFormat()==Texture2D::PixelFormat::RGBA8888,
CCASSERT(image->getPixelFormat()==backend::PixelFormat::RGBA8888,
"unsupported format, currently only supports rgba8888");
}
@ -192,7 +192,7 @@ Rect NinePatchImageParser::parseCapInset() const
void NinePatchImageParser::setSpriteFrameInfo(Image* image, const cocos2d::Rect& frameRect, bool rotated )
{
this->_image = image;
CCASSERT(image->getPixelFormat()==Texture2D::PixelFormat::RGBA8888,
CCASSERT(image->getPixelFormat()==backend::PixelFormat::RGBA8888,
"unsupported format, currently only supports rgba8888");
this->_imageFrame = frameRect;
this->_isRotated = rotated;

4
cocos/base/ccTypes.h
View File

@ -653,10 +653,8 @@ enum class RenderTargetFlag : uint8_t
ALL = COLOR | DEPTH | STENCIL
};
ENABLE_BITMASK_OPERATORS(RenderTargetFlag)
// export backend types to cocos2d namespance
using TextureFormat = backend::TextureFormat;
using TextureUsage = backend::TextureUsage;
using PixelFormat = backend::PixelFormat;
NS_CC_END
// end group

4
cocos/base/ccUtils.cpp
View File

@ -181,7 +181,7 @@ void captureNode(Node* startNode, std::function<void(Image*)> imageCallback, flo
RenderTexture* finalRtx = nullptr;
auto rtx = RenderTexture::create(size.width, size.height, Texture2D::PixelFormat::RGBA8888, TextureFormat::D24S8);
auto rtx = RenderTexture::create(size.width, size.height, backend::PixelFormat::RGBA8888, PixelFormat::D24S8);
// rtx->setKeepMatrix(true);
Point savedPos = startNode->getPosition();
Point anchor;
@ -204,7 +204,7 @@ void captureNode(Node* startNode, std::function<void(Image*)> imageCallback, flo
#ifndef CC_USE_METAL
sprite->setFlippedY(true);
#endif
finalRtx = RenderTexture::create(size.width * scale, size.height * scale, Texture2D::PixelFormat::RGBA8888, TextureFormat::D24S8);
finalRtx = RenderTexture::create(size.width * scale, size.height * scale, backend::PixelFormat::RGBA8888, PixelFormat::D24S8);
sprite->setScale(scale); // or use finalRtx->setKeepMatrix(true);
finalRtx->begin();

126
cocos/platform/CCImage.cpp
View File

@ -215,47 +215,47 @@ namespace
// v2
typedef const std::map<PVR2TexturePixelFormat, Texture2D::PixelFormat> _pixel2_formathash;
typedef const std::map<PVR2TexturePixelFormat, backend::PixelFormat> _pixel2_formathash;
static const _pixel2_formathash::value_type v2_pixel_formathash_value[] =
{
_pixel2_formathash::value_type(PVR2TexturePixelFormat::BGRA8888, Texture2D::PixelFormat::BGRA8888),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::RGBA8888, Texture2D::PixelFormat::RGBA8888),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::RGBA4444, Texture2D::PixelFormat::RGBA4444),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::RGBA5551, Texture2D::PixelFormat::RGB5A1),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::RGB565, Texture2D::PixelFormat::RGB565),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::RGB888, Texture2D::PixelFormat::RGB888),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::A8, Texture2D::PixelFormat::A8),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::I8, Texture2D::PixelFormat::I8),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::AI88, Texture2D::PixelFormat::AI88),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::BGRA8888, backend::PixelFormat::BGRA8888),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::RGBA8888, backend::PixelFormat::RGBA8888),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::RGBA4444, backend::PixelFormat::RGBA4444),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::RGBA5551, backend::PixelFormat::RGB5A1),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::RGB565, backend::PixelFormat::RGB565),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::RGB888, backend::PixelFormat::RGB888),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::A8, backend::PixelFormat::A8),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::I8, backend::PixelFormat::I8),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::AI88, backend::PixelFormat::AI88),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::PVRTC2BPP_RGBA, Texture2D::PixelFormat::PVRTC2A),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::PVRTC4BPP_RGBA, Texture2D::PixelFormat::PVRTC4A),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::PVRTC2BPP_RGBA, backend::PixelFormat::PVRTC2A),
_pixel2_formathash::value_type(PVR2TexturePixelFormat::PVRTC4BPP_RGBA, backend::PixelFormat::PVRTC4A),
};
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<PVR3TexturePixelFormat, Texture2D::PixelFormat> _pixel3_formathash;
typedef const std::map<PVR3TexturePixelFormat, backend::PixelFormat> _pixel3_formathash;
static _pixel3_formathash::value_type v3_pixel_formathash_value[] =
{
_pixel3_formathash::value_type(PVR3TexturePixelFormat::BGRA8888, Texture2D::PixelFormat::BGRA8888),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::RGBA8888, Texture2D::PixelFormat::RGBA8888),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::RGBA4444, Texture2D::PixelFormat::RGBA4444),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::RGBA5551, Texture2D::PixelFormat::RGB5A1),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::RGB565, Texture2D::PixelFormat::RGB565),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::RGB888, Texture2D::PixelFormat::RGB888),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::A8, Texture2D::PixelFormat::A8),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::L8, Texture2D::PixelFormat::I8),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::LA88, Texture2D::PixelFormat::AI88),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::BGRA8888, backend::PixelFormat::BGRA8888),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::RGBA8888, backend::PixelFormat::RGBA8888),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::RGBA4444, backend::PixelFormat::RGBA4444),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::RGBA5551, backend::PixelFormat::RGB5A1),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::RGB565, backend::PixelFormat::RGB565),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::RGB888, backend::PixelFormat::RGB888),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::A8, backend::PixelFormat::A8),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::L8, backend::PixelFormat::I8),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::LA88, backend::PixelFormat::AI88),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC2BPP_RGB, Texture2D::PixelFormat::PVRTC2),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC2BPP_RGBA, Texture2D::PixelFormat::PVRTC2A),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC4BPP_RGB, Texture2D::PixelFormat::PVRTC4),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC4BPP_RGBA, Texture2D::PixelFormat::PVRTC4A),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC2BPP_RGB, backend::PixelFormat::PVRTC2),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC2BPP_RGBA, backend::PixelFormat::PVRTC2A),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC4BPP_RGB, backend::PixelFormat::PVRTC4),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::PVRTC4BPP_RGBA, backend::PixelFormat::PVRTC4A),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::ETC1, Texture2D::PixelFormat::ETC),
_pixel3_formathash::value_type(PVR3TexturePixelFormat::ETC1, backend::PixelFormat::ETC),
};
static const int PVR3_MAX_TABLE_ELEMENTS = sizeof(v3_pixel_formathash_value) / sizeof(v3_pixel_formathash_value[0]);
@ -455,22 +455,22 @@ namespace
#endif //CC_USE_PNG
}
Texture2D::PixelFormat getDevicePixelFormat(Texture2D::PixelFormat format)
backend::PixelFormat getDevicePixelFormat(backend::PixelFormat format)
{
switch (format) {
case Texture2D::PixelFormat::PVRTC4:
case Texture2D::PixelFormat::PVRTC4A:
case Texture2D::PixelFormat::PVRTC2:
case Texture2D::PixelFormat::PVRTC2A:
case backend::PixelFormat::PVRTC4:
case backend::PixelFormat::PVRTC4A:
case backend::PixelFormat::PVRTC2:
case backend::PixelFormat::PVRTC2A:
if(Configuration::getInstance()->supportsPVRTC())
return format;
else
return Texture2D::PixelFormat::RGBA8888;
case Texture2D::PixelFormat::ETC:
return backend::PixelFormat::RGBA8888;
case backend::PixelFormat::ETC:
if(Configuration::getInstance()->supportsETC())
return format;
else
return Texture2D::PixelFormat::RGB888;
return backend::PixelFormat::RGB888;
default:
return format;
}
@ -488,7 +488,7 @@ Image::Image()
, _height(0)
, _unpack(false)
, _fileType(Format::UNKNOWN)
, _pixelFormat(Texture2D::PixelFormat::NONE)
, _pixelFormat(backend::PixelFormat::NONE)
, _numberOfMipmaps(0)
, _hasPremultipliedAlpha(false)
{
@ -875,11 +875,11 @@ bool Image::initWithJpgData(const unsigned char * data, ssize_t dataLen)
// we only support RGB or grayscale
if (cinfo.jpeg_color_space == JCS_GRAYSCALE)
{
_pixelFormat = Texture2D::PixelFormat::I8;
_pixelFormat = backend::PixelFormat::I8;
}else
{
cinfo.out_color_space = JCS_RGB;
_pixelFormat = Texture2D::PixelFormat::RGB888;
_pixelFormat = backend::PixelFormat::RGB888;
}
/* Start decompression jpeg here */
@ -1003,16 +1003,16 @@ bool Image::initWithPngData(const unsigned char * data, ssize_t dataLen)
switch (color_type)
{
case PNG_COLOR_TYPE_GRAY:
_pixelFormat = Texture2D::PixelFormat::I8;
_pixelFormat = backend::PixelFormat::I8;
break;
case PNG_COLOR_TYPE_GRAY_ALPHA:
_pixelFormat = Texture2D::PixelFormat::AI88;
_pixelFormat = backend::PixelFormat::AI88;
break;
case PNG_COLOR_TYPE_RGB:
_pixelFormat = Texture2D::PixelFormat::RGB888;
_pixelFormat = backend::PixelFormat::RGB888;
break;
case PNG_COLOR_TYPE_RGB_ALPHA:
_pixelFormat = Texture2D::PixelFormat::RGBA8888;
_pixelFormat = backend::PixelFormat::RGBA8888;
break;
default:
break;
@ -1211,7 +1211,7 @@ bool Image::initWithTiffData(const unsigned char * data, ssize_t dataLen)
npixels = w * h;
_pixelFormat = Texture2D::PixelFormat::RGBA8888;
_pixelFormat = backend::PixelFormat::RGBA8888;
_width = w;
_height = h;
@ -1635,7 +1635,7 @@ bool Image::initWithETCData(const unsigned char * data, ssize_t dataLen)
{
//old opengl version has no define for GL_ETC1_RGB8_OES, add macro to make compiler happy.
#ifdef GL_ETC1_RGB8_OES
_pixelFormat = Texture2D::PixelFormat::ETC;
_pixelFormat = backend::PixelFormat::ETC;
_dataLen = dataLen - ETC_PKM_HEADER_SIZE;
_data = static_cast<unsigned char*>(malloc(_dataLen * sizeof(unsigned char)));
memcpy(_data, static_cast<const unsigned char*>(data) + ETC_PKM_HEADER_SIZE, _dataLen);
@ -1651,7 +1651,7 @@ bool Image::initWithETCData(const unsigned char * data, ssize_t dataLen)
//if it is not gles or device do not support ETC, decode texture by software
int bytePerPixel = 3;
unsigned int stride = _width * bytePerPixel;
_pixelFormat = Texture2D::PixelFormat::RGB888;
_pixelFormat = backend::PixelFormat::RGB888;
_dataLen = _width * _height * bytePerPixel;
_data = static_cast<unsigned char*>(malloc(_dataLen * sizeof(unsigned char)));
@ -1686,15 +1686,15 @@ bool Image::initWithTGAData(tImageTGA* tgaData)
// unsupported RGB555
if (tgaData->pixelDepth == 16)
{
_pixelFormat = Texture2D::PixelFormat::RGB5A1;
_pixelFormat = backend::PixelFormat::RGB5A1;
}
else if(tgaData->pixelDepth == 24)
{
_pixelFormat = Texture2D::PixelFormat::RGB888;
_pixelFormat = backend::PixelFormat::RGB888;
}
else if(tgaData->pixelDepth == 32)
{
_pixelFormat = Texture2D::PixelFormat::RGBA8888;
_pixelFormat = backend::PixelFormat::RGBA8888;
}
else
{
@ -1707,7 +1707,7 @@ bool Image::initWithTGAData(tImageTGA* tgaData)
// gray
if (8 == tgaData->pixelDepth)
{
_pixelFormat = Texture2D::PixelFormat::I8;
_pixelFormat = backend::PixelFormat::I8;
}
else
{
@ -1805,18 +1805,18 @@ bool Image::initWithS3TCData(const unsigned char * data, ssize_t dataLen)
if (FOURCC_DXT1 == header->ddsd.DUMMYUNIONNAMEN4.ddpfPixelFormat.fourCC)
{
_pixelFormat = Texture2D::PixelFormat::S3TC_DXT1;
_pixelFormat = backend::PixelFormat::S3TC_DXT1;
}
else if (FOURCC_DXT3 == header->ddsd.DUMMYUNIONNAMEN4.ddpfPixelFormat.fourCC)
{
_pixelFormat = Texture2D::PixelFormat::S3TC_DXT3;
_pixelFormat = backend::PixelFormat::S3TC_DXT3;
}
else if (FOURCC_DXT5 == header->ddsd.DUMMYUNIONNAMEN4.ddpfPixelFormat.fourCC)
{
_pixelFormat = Texture2D::PixelFormat::S3TC_DXT5;
_pixelFormat = backend::PixelFormat::S3TC_DXT5;
}
} else { //will software decode
_pixelFormat = Texture2D::PixelFormat::RGBA8888;
_pixelFormat = backend::PixelFormat::RGBA8888;
}
/* load the mipmaps */
@ -1954,13 +1954,13 @@ bool Image::initWithATITCData(const unsigned char *data, ssize_t dataLen)
switch (header->glInternalFormat)
{
case CC_GL_ATC_RGB_AMD:
_pixelFormat = Texture2D::PixelFormat::ATC_RGB;
_pixelFormat = backend::PixelFormat::ATC_RGB;
break;
case CC_GL_ATC_RGBA_EXPLICIT_ALPHA_AMD:
_pixelFormat = Texture2D::PixelFormat::ATC_EXPLICIT_ALPHA;
_pixelFormat = backend::PixelFormat::ATC_EXPLICIT_ALPHA;
break;
case CC_GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD:
_pixelFormat = Texture2D::PixelFormat::ATC_INTERPOLATED_ALPHA;
_pixelFormat = backend::PixelFormat::ATC_INTERPOLATED_ALPHA;
break;
default:
break;
@ -1977,7 +1977,7 @@ bool Image::initWithATITCData(const unsigned char *data, ssize_t dataLen)
int bytePerPixel = 4;
unsigned int stride = width * bytePerPixel;
_pixelFormat = Texture2D::PixelFormat::RGBA8888;
_pixelFormat = backend::PixelFormat::RGBA8888;
std::vector<unsigned char> decodeImageData(stride * height);
switch (header->glInternalFormat)
@ -2028,7 +2028,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;
_pixelFormat = config.input.has_alpha?Texture2D::PixelFormat::RGBA8888:Texture2D::PixelFormat::RGB888;
_pixelFormat = config.input.has_alpha?backend::PixelFormat::RGBA8888:backend::PixelFormat::RGB888;
_width = config.input.width;
_height = config.input.height;
@ -2070,7 +2070,7 @@ bool Image::initWithRawData(const unsigned char * data, ssize_t /*dataLen*/, int
_height = height;
_width = width;
_hasPremultipliedAlpha = preMulti;
_pixelFormat = Texture2D::PixelFormat::RGBA8888;
_pixelFormat = backend::PixelFormat::RGBA8888;
// only RGBA8888 supported
int bytesPerComponent = 4;
@ -2089,10 +2089,10 @@ bool Image::initWithRawData(const unsigned char * data, ssize_t /*dataLen*/, int
#if (CC_TARGET_PLATFORM != CC_PLATFORM_IOS)
bool Image::saveToFile(const std::string& filename, bool isToRGB)
{
//only support for Texture2D::PixelFormat::RGB888 or Texture2D::PixelFormat::RGBA8888 uncompressed data
if (isCompressed() || (_pixelFormat != Texture2D::PixelFormat::RGB888 && _pixelFormat != Texture2D::PixelFormat::RGBA8888))
//only support for backend::PixelFormat::RGB888 or backend::PixelFormat::RGBA8888 uncompressed data
if (isCompressed() || (_pixelFormat != backend::PixelFormat::RGB888 && _pixelFormat != backend::PixelFormat::RGBA8888))
{
CCLOG("cocos2d: Image: saveToFile is only support for Texture2D::PixelFormat::RGB888 or Texture2D::PixelFormat::RGBA8888 uncompressed data for now");
CCLOG("cocos2d: Image: saveToFile is only support for backend::PixelFormat::RGB888 or backend::PixelFormat::RGBA8888 uncompressed data for now");
return false;
}
@ -2347,7 +2347,7 @@ void Image::premultipliedAlpha()
_hasPremultipliedAlpha = false;
return;
#else
CCASSERT(_pixelFormat == Texture2D::PixelFormat::RGBA8888, "The pixel format should be RGBA8888!");
CCASSERT(_pixelFormat == backend::PixelFormat::RGBA8888, "The pixel format should be RGBA8888!");
unsigned int* fourBytes = (unsigned int*)_data;
for(int i = 0; i < _width * _height; i++)

4
cocos/platform/CCImage.h
View File

@ -136,7 +136,7 @@ public:
unsigned char * getData() { return _data; }
ssize_t getDataLen() { return _dataLen; }
Format getFileType() { return _fileType; }
Texture2D::PixelFormat getPixelFormat() { return _pixelFormat; }
backend::PixelFormat getPixelFormat() { return _pixelFormat; }
int getWidth() { return _width; }
int getHeight() { return _height; }
int getNumberOfMipmaps() { return _numberOfMipmaps; }
@ -191,7 +191,7 @@ protected:
int _height;
bool _unpack;
Format _fileType;
Texture2D::PixelFormat _pixelFormat;
backend::PixelFormat _pixelFormat;
MipmapInfo _mipmaps[MIPMAP_MAX]; // pointer to mipmap images
int _numberOfMipmaps;
// false if we can't auto detect the image is premultiplied or not.

6
cocos/platform/ios/CCImage-ios.mm
View File

@ -40,10 +40,10 @@ NS_CC_BEGIN
bool cocos2d::Image::saveToFile(const std::string& filename, bool isToRGB)
{
//only support for Texture2D::PixelFormat::RGB888 or Texture2D::PixelFormat::RGBA8888 uncompressed data
if (isCompressed() || (_pixelFormat != Texture2D::PixelFormat::RGB888 && _pixelFormat != Texture2D::PixelFormat::RGBA8888))
//only support for backend::PixelFormat::RGB888 or backend::PixelFormat::RGBA8888 uncompressed data
if (isCompressed() || (_pixelFormat != backend::PixelFormat::RGB888 && _pixelFormat != backend::PixelFormat::RGBA8888))
{
CCLOG("cocos2d: Image: saveToFile is only support for Texture2D::PixelFormat::RGB888 or Texture2D::PixelFormat::RGBA8888 uncompressed data for now");
CCLOG("cocos2d: Image: saveToFile is only support for backend::PixelFormat::RGB888 or backend::PixelFormat::RGBA8888 uncompressed data for now");
return false;
}
bool saveToPNG = false;

10
cocos/renderer/CCRenderer.cpp
View File

@ -758,9 +758,9 @@ backend::RenderPipeline* Renderer::getRenderPipeline(const backend::RenderPipeli
{
void* program;
unsigned int vertexLayoutInfo[32];
backend::TextureFormat colorAttachment;
backend::TextureFormat depthAttachment;
backend::TextureFormat stencilAttachment;
backend::PixelFormat colorAttachment;
backend::PixelFormat depthAttachment;
backend::PixelFormat stencilAttachment;
bool blendEnabled;
unsigned int writeMask;
unsigned int rgbBlendOperation;
@ -850,7 +850,7 @@ void Renderer::setRenderPipeline(const PipelineDescriptor& pipelineDescriptor, c
}
else
{
renderPipelineDescriptor.depthAttachmentFormat = TextureFormat::D24S8;
renderPipelineDescriptor.depthAttachmentFormat = PixelFormat::D24S8;
}
if (renderPassDescriptor.stencilAttachmentTexture)
@ -859,7 +859,7 @@ void Renderer::setRenderPipeline(const PipelineDescriptor& pipelineDescriptor, c
}
else
{
renderPipelineDescriptor.stencilAttachmentFormat = TextureFormat::D24S8;
renderPipelineDescriptor.stencilAttachmentFormat = PixelFormat::D24S8;
}
}

295
cocos/renderer/CCTexture2D.cpp
View File

@ -44,7 +44,6 @@ THE SOFTWARE.
#include "base/CCDirector.h"
#include "base/CCNinePatchImageParser.h"
#include "renderer/backend/Device.h"
#include "renderer/backend/StringUtils.h"
#include "renderer/backend/ProgramState.h"
#include "renderer/ccShaders.h"
#include "renderer/CCTextureUtils.h"
@ -62,127 +61,72 @@ namespace {
typedef Texture2D::PixelFormatInfoMap::value_type PixelFormatInfoMapValue;
static const PixelFormatInfoMapValue TexturePixelFormatInfoTablesValue[] =
{
PixelFormatInfoMapValue(Texture2D::PixelFormat::BGRA8888, Texture2D::PixelFormatInfo(GL_BGRA, GL_BGRA, GL_UNSIGNED_BYTE, 32, false, true)),
PixelFormatInfoMapValue(Texture2D::PixelFormat::RGBA8888, Texture2D::PixelFormatInfo(GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, 32, false, true)),
PixelFormatInfoMapValue(Texture2D::PixelFormat::RGBA4444, Texture2D::PixelFormatInfo(GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, 16, false, true)),
PixelFormatInfoMapValue(Texture2D::PixelFormat::RGB5A1, Texture2D::PixelFormatInfo(GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, 16, false, true)),
PixelFormatInfoMapValue(Texture2D::PixelFormat::RGB565, Texture2D::PixelFormatInfo(GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 16, false, false)),
PixelFormatInfoMapValue(Texture2D::PixelFormat::RGB888, Texture2D::PixelFormatInfo(GL_RGB, GL_RGB, GL_UNSIGNED_BYTE, 24, false, false)),
PixelFormatInfoMapValue(Texture2D::PixelFormat::A8, Texture2D::PixelFormatInfo(GL_ALPHA, GL_ALPHA, GL_UNSIGNED_BYTE, 8, false, false)),
PixelFormatInfoMapValue(Texture2D::PixelFormat::I8, Texture2D::PixelFormatInfo(GL_LUMINANCE, GL_LUMINANCE, GL_UNSIGNED_BYTE, 8, false, false)),
PixelFormatInfoMapValue(Texture2D::PixelFormat::AI88, Texture2D::PixelFormatInfo(GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 16, false, true)),
PixelFormatInfoMapValue(backend::PixelFormat::BGRA8888, Texture2D::PixelFormatInfo(GL_BGRA, GL_BGRA, GL_UNSIGNED_BYTE, 32, false, true)),
PixelFormatInfoMapValue(backend::PixelFormat::RGBA8888, Texture2D::PixelFormatInfo(GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, 32, false, true)),
PixelFormatInfoMapValue(backend::PixelFormat::RGBA4444, Texture2D::PixelFormatInfo(GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, 16, false, true)),
PixelFormatInfoMapValue(backend::PixelFormat::RGB5A1, Texture2D::PixelFormatInfo(GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, 16, false, true)),
PixelFormatInfoMapValue(backend::PixelFormat::RGB565, Texture2D::PixelFormatInfo(GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 16, false, false)),
PixelFormatInfoMapValue(backend::PixelFormat::RGB888, Texture2D::PixelFormatInfo(GL_RGB, GL_RGB, GL_UNSIGNED_BYTE, 24, false, false)),
PixelFormatInfoMapValue(backend::PixelFormat::A8, Texture2D::PixelFormatInfo(GL_ALPHA, GL_ALPHA, GL_UNSIGNED_BYTE, 8, false, false)),
PixelFormatInfoMapValue(backend::PixelFormat::I8, Texture2D::PixelFormatInfo(GL_LUMINANCE, GL_LUMINANCE, GL_UNSIGNED_BYTE, 8, false, false)),
PixelFormatInfoMapValue(backend::PixelFormat::AI88, Texture2D::PixelFormatInfo(GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 16, false, true)),
#ifndef CC_USE_METAL
//OpenGL only
#ifdef GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG
PixelFormatInfoMapValue(Texture2D::PixelFormat::PVRTC2, Texture2D::PixelFormatInfo(GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG, 0xFFFFFFFF, 0xFFFFFFFF, 2, true, false)),
PixelFormatInfoMapValue(Texture2D::PixelFormat::PVRTC2A, Texture2D::PixelFormatInfo(GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, 0xFFFFFFFF, 0xFFFFFFFF, 2, true, true)),
PixelFormatInfoMapValue(Texture2D::PixelFormat::PVRTC4, Texture2D::PixelFormatInfo(GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG, 0xFFFFFFFF, 0xFFFFFFFF, 4, true, false)),
PixelFormatInfoMapValue(Texture2D::PixelFormat::PVRTC4A, Texture2D::PixelFormatInfo(GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, 0xFFFFFFFF, 0xFFFFFFFF, 4, true, true)),
PixelFormatInfoMapValue(backend::PixelFormat::PVRTC2, Texture2D::PixelFormatInfo(GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG, 0xFFFFFFFF, 0xFFFFFFFF, 2, true, false)),
PixelFormatInfoMapValue(backend::PixelFormat::PVRTC2A, Texture2D::PixelFormatInfo(GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, 0xFFFFFFFF, 0xFFFFFFFF, 2, true, true)),
PixelFormatInfoMapValue(backend::PixelFormat::PVRTC4, Texture2D::PixelFormatInfo(GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG, 0xFFFFFFFF, 0xFFFFFFFF, 4, true, false)),
PixelFormatInfoMapValue(backend::PixelFormat::PVRTC4A, Texture2D::PixelFormatInfo(GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, 0xFFFFFFFF, 0xFFFFFFFF, 4, true, true)),
#endif
#else
//Metal && iOS
#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
PixelFormatInfoMapValue(Texture2D::PixelFormat::PVRTC2, Texture2D::PixelFormatInfo(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 2, true, false)),
PixelFormatInfoMapValue(Texture2D::PixelFormat::PVRTC2A, Texture2D::PixelFormatInfo(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 2, true, true)),
PixelFormatInfoMapValue(Texture2D::PixelFormat::PVRTC4, Texture2D::PixelFormatInfo(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 4, true, false)),
PixelFormatInfoMapValue(Texture2D::PixelFormat::PVRTC4A, Texture2D::PixelFormatInfo(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 4, true, true)),
PixelFormatInfoMapValue(backend::PixelFormat::PVRTC2, Texture2D::PixelFormatInfo(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 2, true, false)),
PixelFormatInfoMapValue(backend::PixelFormat::PVRTC2A, Texture2D::PixelFormatInfo(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 2, true, true)),
PixelFormatInfoMapValue(backend::PixelFormat::PVRTC4, Texture2D::PixelFormatInfo(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 4, true, false)),
PixelFormatInfoMapValue(backend::PixelFormat::PVRTC4A, Texture2D::PixelFormatInfo(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 4, true, true)),
#endif
#endif
#ifdef GL_ETC1_RGB8_OES
PixelFormatInfoMapValue(Texture2D::PixelFormat::ETC, Texture2D::PixelFormatInfo(GL_ETC1_RGB8_OES, 0xFFFFFFFF, 0xFFFFFFFF, 4, true, false)),
PixelFormatInfoMapValue(backend::PixelFormat::ETC, Texture2D::PixelFormatInfo(GL_ETC1_RGB8_OES, 0xFFFFFFFF, 0xFFFFFFFF, 4, true, false)),
#endif
#ifdef GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
PixelFormatInfoMapValue(Texture2D::PixelFormat::S3TC_DXT1, Texture2D::PixelFormatInfo(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 0xFFFFFFFF, 0xFFFFFFFF, 4, true, false)),
PixelFormatInfoMapValue(backend::PixelFormat::S3TC_DXT1, Texture2D::PixelFormatInfo(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 0xFFFFFFFF, 0xFFFFFFFF, 4, true, false)),
#endif
#ifdef GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
PixelFormatInfoMapValue(Texture2D::PixelFormat::S3TC_DXT3, Texture2D::PixelFormatInfo(GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 0xFFFFFFFF, 0xFFFFFFFF, 8, true, false)),
PixelFormatInfoMapValue(backend::PixelFormat::S3TC_DXT3, Texture2D::PixelFormatInfo(GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 0xFFFFFFFF, 0xFFFFFFFF, 8, true, false)),
#endif
#ifdef GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
PixelFormatInfoMapValue(Texture2D::PixelFormat::S3TC_DXT5, Texture2D::PixelFormatInfo(GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 0xFFFFFFFF, 0xFFFFFFFF, 8, true, false)),
PixelFormatInfoMapValue(backend::PixelFormat::S3TC_DXT5, Texture2D::PixelFormatInfo(GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 0xFFFFFFFF, 0xFFFFFFFF, 8, true, false)),
#endif
#ifdef GL_ATC_RGB_AMD
PixelFormatInfoMapValue(Texture2D::PixelFormat::ATC_RGB, Texture2D::PixelFormatInfo(GL_ATC_RGB_AMD,
PixelFormatInfoMapValue(backend::PixelFormat::ATC_RGB, Texture2D::PixelFormatInfo(GL_ATC_RGB_AMD,
0xFFFFFFFF, 0xFFFFFFFF, 4, true, false)),
#endif
#ifdef GL_ATC_RGBA_EXPLICIT_ALPHA_AMD
PixelFormatInfoMapValue(Texture2D::PixelFormat::ATC_EXPLICIT_ALPHA, Texture2D::PixelFormatInfo(GL_ATC_RGBA_EXPLICIT_ALPHA_AMD,
PixelFormatInfoMapValue(backend::PixelFormat::ATC_EXPLICIT_ALPHA, Texture2D::PixelFormatInfo(GL_ATC_RGBA_EXPLICIT_ALPHA_AMD,
0xFFFFFFFF, 0xFFFFFFFF, 8, true, false)),
#endif
#ifdef GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD
PixelFormatInfoMapValue(Texture2D::PixelFormat::ATC_INTERPOLATED_ALPHA, Texture2D::PixelFormatInfo(GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD,
PixelFormatInfoMapValue(backend::PixelFormat::ATC_INTERPOLATED_ALPHA, Texture2D::PixelFormatInfo(GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD,
0xFFFFFFFF, 0xFFFFFFFF, 8, true, false)),
#endif
//metal formats
#ifdef CC_USE_METAL
#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
PixelFormatInfoMapValue(Texture2D::PixelFormat::MTL_ABGR4, Texture2D::PixelFormatInfo(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 16, false, true)),
PixelFormatInfoMapValue(Texture2D::PixelFormat::MTL_B5G6R5, Texture2D::PixelFormatInfo(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 16, false, false)),
PixelFormatInfoMapValue(Texture2D::PixelFormat::MTL_BGR5A1, Texture2D::PixelFormatInfo(0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF, 16, false, true)),
PixelFormatInfoMapValue(backend::PixelFormat::MTL_ABGR4, Texture2D::PixelFormatInfo(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 16, false, true)),
PixelFormatInfoMapValue(backend::PixelFormat::MTL_B5G6R5, Texture2D::PixelFormatInfo(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 16, false, false)),
PixelFormatInfoMapValue(backend::PixelFormat::MTL_BGR5A1, Texture2D::PixelFormatInfo(0xFFFFFFFF,0xFFFFFFFF, 0xFFFFFFFF, 16, false, true)),
#endif
#endif
};
backend::SamplerFilter GLToBackendMagFilter(GLint magFilter)
{
switch (magFilter)
{
case GL_LINEAR:
return backend::SamplerFilter::LINEAR;
case GL_NEAREST:
return backend::SamplerFilter::NEAREST;
default:
return backend::SamplerFilter::LINEAR;
}
}
GLint toGLAddressMode(backend::SamplerAddressMode addressMode, bool isPow2)
{
GLint ret = GL_REPEAT;
if (!isPow2 && (addressMode != backend::SamplerAddressMode::CLAMP_TO_EDGE))
{
cocos2d::log("Change texture wrap mode to CLAMP_TO_EDGE since non-power-of-two texture occur in %s %s %d", __FILE__, __FUNCTION__, __LINE__);
return GL_CLAMP_TO_EDGE;
}
switch (addressMode)
{
case backend::SamplerAddressMode::REPEAT:
ret = GL_REPEAT;
break;
case backend::SamplerAddressMode::MIRROR_REPEAT:
ret = GL_MIRRORED_REPEAT;
break;
case backend::SamplerAddressMode::CLAMP_TO_EDGE:
ret = GL_CLAMP_TO_EDGE;
break;
default:
break;
}
return ret;
}
backend::SamplerAddressMode GLToBackendAddressMode(int addressMode)
{
switch (addressMode)
{
case GL_REPEAT:
return backend::SamplerAddressMode::REPEAT;
case GL_MIRRORED_REPEAT:
return backend::SamplerAddressMode::MIRROR_REPEAT;
case GL_CLAMP_TO_EDGE:
return backend::SamplerAddressMode::CLAMP_TO_EDGE;
default:
return backend::SamplerAddressMode::REPEAT;
}
}
}
//CLASS IMPLEMENTATIONS:
@ -193,11 +137,11 @@ const Texture2D::PixelFormatInfoMap Texture2D::_pixelFormatInfoTables(TexturePix
// If the image has alpha, you can create RGBA8 (32-bit) or RGBA4 (16-bit) or RGB5A1 (16-bit)
// Default is: RGBA8888 (32-bit textures)
static Texture2D::PixelFormat g_defaultAlphaPixelFormat = Texture2D::PixelFormat::DEFAULT;
static backend::PixelFormat g_defaultAlphaPixelFormat = backend::PixelFormat::DEFAULT;
Texture2D::Texture2D()
: _pixelFormat(Texture2D::PixelFormat::DEFAULT)
: _pixelFormat(backend::PixelFormat::DEFAULT)
, _pixelsWide(0)
, _pixelsHigh(0)
, _maxS(0.0)
@ -210,7 +154,7 @@ Texture2D::Texture2D()
, _alphaTexture(nullptr)
{
backend::TextureDescriptor textureDescriptor;
textureDescriptor.textureFormat = TextureFormat::NONE;
textureDescriptor.textureFormat = PixelFormat::NONE;
_texture = static_cast<backend::Texture2D*>(backend::Device::getInstance()->newTexture(textureDescriptor));
}
@ -229,7 +173,7 @@ Texture2D::~Texture2D()
CC_SAFE_RELEASE(_programState);
}
Texture2D::PixelFormat Texture2D::getPixelFormat() const
backend::PixelFormat Texture2D::getPixelFormat() const
{
return _pixelFormat;
}
@ -293,7 +237,7 @@ bool Texture2D::hasPremultipliedAlpha() const
return _hasPremultipliedAlpha;
}
bool Texture2D::initWithData(const void *data, ssize_t dataLen, Texture2D::PixelFormat pixelFormat, Texture2D::PixelFormat renderFormat, int pixelsWide, int pixelsHigh, const Size& /*contentSize*/)
bool Texture2D::initWithData(const void *data, ssize_t dataLen, backend::PixelFormat pixelFormat, backend::PixelFormat renderFormat, int pixelsWide, int pixelsHigh, const Size& /*contentSize*/)
{
CCASSERT(dataLen>0 && pixelsWide>0 && pixelsHigh>0, "Invalid size");
@ -304,7 +248,7 @@ bool Texture2D::initWithData(const void *data, ssize_t dataLen, Texture2D::Pixel
return initWithMipmaps(&mipmap, 1, pixelFormat, renderFormat, pixelsWide, pixelsHigh);
}
bool Texture2D::initWithMipmaps(MipmapInfo* mipmaps, int mipmapsNum, PixelFormat pixelFormat, PixelFormat renderFormat, int pixelsWide, int pixelsHigh)
bool Texture2D::initWithMipmaps(MipmapInfo* mipmaps, int mipmapsNum, backend::PixelFormat pixelFormat, backend::PixelFormat renderFormat, int pixelsWide, int pixelsHigh)
{
//the pixelFormat must be a certain value
CCASSERT(pixelFormat != PixelFormat::NONE && pixelFormat != PixelFormat::AUTO, "the \"pixelFormat\" param must be a certain value!");
@ -345,45 +289,64 @@ bool Texture2D::initWithMipmaps(MipmapInfo* mipmaps, int mipmapsNum, PixelFormat
backend::TextureDescriptor textureDescriptor;
textureDescriptor.width = pixelsWide;
textureDescriptor.height = pixelsHigh;
textureDescriptor.samplerDescriptor.minFilter = (_antialiasEnabled) ? backend::SamplerFilter::LINEAR : backend::SamplerFilter::NEAREST;
textureDescriptor.samplerDescriptor.magFilter = (_antialiasEnabled) ? backend::SamplerFilter::LINEAR : backend::SamplerFilter::NEAREST;
if (mipmapsNum > 1)
if (mipmapsNum == 1)
{
textureDescriptor.samplerDescriptor.mipmapFilter = backend::SamplerFilter::NEAREST;
textureDescriptor.samplerDescriptor.minFilter = (_antialiasEnabled) ? backend::SamplerFilter::LINEAR : backend::SamplerFilter::NEAREST;
}
else
{
textureDescriptor.samplerDescriptor.minFilter = (_antialiasEnabled) ? backend::SamplerFilter::LINEAR_MIPMAP_NEAREST : backend::SamplerFilter::NEAREST_MIPMAP_NEAREST;
}
unsigned char *data = mipmaps[0].address;
size_t dataLen = mipmaps[0].len;
unsigned char *outData = data;
size_t outDataLen;
if(renderFormat != pixelFormat) //need conversion
int width = pixelsWide;
int height = pixelsHigh;
backend::PixelFormat oriPixelFormat = pixelFormat;
for (int i = 0; i < mipmapsNum; ++i)
{
auto convertedFormat = backend::PixelFormatUtils::convertDataToFormat(data, dataLen, pixelFormat, renderFormat, &outData, &outDataLen);
unsigned char *data = mipmaps[i].address;
size_t dataLen = mipmaps[i].len;
unsigned char *outData = data;
size_t outDataLen = dataLen;
if(renderFormat != oriPixelFormat && !info.compressed) //need conversion
{
auto convertedFormat = backend::PixelFormatUtils::convertDataToFormat(data, dataLen, oriPixelFormat, renderFormat, &outData, &outDataLen);
#ifdef CC_USE_METAL
CCASSERT(convertedFormat == renderFormat, "PixelFormat convert failed!");
CCASSERT(convertedFormat == renderFormat, "PixelFormat convert failed!");
#endif
if(convertedFormat == renderFormat) pixelFormat = renderFormat;
}
if(convertedFormat == renderFormat) pixelFormat = renderFormat;
}
textureDescriptor.textureFormat = pixelFormat;
CCASSERT(textureDescriptor.textureFormat != backend::PixelFormat::NONE, "PixelFormat should not be NONE");
backend::StringUtils::PixelFormat format = static_cast<backend::StringUtils::PixelFormat>(pixelFormat);
CCASSERT(format != backend::StringUtils::PixelFormat::NONE, "PixelFormat should not be NONE");
textureDescriptor.textureFormat = backend::StringUtils::PixelFormat2TextureFormat(format);
CCASSERT(textureDescriptor.textureFormat != backend::TextureFormat::NONE, "TextureFormat should not be NONE");
textureDescriptor.compressed = info.compressed;
if(_texture->getTextureFormat() != textureDescriptor.textureFormat)
_texture->updateTextureDescriptor(textureDescriptor);
if(_texture->getTextureFormat() != textureDescriptor.textureFormat)
_texture->updateTextureDescriptor(textureDescriptor);
if(info.compressed)
{
_texture->updateCompressedData(data, width, height, dataLen, i);
}
else
{
_texture->updateData(outData, width, height, i);
}
_texture->updateData(outData);
if(outData && outData != data && outDataLen > 0)
{
free(outData);
outData = nullptr;
outDataLen = 0;
if(outData && outData != data && outDataLen > 0)
{
free(outData);
outData = nullptr;
outDataLen = 0;
}
if (i > 0 && (width != height || ccNextPOT(width) != width ))
{
CCLOG("cocos2d: Texture2D. WARNING. Mipmap level %u is not squared. Texture won't render correctly. width=%d != height=%d", i, width, height);
}
width = MAX(width >> 1, 1);
height = MAX(height >> 1, 1);
}
_contentSize = Size((float)pixelsWide, (float)pixelsHigh);
@ -404,7 +367,7 @@ bool Texture2D::updateWithData(void *data,int offsetX,int offsetY,int width,int
if (_texture && width > 0 && height > 0)
{
uint8_t* textureData = static_cast<uint8_t*>(data);
_texture->updateSubData(offsetX, offsetY, width, height, textureData);
_texture->updateSubData(offsetX, offsetY, width, height, 0, textureData);
return true;
}
return false;
@ -416,7 +379,7 @@ bool Texture2D::initWithImage(Image *image)
return initWithImage(image, g_defaultAlphaPixelFormat);
}
bool Texture2D::initWithImage(Image *image, PixelFormat format)
bool Texture2D::initWithImage(Image *image, backend::PixelFormat format)
{
if (image == nullptr)
{
@ -438,8 +401,8 @@ bool Texture2D::initWithImage(Image *image, PixelFormat format)
unsigned char* tempData = image->getData();
Size imageSize = Size((float)imageWidth, (float)imageHeight);
PixelFormat renderFormat = ((PixelFormat::NONE == format) || (PixelFormat::AUTO == format)) ? image->getPixelFormat() : format;
PixelFormat imagePixelFormat = image->getPixelFormat();
backend::PixelFormat renderFormat = ((PixelFormat::NONE == format) || (PixelFormat::AUTO == format)) ? image->getPixelFormat() : format;
backend::PixelFormat imagePixelFormat = image->getPixelFormat();
size_t tempDataLen = image->getDataLen();
@ -635,18 +598,24 @@ bool Texture2D::initWithBackendTexture(backend::Texture *texture)
bool Texture2D::hasMipmaps() const
{
return _hasMipmaps;
return _texture->hasMipmaps();
}
void Texture2D::setAliasTexParameters()
{
backend::SamplerDescriptor descriptor(false,
backend::SamplerFilter::NEAREST,
backend::SamplerFilter::NEAREST,
backend::SamplerFilter::NEAREST,
backend::SamplerAddressMode::DONT_CARE,
backend::SamplerAddressMode::DONT_CARE
if (! _antialiasEnabled)
{
return;
}
_antialiasEnabled = false;
backend::SamplerDescriptor descriptor(
backend::SamplerFilter::NEAREST, //magFilter
(_texture->hasMipmaps()) ? backend::SamplerFilter::NEAREST_MIPMAP_NEAREST : backend::SamplerFilter::NEAREST, //minFilter
backend::SamplerAddressMode::DONT_CARE, //sAddressMode
backend::SamplerAddressMode::DONT_CARE//tAddressMode
);
_texture->updateSamplerDescriptor(descriptor);
}
@ -654,12 +623,17 @@ void Texture2D::setAliasTexParameters()
void Texture2D::setAntiAliasTexParameters()
{
backend::SamplerDescriptor descriptor(false,
backend::SamplerFilter::LINEAR,
backend::SamplerFilter::LINEAR,
backend::SamplerFilter::LINEAR,
backend::SamplerAddressMode::DONT_CARE,
backend::SamplerAddressMode::DONT_CARE
if ( _antialiasEnabled )
{
return;
}
_antialiasEnabled = true;
backend::SamplerDescriptor descriptor(
backend::SamplerFilter::LINEAR, //magFilter
(_texture->hasMipmaps()) ? backend::SamplerFilter::LINEAR_MIPMAP_NEAREST : backend::SamplerFilter::LINEAR, //minFilter
backend::SamplerAddressMode::DONT_CARE, //sAddressMode
backend::SamplerAddressMode::DONT_CARE //tAddressMode
);
_texture->updateSamplerDescriptor(descriptor);
}
@ -668,70 +642,70 @@ const char* Texture2D::getStringForFormat() const
{
switch (_pixelFormat)
{
case Texture2D::PixelFormat::RGBA8888:
case backend::PixelFormat::RGBA8888:
return "RGBA8888";
case Texture2D::PixelFormat::RGB888:
case backend::PixelFormat::RGB888:
return "RGB888";
case Texture2D::PixelFormat::RGB565:
case backend::PixelFormat::RGB565:
return "RGB565";
case Texture2D::PixelFormat::RGBA4444:
case backend::PixelFormat::RGBA4444:
return "RGBA4444";
case Texture2D::PixelFormat::RGB5A1:
case backend::PixelFormat::RGB5A1:
return "RGB5A1";
case Texture2D::PixelFormat::AI88:
case backend::PixelFormat::AI88:
return "AI88";
case Texture2D::PixelFormat::A8:
case backend::PixelFormat::A8:
return "A8";
case Texture2D::PixelFormat::I8:
case backend::PixelFormat::I8:
return "I8";
case Texture2D::PixelFormat::PVRTC4:
case backend::PixelFormat::PVRTC4:
return "PVRTC4";
case Texture2D::PixelFormat::PVRTC2:
case backend::PixelFormat::PVRTC2:
return "PVRTC2";
case Texture2D::PixelFormat::PVRTC2A:
case backend::PixelFormat::PVRTC2A:
return "PVRTC2A";
case Texture2D::PixelFormat::PVRTC4A:
case backend::PixelFormat::PVRTC4A:
return "PVRTC4A";
case Texture2D::PixelFormat::ETC:
case backend::PixelFormat::ETC:
return "ETC";
case Texture2D::PixelFormat::S3TC_DXT1:
case backend::PixelFormat::S3TC_DXT1:
return "S3TC_DXT1";
case Texture2D::PixelFormat::S3TC_DXT3:
case backend::PixelFormat::S3TC_DXT3:
return "S3TC_DXT3";
case Texture2D::PixelFormat::S3TC_DXT5:
case backend::PixelFormat::S3TC_DXT5:
return "S3TC_DXT5";
case Texture2D::PixelFormat::ATC_RGB:
case backend::PixelFormat::ATC_RGB:
return "ATC_RGB";
case Texture2D::PixelFormat::ATC_EXPLICIT_ALPHA:
case backend::PixelFormat::ATC_EXPLICIT_ALPHA:
return "ATC_EXPLICIT_ALPHA";
case Texture2D::PixelFormat::ATC_INTERPOLATED_ALPHA:
case backend::PixelFormat::ATC_INTERPOLATED_ALPHA:
return "ATC_INTERPOLATED_ALPHA";
case Texture2D::PixelFormat::MTL_ABGR4:
case backend::PixelFormat::MTL_ABGR4:
return "MTL_ABGR4";
case Texture2D::PixelFormat::MTL_B5G6R5:
case backend::PixelFormat::MTL_B5G6R5:
return "MTL_RGB565";
case Texture2D::PixelFormat::MTL_BGR5A1:
case backend::PixelFormat::MTL_BGR5A1:
return "MTL_BGR5A1";
default:
@ -748,17 +722,17 @@ const char* Texture2D::getStringForFormat() const
//
// implementation Texture2D (PixelFormat)
void Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat format)
void Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat format)
{
g_defaultAlphaPixelFormat = format;
}
Texture2D::PixelFormat Texture2D::getDefaultAlphaPixelFormat()
backend::PixelFormat Texture2D::getDefaultAlphaPixelFormat()
{
return g_defaultAlphaPixelFormat;
}
unsigned int Texture2D::getBitsPerPixelForFormat(Texture2D::PixelFormat format) const
unsigned int Texture2D::getBitsPerPixelForFormat(backend::PixelFormat format) const
{
if (format == PixelFormat::NONE || format == PixelFormat::DEFAULT)
{
@ -860,7 +834,6 @@ void Texture2D::generateMipmap()
CCASSERT(_pixelsWide == ccNextPOT(_pixelsWide) && _pixelsHigh == ccNextPOT(_pixelsHigh), "Mipmap texture only works in POT textures");
_texture->generateMipmaps();
_hasMipmaps = true;
}
void Texture2D::initProgram()

92
cocos/renderer/CCTexture2D.h
View File

@ -72,66 +72,6 @@ namespace backend {
class CC_DLL Texture2D : public Ref
{
public:
/** @typedef Texture2D::PixelFormat
Possible texture pixel formats
*/
enum class PixelFormat
{
//! auto detect the type
AUTO,
//! 32-bit texture: BGRA8888
BGRA8888,
//! 32-bit texture: RGBA8888
RGBA8888,
//! 24-bit texture: RGBA888
RGB888,
//! 16-bit texture without Alpha channel
RGB565,
//! 8-bit textures used as masks
A8,
//! 8-bit intensity texture
I8,
//! 16-bit textures used as masks
AI88,
//! 16-bit textures: RGBA4444
RGBA4444,
//! 16-bit textures: RGB5A1
RGB5A1,
//! 4-bit PVRTC-compressed texture: PVRTC4
PVRTC4,
//! 4-bit PVRTC-compressed texture: PVRTC4 (has alpha channel)
PVRTC4A,
//! 2-bit PVRTC-compressed texture: PVRTC2
PVRTC2,
//! 2-bit PVRTC-compressed texture: PVRTC2 (has alpha channel)
PVRTC2A,
//! ETC-compressed texture: ETC
ETC,
//! S3TC-compressed texture: S3TC_Dxt1
S3TC_DXT1,
//! S3TC-compressed texture: S3TC_Dxt3
S3TC_DXT3,
//! S3TC-compressed texture: S3TC_Dxt5
S3TC_DXT5,
//! ATITC-compressed texture: ATC_RGB
ATC_RGB,
//! ATITC-compressed texture: ATC_EXPLICIT_ALPHA
ATC_EXPLICIT_ALPHA,
//! ATITC-compressed texture: ATC_INTERPOLATED_ALPHA
ATC_INTERPOLATED_ALPHA,
//! Default texture format: AUTO
MTL_B5G6R5,
//MTL_A1BGR5,
MTL_BGR5A1,
MTL_ABGR4,
DEFAULT = AUTO,
NONE = -1
};
struct PixelFormatInfo {
PixelFormatInfo(GLenum anInternalFormat, GLenum aFormat, GLenum aType, int aBpp, bool aCompressed, bool anAlpha)
@ -151,7 +91,7 @@ public:
bool alpha;
};
typedef std::map<Texture2D::PixelFormat, const PixelFormatInfo> PixelFormatInfoMap;
typedef std::map<backend::PixelFormat, const PixelFormatInfo> PixelFormatInfoMap;
/**
* Extension to set the Min / Mag filter
@ -163,12 +103,12 @@ public:
@param format
If the UIImage contains alpha channel, then the options are:
- generate 32-bit textures: Texture2D::PixelFormat::RGBA8888 (default one)
- generate 24-bit textures: Texture2D::PixelFormat::RGB888
- generate 16-bit textures: Texture2D::PixelFormat::RGBA4444
- generate 16-bit textures: Texture2D::PixelFormat::RGB5A1
- generate 16-bit textures: Texture2D::PixelFormat::RGB565
- generate 8-bit textures: Texture2D::PixelFormat::A8 (only use it if you use just 1 color)
- generate 32-bit textures: backend::PixelFormat::RGBA8888 (default one)
- generate 24-bit textures: backend::PixelFormat::RGB888
- generate 16-bit textures: backend::PixelFormat::RGBA4444
- generate 16-bit textures: backend::PixelFormat::RGB5A1
- generate 16-bit textures: backend::PixelFormat::RGB565
- generate 8-bit textures: backend::PixelFormat::A8 (only use it if you use just 1 color)
How does it work ?
- If the image is an RGBA (with Alpha) then the default pixel format will be used (it can be a 8-bit, 16-bit or 32-bit texture)
@ -178,12 +118,12 @@ public:
@since v0.8
*/
static void setDefaultAlphaPixelFormat(Texture2D::PixelFormat format);
static void setDefaultAlphaPixelFormat(backend::PixelFormat format);
/** Returns the alpha pixel format.
@since v0.8
*/
static Texture2D::PixelFormat getDefaultAlphaPixelFormat();
static backend::PixelFormat getDefaultAlphaPixelFormat();
public:
/**
@ -207,7 +147,7 @@ public:
* @js NA
* @lua NA
*/
bool initWithData(const void *data, ssize_t dataLen, Texture2D::PixelFormat pixelFormat, int pixelsWide, int pixelsHigh, const Size& contentSize) { return initWithData(data, dataLen, pixelFormat, pixelFormat, pixelsWide, pixelsHigh, contentSize);}
bool initWithData(const void *data, ssize_t dataLen, backend::PixelFormat pixelFormat, int pixelsWide, int pixelsHigh, const Size& contentSize) { return initWithData(data, dataLen, pixelFormat, pixelFormat, pixelsWide, pixelsHigh, contentSize);}
/** Initializes with a texture2d with data.
@ -221,7 +161,7 @@ public:
* @js NA
* @lua NA
*/
bool initWithData(const void *data, ssize_t dataLen, Texture2D::PixelFormat pixelFormat, Texture2D::PixelFormat renderFormat, int pixelsWide, int pixelsHigh, const Size& contentSize);
bool initWithData(const void *data, ssize_t dataLen, backend::PixelFormat pixelFormat, backend::PixelFormat renderFormat, int pixelsWide, int pixelsHigh, const Size& contentSize);
/** Initializes with mipmaps.
@ -231,7 +171,7 @@ public:
@param pixelsWide The image width.
@param pixelsHigh The image height.
*/
bool initWithMipmaps(MipmapInfo* mipmaps, int mipmapsNum, Texture2D::PixelFormat pixelFormat, Texture2D::PixelFormat renderFormat, int pixelsWide, int pixelsHigh);
bool initWithMipmaps(MipmapInfo* mipmaps, int mipmapsNum, backend::PixelFormat pixelFormat, backend::PixelFormat renderFormat, int pixelsWide, int pixelsHigh);
/** Update with texture data.
@ -271,7 +211,7 @@ public:
@param image An UIImage object.
@param format Texture pixel formats.
**/
bool initWithImage(Image * image, PixelFormat format);
bool initWithImage(Image * image, backend::PixelFormat format);
/** Initializes a texture from a string with dimensions, alignment, font name and font size.
@ -339,7 +279,7 @@ public:
/** Helper functions that returns bits per pixels for a given format.
@since v2.0
*/
unsigned int getBitsPerPixelForFormat(Texture2D::PixelFormat format) const;
unsigned int getBitsPerPixelForFormat(backend::PixelFormat format) const;
/** Get content size. */
const Size& getContentSizeInPixels();
@ -351,7 +291,7 @@ public:
bool hasMipmaps() const;
/** Gets the pixel format of the texture. */
Texture2D::PixelFormat getPixelFormat() const;
backend::PixelFormat getPixelFormat() const;
/** Gets the width of the texture in pixels. */
int getPixelsWide() const;
@ -433,7 +373,7 @@ private:
protected:
/** pixel format of the texture */
Texture2D::PixelFormat _pixelFormat;
backend::PixelFormat _pixelFormat;
/** width in pixels */
int _pixelsWide;

8
cocos/renderer/CCTextureCache.cpp
View File

@ -101,7 +101,7 @@ public:
std::string callbackKey;
Image image;
Image imageAlpha;
Texture2D::PixelFormat pixelFormat;
backend::PixelFormat pixelFormat;
bool loadSuccess;
};
@ -718,7 +718,7 @@ VolatileTexture::VolatileTexture(Texture2D *t)
, _uiImage(nullptr)
, _cashedImageType(kInvalid)
, _textureData(nullptr)
, _pixelFormat(Texture2D::PixelFormat::RGBA8888)
, _pixelFormat(backend::PixelFormat::RGBA8888)
, _fileName("")
, _text("")
{
@ -777,7 +777,7 @@ VolatileTexture* VolatileTextureMgr::findVolotileTexture(Texture2D *tt)
return vt;
}
void VolatileTextureMgr::addDataTexture(Texture2D *tt, void* data, int dataLen, Texture2D::PixelFormat pixelFormat, const Size& contentSize)
void VolatileTextureMgr::addDataTexture(Texture2D *tt, void* data, int dataLen, backend::PixelFormat pixelFormat, const Size& contentSize)
{
if (_isReloading)
{
@ -869,7 +869,7 @@ void VolatileTextureMgr::reloadAllTextures()
_isReloading = false;
}
void VolatileTextureMgr::reloadTexture(Texture2D* texture, const std::string& filename, Texture2D::PixelFormat pixelFormat)
void VolatileTextureMgr::reloadTexture(Texture2D* texture, const std::string& filename, backend::PixelFormat pixelFormat)
{
if (!texture)
return;

6
cocos/renderer/CCTextureCache.h
View File

@ -257,7 +257,7 @@ protected:
void *_textureData;
int _dataLen;
Size _textureSize;
Texture2D::PixelFormat _pixelFormat;
backend::PixelFormat _pixelFormat;
std::string _fileName;
@ -270,7 +270,7 @@ class CC_DLL VolatileTextureMgr
public:
static void addImageTexture(Texture2D *tt, const std::string& imageFileName);
static void addStringTexture(Texture2D *tt, const char* text, const FontDefinition& fontDefinition);
static void addDataTexture(Texture2D *tt, void* data, int dataLen, Texture2D::PixelFormat pixelFormat, const Size& contentSize);
static void addDataTexture(Texture2D *tt, void* data, int dataLen, backend::PixelFormat pixelFormat, const Size& contentSize);
static void addImage(Texture2D *tt, Image *image);
static void removeTexture(Texture2D *t);
static void reloadAllTextures();
@ -284,7 +284,7 @@ public:
static VolatileTexture* findVolotileTexture(Texture2D *tt);
private:
static void reloadTexture(Texture2D* texture, const std::string& filename, Texture2D::PixelFormat pixelFormat);
static void reloadTexture(Texture2D* texture, const std::string& filename, backend::PixelFormat pixelFormat);
};
#endif

18
cocos/renderer/CCTextureCube.cpp
View File

@ -63,7 +63,7 @@ namespace {
}
}
unsigned char* getImageData(Image* img, Texture2D::PixelFormat& ePixFmt)
unsigned char* getImageData(Image* img, backend::PixelFormat& ePixFmt)
{
unsigned char* pTmpData = img->getData();
unsigned int* inPixel32 = nullptr;
@ -78,24 +78,24 @@ unsigned char* getImageData(Image* img, Texture2D::PixelFormat& ePixFmt)
// compute pixel format
if (bHasAlpha)
{
ePixFmt = Texture2D::PixelFormat::DEFAULT;
ePixFmt = backend::PixelFormat::DEFAULT;
}
else
{
if (uBPP >= 8)
{
ePixFmt = Texture2D::PixelFormat::RGB888;
ePixFmt = backend::PixelFormat::RGB888;
}
else
{
ePixFmt = Texture2D::PixelFormat::RGB565;
ePixFmt = backend::PixelFormat::RGB565;
}
}
// Repack the pixel data into the right format
unsigned int uLen = nWidth * nHeight;
if (ePixFmt == Texture2D::PixelFormat::RGB565)
if (ePixFmt == backend::PixelFormat::RGB565)
{
if (bHasAlpha)
{
@ -133,7 +133,7 @@ unsigned char* getImageData(Image* img, Texture2D::PixelFormat& ePixFmt)
}
}
if (bHasAlpha && ePixFmt == Texture2D::PixelFormat::RGB888)
if (bHasAlpha && ePixFmt == backend::PixelFormat::RGB888)
{
// Convert "RRRRRRRRRGGGGGGGGBBBBBBBBAAAAAAAA" to "RRRRRRRRGGGGGGGGBBBBBBBB"
inPixel32 = (unsigned int*)img->getData();
@ -253,16 +253,16 @@ bool TextureCube::init(const std::string& positive_x, const std::string& negativ
{
Image* img = images[i];
Texture2D::PixelFormat ePixelFmt;
backend::PixelFormat ePixelFmt;
unsigned char* pData = getImageData(img, ePixelFmt);
uint8_t *cData = nullptr;
uint8_t *useData = pData;
//convert pixel format to RGBA
if (ePixelFmt != Texture2D::PixelFormat::RGBA8888)
if (ePixelFmt != backend::PixelFormat::RGBA8888)
{
size_t len = 0;
backend::PixelFormatUtils::convertDataToFormat(pData, img->getDataLen(), ePixelFmt, Texture2D::PixelFormat::RGBA8888, &cData, &len);
backend::PixelFormatUtils::convertDataToFormat(pData, img->getDataLen(), ePixelFmt, backend::PixelFormat::RGBA8888, &cData, &len);
if (cData != pData) //convert error
{
useData = cData;

18
cocos/renderer/CCTextureUtils.cpp
View File

@ -566,7 +566,7 @@ namespace backend { namespace PixelFormatUtils {
cocos2d::Texture2D::PixelFormat convertI8ToFormat(const unsigned char* data, size_t dataLen, PixelFormat format, unsigned char** outData, size_t* outDataLen)
cocos2d::backend::PixelFormat convertI8ToFormat(const unsigned char* data, size_t dataLen, PixelFormat format, unsigned char** outData, size_t* outDataLen)
{
switch (format)
{
@ -634,7 +634,7 @@ namespace backend { namespace PixelFormatUtils {
return format;
}
cocos2d::Texture2D::PixelFormat convertAI88ToFormat(const unsigned char* data, size_t dataLen, PixelFormat format, unsigned char** outData, size_t* outDataLen)
cocos2d::backend::PixelFormat convertAI88ToFormat(const unsigned char* data, size_t dataLen, PixelFormat format, unsigned char** outData, size_t* outDataLen)
{
switch (format)
{
@ -704,7 +704,7 @@ namespace backend { namespace PixelFormatUtils {
return format;
}
cocos2d::Texture2D::PixelFormat convertRGB888ToFormat(const unsigned char* data, size_t dataLen, PixelFormat format, unsigned char** outData, size_t* outDataLen)
cocos2d::backend::PixelFormat convertRGB888ToFormat(const unsigned char* data, size_t dataLen, PixelFormat format, unsigned char** outData, size_t* outDataLen)
{
switch (format)
{
@ -772,7 +772,7 @@ namespace backend { namespace PixelFormatUtils {
return format;
}
cocos2d::Texture2D::PixelFormat convertRGBA8888ToFormat(const unsigned char* data, size_t dataLen, PixelFormat format, unsigned char** outData, size_t* outDataLen)
cocos2d::backend::PixelFormat convertRGBA8888ToFormat(const unsigned char* data, size_t dataLen, PixelFormat format, unsigned char** outData, size_t* outDataLen)
{
switch (format)
@ -842,7 +842,7 @@ namespace backend { namespace PixelFormatUtils {
return format;
}
cocos2d::Texture2D::PixelFormat convertRGB5A1ToFormat(const unsigned char* data, size_t dataLen, PixelFormat format, unsigned char** outData, size_t* outDataLen)
cocos2d::backend::PixelFormat convertRGB5A1ToFormat(const unsigned char* data, size_t dataLen, PixelFormat format, unsigned char** outData, size_t* outDataLen)
{
switch (format)
{
@ -870,7 +870,7 @@ namespace backend { namespace PixelFormatUtils {
return format;
}
cocos2d::Texture2D::PixelFormat convertRGB565ToFormat(const unsigned char* data, size_t dataLen, PixelFormat format, unsigned char** outData, size_t* outDataLen)
cocos2d::backend::PixelFormat convertRGB565ToFormat(const unsigned char* data, size_t dataLen, PixelFormat format, unsigned char** outData, size_t* outDataLen)
{
switch (format)
{
@ -899,7 +899,7 @@ namespace backend { namespace PixelFormatUtils {
return format;
}
cocos2d::Texture2D::PixelFormat convertA8ToFormat(const unsigned char* data, size_t dataLen, PixelFormat format, unsigned char** outData, size_t* outDataLen)
cocos2d::backend::PixelFormat convertA8ToFormat(const unsigned char* data, size_t dataLen, PixelFormat format, unsigned char** outData, size_t* outDataLen)
{
switch (format)
{
@ -922,7 +922,7 @@ namespace backend { namespace PixelFormatUtils {
return format;
}
cocos2d::Texture2D::PixelFormat convertRGBA4444ToFormat(const unsigned char* data, size_t dataLen, PixelFormat format, unsigned char** outData, size_t* outDataLen)
cocos2d::backend::PixelFormat convertRGBA4444ToFormat(const unsigned char* data, size_t dataLen, PixelFormat format, unsigned char** outData, size_t* outDataLen)
{
switch (format)
{
@ -982,7 +982,7 @@ namespace backend { namespace PixelFormatUtils {
rgba(1) -> 12345678
*/
cocos2d::Texture2D::PixelFormat convertDataToFormat(const unsigned char* data, size_t dataLen, PixelFormat originFormat, PixelFormat format, unsigned char** outData, size_t* outDataLen)
cocos2d::backend::PixelFormat convertDataToFormat(const unsigned char* data, size_t dataLen, PixelFormat originFormat, PixelFormat format, unsigned char** outData, size_t* outDataLen)
{
// don't need to convert
if (format == originFormat || format == PixelFormat::AUTO)

2
cocos/renderer/CCTextureUtils.h
View File

@ -7,7 +7,7 @@ NS_CC_BEGIN
namespace backend {
namespace PixelFormatUtils {
typedef cocos2d::Texture2D::PixelFormat PixelFormat;
typedef cocos2d::backend::PixelFormat PixelFormat;
/**convert functions*/

2
cocos/renderer/CMakeLists.txt
View File

@ -33,7 +33,6 @@ set(COCOS_RENDERER_HEADER
renderer/backend/RenderPipeline.h
renderer/backend/RenderPipelineDescriptor.h
renderer/backend/ShaderModule.h
renderer/backend/StringUtils.h
renderer/backend/Texture.h
renderer/backend/Types.h
renderer/backend/VertexLayout.h
@ -67,7 +66,6 @@ set(COCOS_RENDERER_SRC
renderer/backend/DepthStencilState.cpp
renderer/backend/Device.cpp
renderer/backend/ShaderModule.cpp
renderer/backend/StringUtils.cpp
renderer/backend/Texture.cpp
renderer/backend/Types.cpp
renderer/backend/VertexLayout.cpp

6
cocos/renderer/backend/RenderPipelineDescriptor.h
View File

@ -18,9 +18,9 @@ struct RenderPipelineDescriptor
ProgramState* programState = nullptr;
BlendState* blendState = nullptr;
std::shared_ptr<std::vector<VertexLayout>> vertexLayouts = std::make_shared<std::vector<VertexLayout>>();
TextureFormat colorAttachmentsFormat[MAX_COLOR_ATTCHMENT] = { TextureFormat::SYSTEM_DEFAULT };
TextureFormat depthAttachmentFormat = TextureFormat::NONE;
TextureFormat stencilAttachmentFormat = TextureFormat::NONE;
PixelFormat colorAttachmentsFormat[MAX_COLOR_ATTCHMENT] = { PixelFormat::DEFAULT };
PixelFormat depthAttachmentFormat = PixelFormat::NONE;
PixelFormat stencilAttachmentFormat = PixelFormat::NONE;
};
CC_BACKEND_END

255
cocos/renderer/backend/StringUtils.cpp
View File

@ -1,255 +0,0 @@
//
// StringUtils.cpp
// Test
//
// Created by Cocos on 2018/11/2.
// Copyright © 2018 cocos. All rights reserved.
//
#include "StringUtils.h"
CC_BACKEND_BEGIN
std::string StringUtils::TextureFormat2String(const TextureFormat& textureFormat)
{
switch (textureFormat) {
case TextureFormat::R8G8B8A8:
return "R8G8B8A8";
case TextureFormat::R8G8B8:
return "R8G8B8";
case TextureFormat::A8:
return "A8";
default:
return "";
}
}
std::string StringUtils::TextureType2String(const TextureType& textureType)
{
switch (textureType) {
case TextureType::TEXTURE_2D:
return "TEXTURE_2D";
case TextureType::TEXTURE_CUBE:
return "TEXTURE_CUBE";
default:
return "";
}
}
std::string StringUtils::TextureUsage2String(const TextureUsage& textureUsage)
{
switch (textureUsage) {
case TextureUsage::READ:
return "READ";
case TextureUsage::WRITE:
return "WRITE";
case TextureUsage::RENDER_TARGET:
return "RENDER_TARGET";
default:
return "";
}
}
std::string StringUtils::SamplerFilterType2String(const SamplerFilter& filterType)
{
switch (filterType) {
case SamplerFilter::LINEAR:
return "LINEAR";
case SamplerFilter::NEAREST:
return "NEAREST";
default:
return "";
}
}
std::string StringUtils::SamplerAddressMode2String(const SamplerAddressMode& addressMode)
{
switch (addressMode) {
case SamplerAddressMode::REPEAT:
return "REPEAT";
case SamplerAddressMode::MIRROR_REPEAT:
return "MIRROR_REPEAT";
case SamplerAddressMode::CLAMP_TO_EDGE:
return "CLAMP_TO_EDGE";
default:
return "";
}
}
std::string StringUtils::SamplerDescriptor2String(const SamplerDescriptor& descriptor)
{
std::string samplerInfo = descriptor.mipmapEnabled ? "mipmapEnable":"mipmapDisable";
samplerInfo += SamplerFilterType2String(descriptor.magFilter);
samplerInfo += SamplerFilterType2String(descriptor.minFilter);
samplerInfo += SamplerFilterType2String(descriptor.mipmapFilter);
samplerInfo += SamplerAddressMode2String(descriptor.sAddressMode);
samplerInfo += SamplerAddressMode2String(descriptor.tAddressMode);
return samplerInfo;
}
std::string StringUtils::StencilOperation2String(const StencilOperation& operation)
{
switch (operation) {
case StencilOperation::KEEP:
return "KEEP";
case StencilOperation::ZERO:
return "ZERO";
case StencilOperation::REPLACE:
return "REPLACE";
case StencilOperation::INVERT:
return "INVERT";
case StencilOperation::INCREMENT_WRAP:
return "INCREMENT_WRAP";
case StencilOperation::DECREMENT_WRAP:
return "DECREMENT_WRAP";
default:
return "";
}
}
std::string StringUtils::CompareFunction2String(const CompareFunction& compareFunction)
{
switch (compareFunction) {
case CompareFunction::NEVER:
return "NEVER";
case CompareFunction::LESS:
return "LESS";
case CompareFunction::LESS_EQUAL:
return "LESS_EQUAL";
case CompareFunction::GREATER:
return "GREATER";
case CompareFunction::GREATER_EQUAL:
return "GREATER_EQUAL";
case CompareFunction::EQUAL:
return "EQUAL";
case CompareFunction::NOT_EQUAL:
return "NOT_EQUAL";
case CompareFunction::ALWAYS:
return "ALWAYS";
default:
return "";
}
}
std::string StringUtils::ColorWriteMask2String(const ColorWriteMask& colorWriteMask)
{
switch (colorWriteMask) {
case ColorWriteMask::NONE:
return "NONE";
case ColorWriteMask::RED:
return "RED";
case ColorWriteMask::GREEN:
return "GREEN";
case ColorWriteMask::BLUE:
return "BLUE";
case ColorWriteMask::ALPHA:
return "ALPHA";
case ColorWriteMask::ALL:
return "ALL";
default:
return "";
}
}
std::string StringUtils::BlendOperation2String(const BlendOperation& blendOperation)
{
switch (blendOperation) {
case BlendOperation::ADD:
return "ADD";
case BlendOperation::SUBTRACT:
return "SUBTRACT";
case BlendOperation::RESERVE_SUBTRACT:
return "RESERVE_SUBTRACT";
default:
return "";
}
}
std::string StringUtils::BlendFactor2String(const BlendFactor& blendFactor)
{
switch (blendFactor) {
case BlendFactor::ZERO:
return "ZERO";
case BlendFactor::ONE:
return "ONE";
case BlendFactor::SRC_COLOR:
return "SRC_COLOR";
case BlendFactor::ONE_MINUS_SRC_COLOR:
return "ONE_MINUS_SRC_COLOR";
case BlendFactor::SRC_ALPHA:
return "SRC_ALPHA";
case BlendFactor::ONE_MINUS_SRC_ALPHA:
return "ONE_MINUS_SRC_ALPHA";
case BlendFactor::DST_COLOR:
return "DST_COLOR";
case BlendFactor::ONE_MINUS_DST_COLOR:
return "ONE_MINUS_DST_COLOR";
case BlendFactor::DST_ALPHA:
return "DST_ALPHA";
case BlendFactor::ONE_MINUS_DST_ALPHA:
return "ONE_MINUS_DST_ALPHA";
case BlendFactor::SRC_ALPHA_SATURATE:
return "SRC_ALPHA_SATURATE";
case BlendFactor::BLEND_CLOLOR:
return "BLEND_CLOLOR";
default:
return "";
}
}
TextureFormat StringUtils::PixelFormat2TextureFormat(const PixelFormat& pixleFormat)
{
switch (pixleFormat) {
case PixelFormat::BGRA8888:
return TextureFormat::BGRA8888;
case PixelFormat::RGBA8888:
return TextureFormat::R8G8B8A8;
case PixelFormat::RGB888:
return TextureFormat::R8G8B8;
case PixelFormat::A8:
return TextureFormat::A8;
case PixelFormat::RGBA4444:
return TextureFormat::RGBA4444;
case PixelFormat::I8:
return TextureFormat::I8;
case PixelFormat::AI88:
return TextureFormat::AI88;
case PixelFormat::RGB565:
return TextureFormat::RGB565;
case PixelFormat::RGB5A1:
return TextureFormat::RGB5A1;
case PixelFormat::ETC:
return TextureFormat::ETC1;
case PixelFormat::ATC_RGB:
return TextureFormat::ATC_RGB;
case PixelFormat::ATC_EXPLICIT_ALPHA:
return TextureFormat::ATC_EXPLICIT_ALPHA;
case PixelFormat::ATC_INTERPOLATED_ALPHA:
return TextureFormat::ATC_INTERPOLATED_ALPHA;
case PixelFormat::PVRTC2:
return TextureFormat::PVRTC2;
case PixelFormat::PVRTC2A:
return TextureFormat::PVRTC2A;
case PixelFormat::PVRTC4:
return TextureFormat::PVRTC4;
case PixelFormat::PVRTC4A:
return TextureFormat::PVRTC4A;
case PixelFormat::S3TC_DXT1:
return TextureFormat::S3TC_DXT1;
case PixelFormat::S3TC_DXT3:
return TextureFormat::S3TC_DXT3;
case PixelFormat::S3TC_DXT5:
return TextureFormat::S3TC_DXT5;
case PixelFormat::MTL_ABGR4:
return TextureFormat::MTL_ABGR4;
case PixelFormat::MTL_BGR5A1:
return TextureFormat::MTL_BGR5A1;
case PixelFormat::MTL_B5G6R5:
return TextureFormat::MTL_B5G6R5;
default:
return TextureFormat::NONE;
break;
}
}
CC_BACKEND_END

91
cocos/renderer/backend/StringUtils.h
View File

@ -1,91 +0,0 @@
//
// StringUtils.hpp
// Test
//
// Created by Cocos on 2018/11/2.
// Copyright © 2018 cocos. All rights reserved.
//
#ifndef StringUtils_hpp
#define StringUtils_hpp
#include <string>
#include "Types.h"
CC_BACKEND_BEGIN
class StringUtils
{
public:
enum class PixelFormat
{
//! auto detect the type
AUTO,
//! 32-bit texture: BGRA8888
BGRA8888,
//! 32-bit texture: RGBA8888
RGBA8888,
//! 24-bit texture: RGBA888
RGB888,
//! 16-bit texture without Alpha channel
RGB565,
//! 8-bit textures used as masks
A8,
//! 8-bit intensity texture
I8,
//! 16-bit textures used as masks
AI88,
//! 16-bit textures: RGBA4444
RGBA4444,
//! 16-bit textures: RGB5A1
RGB5A1,
//! 4-bit PVRTC-compressed texture: PVRTC4
PVRTC4,
//! 4-bit PVRTC-compressed texture: PVRTC4 (has alpha channel)
PVRTC4A,
//! 2-bit PVRTC-compressed texture: PVRTC2
PVRTC2,
//! 2-bit PVRTC-compressed texture: PVRTC2 (has alpha channel)
PVRTC2A,
//! ETC-compressed texture: ETC
ETC,
//! S3TC-compressed texture: S3TC_Dxt1
S3TC_DXT1,
//! S3TC-compressed texture: S3TC_Dxt3
S3TC_DXT3,
//! S3TC-compressed texture: S3TC_Dxt5
S3TC_DXT5,
//! ATITC-compressed texture: ATC_RGB
ATC_RGB,
//! ATITC-compressed texture: ATC_EXPLICIT_ALPHA
ATC_EXPLICIT_ALPHA,
//! ATITC-compressed texture: ATC_INTERPOLATED_ALPHA
ATC_INTERPOLATED_ALPHA,
//! Default texture format: AUTO
//metal 16-bits packed pixel formats
MTL_B5G6R5,
//MTL_A1BGR5,
MTL_BGR5A1,
MTL_ABGR4,
DEFAULT = AUTO,
NONE = -1
};
static std::string TextureFormat2String(const TextureFormat& textureFormat);
static std::string TextureType2String(const TextureType& textureType);
static std::string TextureUsage2String(const TextureUsage& textureUsage);
static std::string SamplerFilterType2String(const SamplerFilter& filterType);
static std::string SamplerAddressMode2String(const SamplerAddressMode& addressMode);
static std::string SamplerDescriptor2String(const SamplerDescriptor& descriptor);
static std::string StencilOperation2String(const StencilOperation& operation);
static std::string CompareFunction2String(const CompareFunction& compareFunction);
static std::string ColorWriteMask2String(const ColorWriteMask& colorWriteMask);
static std::string BlendOperation2String(const BlendOperation& blendOperation);
static std::string BlendFactor2String(const BlendFactor& blendFactor);
static TextureFormat PixelFormat2TextureFormat(const PixelFormat& pixleFormat);
};
CC_BACKEND_END
#endif /* StringUtils_hpp */

61
cocos/renderer/backend/Texture.cpp
View File

@ -6,56 +6,56 @@ CC_BACKEND_BEGIN
#define bit(n) (n)
namespace
{
uint8_t computeBitsPerElement(TextureFormat textureFormat)
uint8_t computeBitsPerElement(PixelFormat textureFormat)
{
switch (textureFormat)
{
case TextureFormat::R8G8B8A8:
case TextureFormat::BGRA8888:
case PixelFormat::RGBA8888:
case PixelFormat::BGRA8888:
return byte(4);
case TextureFormat::R8G8B8:
case PixelFormat::RGB888:
return byte(3);
case TextureFormat::RGBA4444:
case PixelFormat::RGBA4444:
return byte(2);
case TextureFormat::A8:
case PixelFormat::A8:
return byte(1);
case TextureFormat::I8:
case PixelFormat::I8:
return byte(1);
case TextureFormat::RGB565:
case PixelFormat::RGB565:
return byte(2);
case TextureFormat::RGB5A1:
case PixelFormat::RGB5A1:
return byte(2);
case TextureFormat::AI88:
case PixelFormat::AI88:
return byte(2);
case TextureFormat::ETC1:
case PixelFormat::ETC:
return bit(4);
case TextureFormat::ATC_RGB:
case PixelFormat::ATC_RGB:
return bit(4);
case TextureFormat::ATC_EXPLICIT_ALPHA:
case PixelFormat::ATC_EXPLICIT_ALPHA:
return byte(1);
case TextureFormat::ATC_INTERPOLATED_ALPHA:
case PixelFormat::ATC_INTERPOLATED_ALPHA:
return byte(1);
case TextureFormat::PVRTC2:
case PixelFormat::PVRTC2:
return bit(2);
case TextureFormat::PVRTC2A:
case PixelFormat::PVRTC2A:
return bit(2);
case TextureFormat::PVRTC4:
case PixelFormat::PVRTC4:
return bit(4);
case TextureFormat::PVRTC4A:
case PixelFormat::PVRTC4A:
return bit(4);
case TextureFormat::S3TC_DXT1:
case PixelFormat::S3TC_DXT1:
return bit(4);
case TextureFormat::S3TC_DXT3:
case PixelFormat::S3TC_DXT3:
return byte(1);
case TextureFormat::S3TC_DXT5:
case PixelFormat::S3TC_DXT5:
return byte(1);
case TextureFormat::MTL_BGR5A1:
case PixelFormat::MTL_BGR5A1:
return byte(2);
case TextureFormat::MTL_B5G6R5:
case PixelFormat::MTL_B5G6R5:
return byte(2);
case TextureFormat::MTL_ABGR4:
case PixelFormat::MTL_ABGR4:
return byte(2);
case TextureFormat::D24S8:
case PixelFormat::D24S8:
#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
//ios use MTLPixelFormatDepth32Float_Stencil8 as DepthStencil combined format, its 64 bits
return byte(8);
@ -72,11 +72,11 @@ namespace
Texture::Texture(const TextureDescriptor& descriptor)
: _bitsPerElement(computeBitsPerElement(descriptor.textureFormat))
, _isMipmapEnabled(descriptor.samplerDescriptor.mipmapEnabled)
, _isCompressed(descriptor.compressed)
, _textureType(descriptor.textureType)
, _textureFormat(descriptor.textureFormat)
, _textureUsage(descriptor.textureUsage)
, _width(descriptor.width)
, _height(descriptor.height)
{
}
@ -86,23 +86,20 @@ Texture::~Texture()
void Texture::updateTextureDescriptor(const cocos2d::backend::TextureDescriptor &descriptor)
{
_bitsPerElement = computeBitsPerElement(descriptor.textureFormat);
_isMipmapEnabled = descriptor.samplerDescriptor.mipmapEnabled;
_isCompressed = descriptor.compressed;
_textureType = descriptor.textureType;
_textureFormat = descriptor.textureFormat;
_textureUsage = descriptor.textureUsage;
_width = descriptor.width;
_height = descriptor.height;
}
Texture2D::Texture2D(const TextureDescriptor& descriptor)
: Texture(descriptor)
, _width(descriptor.width)
, _height(descriptor.height)
{
}
TextureCubemap::TextureCubemap(const TextureDescriptor &descriptor)
: Texture(descriptor)
, _size(descriptor.width)
{
}

25
cocos/renderer/backend/Texture.h
View File

@ -11,12 +11,11 @@ CC_BACKEND_BEGIN
struct TextureDescriptor
{
TextureType textureType = TextureType::TEXTURE_2D;
TextureFormat textureFormat = TextureFormat::R8G8B8A8;
PixelFormat textureFormat = PixelFormat::RGBA8888;
TextureUsage textureUsage = TextureUsage::READ;
uint32_t width = 0;
uint32_t height = 0;
uint32_t depth = 0;
bool compressed = false;
SamplerDescriptor samplerDescriptor;
};
@ -28,9 +27,10 @@ public:
virtual void generateMipmaps() = 0;
virtual void updateTextureDescriptor(const TextureDescriptor& descriptor);
inline TextureFormat getTextureFormat() const { return _textureFormat; }
inline PixelFormat getTextureFormat() const { return _textureFormat; }
inline TextureUsage getTextureUsage() const { return _textureUsage; }
inline TextureType getTextureType() const { return _textureType; }
inline bool hasMipmaps() const { return _hasMipmaps; }
protected:
Texture(const TextureDescriptor& descriptor);
@ -38,12 +38,13 @@ protected:
// The bytes of all components.
uint8_t _bitsPerElement = 0;
bool _isMipmapEnabled = false;
bool _hasMipmaps = false;
bool _isCompressed = false;
bool _isMipmapGenerated = false;
uint32_t _width = 0;
uint32_t _height = 0;
TextureType _textureType = TextureType::TEXTURE_2D;
TextureFormat _textureFormat = TextureFormat::R8G8B8;
PixelFormat _textureFormat = PixelFormat::RGBA8888;
TextureUsage _textureUsage = TextureUsage::READ;
};
@ -51,27 +52,25 @@ protected:
class Texture2D : public Texture
{
public:
virtual void updateData(uint8_t* data) = 0;
virtual void updateSubData(uint32_t xoffset, uint32_t yoffset, uint32_t width, uint32_t height, uint8_t* data) = 0;
virtual void updateData(uint8_t* data, uint32_t width , uint32_t height, uint32_t level) = 0;
virtual void updateCompressedData(uint8_t* data, uint32_t width , uint32_t height, uint32_t dataLen, uint32_t level) = 0;
virtual void updateSubData(uint32_t xoffset, uint32_t yoffset, uint32_t width, uint32_t height, uint32_t level, uint8_t* data) = 0;
virtual void updateCompressedSubData(uint32_t xoffset, uint32_t yoffset, uint32_t width, uint32_t height, uint32_t dataLen, uint32_t level, uint8_t* data) = 0;
inline uint32_t getWidth() const { return _width; }
inline uint32_t getHeight() const { return _height; }
protected:
Texture2D(const TextureDescriptor& descriptor);
uint32_t _width = 0;
uint32_t _height = 0;
};
class TextureCubemap : public Texture
{
public:
virtual void updateFaceData(TextureCubeFace side, void *data) = 0;
void setSize(uint32_t size) { _size = size; }
protected:
TextureCubemap(const TextureDescriptor& descriptor);
uint32_t _size = 0;
};
CC_BACKEND_END

99
cocos/renderer/backend/Types.h
View File

@ -41,43 +41,68 @@ enum class VertexFormat : uint32_t
UBYTE4
};
enum class TextureFormat : uint32_t
/** @typedef backend::PixelFormat
Possible texture pixel formats
*/
enum class PixelFormat
{
NONE,
//! auto detect the type
AUTO,
//! 32-bit texture: BGRA8888
BGRA8888,
// Four 8-bit normalized unsigned integer components in RGBA order.
R8G8B8A8,
// Three 8-bit normalized unsigned integer components in RGB order.
R8G8B8,
// One 8-bit normalized unsigned integer component.
A8,
// A packed 32-bit combined depth and stencil pixel format with two nomorlized unsigned integer
// components: 24 bits, typically used for a depth render target, and 8 bits, typically used for
// a stencil render target.
D24S8,
I8,
AI88,
RGBA4444,
//! 32-bit texture: RGBA8888
RGBA8888,
//! 24-bit texture: RGBA888
RGB888,
//! 16-bit texture without Alpha channel
RGB565,
//! 8-bit textures used as masks
A8,
//! 8-bit intensity texture
I8,
//! 16-bit textures used as masks
AI88,
//! 16-bit textures: RGBA4444
RGBA4444,
//! 16-bit textures: RGB5A1
RGB5A1,
//metal 16 bits pixel formats
//! 4-bit PVRTC-compressed texture: PVRTC4
PVRTC4,
//! 4-bit PVRTC-compressed texture: PVRTC4 (has alpha channel)
PVRTC4A,
//! 2-bit PVRTC-compressed texture: PVRTC2
PVRTC2,
//! 2-bit PVRTC-compressed texture: PVRTC2 (has alpha channel)
PVRTC2A,
//! ETC-compressed texture: ETC
ETC,
//! S3TC-compressed texture: S3TC_Dxt1
S3TC_DXT1,
//! S3TC-compressed texture: S3TC_Dxt3
S3TC_DXT3,
//! S3TC-compressed texture: S3TC_Dxt5
S3TC_DXT5,
//! ATITC-compressed texture: ATC_RGB
ATC_RGB,
//! ATITC-compressed texture: ATC_EXPLICIT_ALPHA
ATC_EXPLICIT_ALPHA,
//! ATITC-compressed texture: ATC_INTERPOLATED_ALPHA
ATC_INTERPOLATED_ALPHA,
//! Default texture format: AUTO
MTL_B5G6R5,
//MTL_A1BGR5,
MTL_BGR5A1,
MTL_ABGR4,
// compressed format
ETC1,
ATC_RGB,
ATC_EXPLICIT_ALPHA,
ATC_INTERPOLATED_ALPHA,
PVRTC2,
PVRTC2A,
PVRTC4,
PVRTC4A,
S3TC_DXT1,
S3TC_DXT3,
S3TC_DXT5,
SYSTEM_DEFAULT
// A packed 32-bit combined depth and stencil pixel format with two nomorlized unsigned integer
// components: 24 bits, typically used for a depth render target, and 8 bits, typically used for
// a stencil render target.
D24S8,
DEFAULT = AUTO,
NONE = -1
};
enum class TextureUsage : uint32_t
@ -125,7 +150,11 @@ enum class SamplerAddressMode: uint32_t
enum class SamplerFilter: uint32_t
{
NEAREST,
NEAREST_MIPMAP_NEAREST,
NEAREST_MIPMAP_LINEAR,
LINEAR,
LINEAR_MIPMAP_LINEAR,
LINEAR_MIPMAP_NEAREST,
DONT_CARE,
};
@ -188,10 +217,8 @@ enum class ColorWriteMask: uint32_t
struct SamplerDescriptor
{
bool mipmapEnabled = false;
SamplerFilter magFilter = SamplerFilter::LINEAR;
SamplerFilter minFilter = SamplerFilter::LINEAR;
SamplerFilter mipmapFilter = SamplerFilter::LINEAR;
SamplerAddressMode sAddressMode = SamplerAddressMode::CLAMP_TO_EDGE;
SamplerAddressMode tAddressMode = SamplerAddressMode::CLAMP_TO_EDGE;
@ -204,16 +231,6 @@ struct SamplerDescriptor
SamplerAddressMode _tAddressMode
) : magFilter(_magFilter), minFilter(_minFilter),
sAddressMode(_sAddressMode), tAddressMode(_tAddressMode) {}
SamplerDescriptor(bool _mipmapEnabled,
SamplerFilter _magFilter,
SamplerFilter _minFilter,
SamplerFilter _mipmapFilter,
SamplerAddressMode _sAddressMode,
SamplerAddressMode _tAddressMode
) :mipmapEnabled(_mipmapEnabled), magFilter(_magFilter), minFilter(_minFilter),
mipmapFilter(_mipmapFilter), sAddressMode(_sAddressMode), tAddressMode(_tAddressMode) {}
};
enum class CullMode: uint32_t

3
cocos/renderer/backend/metal/DeviceInfoMTL.mm
View File

@ -397,6 +397,9 @@ const char* DeviceInfoMTL::getExtension() const
bool DeviceInfoMTL::checkForFeatureSupported(FeatureType feature)
{
//TODO coulsonwang, removed it later.
return false;
bool featureSupported = false;
switch (feature)
{

2
cocos/renderer/backend/metal/RenderPipelineMTL.mm
View File

@ -148,7 +148,7 @@ void RenderPipelineMTL::setBlendStateAndFormat(const RenderPipelineDescriptor& d
{
for (int i = 0; i < MAX_COLOR_ATTCHMENT; ++i)
{
if (TextureFormat::NONE == descriptor.colorAttachmentsFormat[i])
if (PixelFormat::NONE == descriptor.colorAttachmentsFormat[i])
continue;
_mtlRenderPipelineDescriptor.colorAttachments[i].pixelFormat = Utils::toMTLPixelFormat(descriptor.colorAttachmentsFormat[i]);

6
cocos/renderer/backend/metal/TextureMTL.h
View File

@ -12,8 +12,10 @@ public:
TextureMTL(id<MTLDevice> mtlDevice, const TextureDescriptor& descriptor);
~TextureMTL();
virtual void updateData(uint8_t* data) override;
virtual void updateSubData(unsigned int xoffset, unsigned int yoffset, unsigned int width, unsigned int height, uint8_t* data) override;
virtual void updateData(uint8_t* data, uint32_t width , uint32_t height, uint32_t level) override;
virtual void updateCompressedData(uint8_t* data, uint32_t width , uint32_t height, uint32_t dataLen, uint32_t level) override;
virtual void updateSubData(uint32_t xoffset, uint32_t yoffset, uint32_t width, uint32_t height, uint32_t level, uint8_t* data) override;
virtual void updateCompressedSubData(uint32_t xoffset, uint32_t yoffset, uint32_t width, uint32_t height, uint32_t dataLen, uint32_t level, uint8_t* data) override;
virtual void updateSamplerDescriptor(const SamplerDescriptor &sampler) override;
virtual void getBytes(int x, int y, int width, int height, bool flipImage, std::function<void(const unsigned char*, int, int)> callback) override;

96
cocos/renderer/backend/metal/TextureMTL.mm
View File

@ -29,8 +29,12 @@ namespace
{
switch (mode) {
case SamplerFilter::NEAREST:
case SamplerFilter::NEAREST_MIPMAP_LINEAR:
case SamplerFilter::NEAREST_MIPMAP_NEAREST:
return MTLSamplerMinMagFilterNearest;
case SamplerFilter::LINEAR:
case SamplerFilter::LINEAR_MIPMAP_LINEAR:
case SamplerFilter::LINEAR_MIPMAP_NEAREST:
return MTLSamplerMinMagFilterLinear;
case SamplerFilter::DONT_CARE:
return MTLSamplerMinMagFilterNearest;
@ -40,8 +44,12 @@ namespace
MTLSamplerMipFilter toMTLSamplerMipFilter(SamplerFilter mode) {
switch (mode) {
case SamplerFilter::NEAREST:
case SamplerFilter::LINEAR_MIPMAP_NEAREST:
case SamplerFilter::NEAREST_MIPMAP_NEAREST:
return MTLSamplerMipFilterNearest;
case SamplerFilter::LINEAR:
case SamplerFilter::LINEAR_MIPMAP_LINEAR:
case SamplerFilter::NEAREST_MIPMAP_LINEAR:
return MTLSamplerMipFilterLinear;
case SamplerFilter::DONT_CARE:
return MTLSamplerMipFilterNearest;
@ -60,13 +68,13 @@ namespace
}
bool convertData(uint8_t* src, unsigned int length, TextureFormat format, uint8_t** out)
bool convertData(uint8_t* src, unsigned int length, PixelFormat format, uint8_t** out)
{
*out = src;
bool converted = false;
switch (format)
{
case TextureFormat::R8G8B8:
case PixelFormat::RGB888:
{
*out = (uint8_t*)malloc(length * 4);
convertRGB2RGBA(src, *out, length);
@ -79,23 +87,36 @@ namespace
return converted;
}
bool isColorRenderable(TextureFormat textureFormat)
bool isColorRenderable(PixelFormat textureFormat)
{
switch (textureFormat)
{
case TextureFormat::R8G8B8A8:
case TextureFormat::R8G8B8:
case TextureFormat::RGBA4444:
case TextureFormat::RGB565:
case TextureFormat::RGB5A1:
case TextureFormat::MTL_BGR5A1:
case TextureFormat::MTL_B5G6R5:
case TextureFormat::MTL_ABGR4:
case PixelFormat::RGBA8888:
case PixelFormat::RGB888:
case PixelFormat::RGBA4444:
case PixelFormat::RGB565:
case PixelFormat::RGB5A1:
case PixelFormat::MTL_BGR5A1:
case PixelFormat::MTL_B5G6R5:
case PixelFormat::MTL_ABGR4:
return true;
default:
return false;
}
}
bool isCompressedFormat(PixelFormat textureFormat)
{
MTLPixelFormat pixelFormat = Utils::toMTLPixelFormat(textureFormat);
#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
bool isCompressed = (pixelFormat >= MTLPixelFormatPVRTC_RGB_2BPP &&
pixelFormat <= MTLPixelFormatASTC_12x12_LDR);
#else
bool isCompressed = (pixelFormat >= MTLPixelFormatBC1_RGBA &&
pixelFormat <= MTLPixelFormatBC7_RGBAUnorm_sRGB);
#endif
return isCompressed;
}
}
TextureMTL::TextureMTL(id<MTLDevice> mtlDevice, const TextureDescriptor& descriptor)
@ -103,6 +124,7 @@ TextureMTL::TextureMTL(id<MTLDevice> mtlDevice, const TextureDescriptor& descrip
{
_mtlDevice = mtlDevice;
updateTextureDescriptor(descriptor);
_isCompressed = isCompressedFormat(descriptor.textureFormat);
}
TextureMTL::~TextureMTL()
@ -121,7 +143,7 @@ void TextureMTL::updateTextureDescriptor(const cocos2d::backend::TextureDescript
Texture::updateTextureDescriptor(descriptor);
createTexture(_mtlDevice, descriptor);
updateSamplerDescriptor(descriptor.samplerDescriptor);
if (TextureFormat::R8G8B8 == _textureFormat)
if (PixelFormat::RGB888 == _textureFormat)
{
_bitsPerElement = 4 * 8;
}
@ -129,12 +151,12 @@ void TextureMTL::updateTextureDescriptor(const cocos2d::backend::TextureDescript
_bytesPerRow = descriptor.width * _bitsPerElement / 8 ;
}
void TextureMTL::updateData(uint8_t* data)
void TextureMTL::updateData(uint8_t* data, uint32_t width , uint32_t height, uint32_t level)
{
updateSubData(0, 0, (unsigned int)_mtlTexture.width, (unsigned int)_mtlTexture.height, data);
updateSubData(0, 0, width, height, level, data);
}
void TextureMTL::updateSubData(unsigned int xoffset, unsigned int yoffset, unsigned int width, unsigned int height, uint8_t* data)
void TextureMTL::updateSubData(uint32_t xoffset, uint32_t yoffset, uint32_t width, uint32_t height, uint32_t level, uint8_t* data)
{
MTLRegion region =
{
@ -147,23 +169,30 @@ void TextureMTL::updateSubData(unsigned int xoffset, unsigned int yoffset, unsig
(uint32_t)(width * height),
_textureFormat, &convertedData);
//TODO coulsonwang, it seems that only PVRTC has such limitation.
//when pixel format is a compressed one, bytePerRow should be set to ZERO
int bytesPerRow = _isCompressed ? 0 : _bytesPerRow;
int bytesPerRow = _isCompressed ? 0 : (width * _bitsPerElement / 8);
[_mtlTexture replaceRegion:region
mipmapLevel:0
mipmapLevel:level
withBytes:convertedData
bytesPerRow:bytesPerRow];
if (converted)
free(convertedData);
// metal doesn't generate mipmaps automatically, so should generate it manually.
if (_isMipmapEnabled)
{
_isMipmapGenerated = false;
generateMipmaps();
}
if(!_hasMipmaps && level > 0)
_hasMipmaps = true;
}
void TextureMTL::updateCompressedData(uint8_t *data, uint32_t width, uint32_t height, uint32_t dataLen, uint32_t level)
{
updateCompressedSubData(0, 0, width, height, dataLen, level, data);
}
void TextureMTL::updateCompressedSubData(uint32_t xoffset, uint32_t yoffset, uint32_t width, uint32_t height, uint32_t dataLen, uint32_t level, uint8_t *data)
{
updateSubData(xoffset, yoffset, width, height, level, data);
}
void TextureMTL::createTexture(id<MTLDevice> mtlDevice, const TextureDescriptor& descriptor)
@ -181,7 +210,7 @@ void TextureMTL::createTexture(id<MTLDevice> mtlDevice, const TextureDescriptor&
if (TextureUsage::RENDER_TARGET == descriptor.textureUsage)
{
//DepthStencil, and Multisample textures must be allocated with the MTLResourceStorageModePrivate resource option
if(TextureFormat::D24S8 == descriptor.textureFormat)
if(PixelFormat::D24S8 == descriptor.textureFormat)
textureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
textureDescriptor.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
}
@ -199,8 +228,6 @@ void TextureMTL::createSampler(id<MTLDevice> mtlDevice, const SamplerDescriptor
mtlDescriptor.minFilter = descriptor.minFilter == SamplerFilter::DONT_CARE ? _minFilter : toMTLSamplerMinMagFilter(descriptor.minFilter);
mtlDescriptor.magFilter = descriptor.magFilter == SamplerFilter::DONT_CARE ? _magFilter : toMTLSamplerMinMagFilter(descriptor.magFilter);
if (_isMipmapEnabled)
mtlDescriptor.mipFilter = descriptor.mipmapFilter == SamplerFilter::DONT_CARE ? _mipFilter : toMTLSamplerMipFilter(descriptor.mipmapFilter);
if(_mtlSamplerState)
{
@ -253,9 +280,9 @@ void TextureMTL::generateMipmaps()
if (TextureUsage::RENDER_TARGET == _textureUsage || isColorRenderable(_textureFormat) == false)
return;
if(!_isMipmapGenerated)
if(!_hasMipmaps)
{
_isMipmapGenerated = true;
_hasMipmaps = true;
Utils::generateMipmaps(_mtlTexture);
}
@ -281,7 +308,7 @@ void TextureCubeMTL::updateTextureDescriptor(const cocos2d::backend::TextureDesc
updateSamplerDescriptor(descriptor.samplerDescriptor);
// Metal doesn't support RGB888/RGBA4444, so should convert to RGBA888;
if (TextureFormat::R8G8B8 == _textureFormat)
if (PixelFormat::RGB888 == _textureFormat)
{
_bitsPerElement = 4 * 8;
}
@ -319,8 +346,6 @@ void TextureCubeMTL::createSampler(id<MTLDevice> mtlDevice, const SamplerDescrip
mtlDescriptor.minFilter = descriptor.minFilter == SamplerFilter::DONT_CARE ? _minFilter : toMTLSamplerMinMagFilter(descriptor.minFilter);
mtlDescriptor.magFilter = descriptor.magFilter == SamplerFilter::DONT_CARE ? _magFilter : toMTLSamplerMinMagFilter(descriptor.magFilter);
if (_isMipmapEnabled)
mtlDescriptor.mipFilter = descriptor.mipmapFilter == SamplerFilter::DONT_CARE ? _mipFilter : toMTLSamplerMipFilter(descriptor.mipmapFilter);
if(_mtlSamplerState)
{
@ -353,11 +378,6 @@ void TextureCubeMTL::updateFaceData(TextureCubeFace side, void *data)
withBytes:data
bytesPerRow:_bytesPerRow
bytesPerImage:_bytesPerImage];
if(_isMipmapEnabled)
{
_isMipmapGenerated = true;
generateMipmaps();
}
}
void TextureCubeMTL::getBytes(int x, int y, int width, int height, bool flipImage, std::function<void(const unsigned char*, int, int)> callback)
@ -394,9 +414,9 @@ void TextureCubeMTL::generateMipmaps()
if (TextureUsage::RENDER_TARGET == _textureUsage || isColorRenderable(_textureFormat) == false)
return;
if(!_isMipmapGenerated)
if(!_hasMipmaps)
{
_isMipmapGenerated = true;
_hasMipmaps = true;
Utils::generateMipmaps(_mtlTexture);
}
}

2
cocos/renderer/backend/metal/Utils.h
View File

@ -16,7 +16,7 @@ public:
static id<MTLTexture> getDefaultDepthStencilTexture();
static MTLPixelFormat toMTLPixelFormat(TextureFormat textureFormat);
static MTLPixelFormat toMTLPixelFormat(PixelFormat textureFormat);
static void generateMipmaps(id<MTLTexture> texture);
static void getTextureBytes(int origX, int origY, int rectWidth, int rectHeight, id<MTLTexture> texture, std::function<void(const unsigned char*, int, int)> callback);
static void swizzleImage(unsigned char* image, int width, int height, MTLPixelFormat format);

30
cocos/renderer/backend/metal/Utils.mm
View File

@ -78,42 +78,42 @@ void Utils::updateDefaultColorAttachmentTexture(id<MTLTexture> texture)
Utils::_defaultColorAttachmentTexture = texture;
}
MTLPixelFormat Utils::toMTLPixelFormat(TextureFormat textureFormat)
MTLPixelFormat Utils::toMTLPixelFormat(PixelFormat textureFormat)
{
switch (textureFormat)
{
#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
case TextureFormat::MTL_ABGR4:
case PixelFormat::MTL_ABGR4:
return MTLPixelFormatABGR4Unorm;
case TextureFormat::MTL_BGR5A1:
case PixelFormat::MTL_BGR5A1:
return MTLPixelFormatBGR5A1Unorm;
case TextureFormat::MTL_B5G6R5:
case PixelFormat::MTL_B5G6R5:
return MTLPixelFormatB5G6R5Unorm;
case TextureFormat::PVRTC4A:
case PixelFormat::PVRTC4A:
return MTLPixelFormatPVRTC_RGBA_4BPP;
case TextureFormat::PVRTC4:
case PixelFormat::PVRTC4:
return MTLPixelFormatPVRTC_RGB_4BPP;
case TextureFormat::PVRTC2A:
case PixelFormat::PVRTC2A:
return MTLPixelFormatPVRTC_RGBA_2BPP;
case TextureFormat::PVRTC2:
case PixelFormat::PVRTC2:
return MTLPixelFormatPVRTC_RGB_2BPP;
#endif
case TextureFormat::R8G8B8A8:
case PixelFormat::RGBA8888:
return MTLPixelFormatRGBA8Unorm;
// Should transfer the data to match pixel format when updating data.
case TextureFormat::R8G8B8:
case PixelFormat::RGB888:
return MTLPixelFormatRGBA8Unorm;
case TextureFormat::A8:
case PixelFormat::A8:
return MTLPixelFormatA8Unorm;
case TextureFormat::BGRA8888:
case PixelFormat::BGRA8888:
return MTLPixelFormatBGRA8Unorm;
//on mac, D24S8 means MTLPixelFormatDepth24Unorm_Stencil8, while on ios it means MTLPixelFormatDepth32Float_Stencil8
case TextureFormat::D24S8:
case PixelFormat::D24S8:
return getSupportedDepthStencilFormat();
case TextureFormat::SYSTEM_DEFAULT:
case PixelFormat::DEFAULT:
return COLOR_ATTAHCMENT_PIXEL_FORMAT;
case TextureFormat::NONE:
case PixelFormat::NONE:
default:
return MTLPixelFormatInvalid;
}

182
cocos/renderer/backend/opengl/TextureGL.cpp
View File

@ -11,7 +11,24 @@ CC_BACKEND_BEGIN
#define ISPOW2(n) (((n) & (n-1)) == 0)
void TextureInfoGL::applySamplerDescriptor(const SamplerDescriptor& descriptor, bool isPow2)
namespace {
bool isMipmapEnabled(GLint filter)
{
switch(filter)
{
case GL_LINEAR_MIPMAP_LINEAR:
case GL_LINEAR_MIPMAP_NEAREST:
case GL_NEAREST_MIPMAP_NEAREST:
case GL_NEAREST_MIPMAP_LINEAR:
return true;
default:
break;
}
return false;
}
}
void TextureInfoGL::applySamplerDescriptor(const SamplerDescriptor& descriptor, bool isPow2, bool hasMipmaps)
{
if (descriptor.magFilter != SamplerFilter::DONT_CARE)
{
@ -20,7 +37,7 @@ void TextureInfoGL::applySamplerDescriptor(const SamplerDescriptor& descriptor,
if (descriptor.minFilter != SamplerFilter::DONT_CARE)
{
minFilterGL = UtilsGL::toGLMinFilter(descriptor.minFilter, descriptor.mipmapFilter, descriptor.mipmapEnabled, isPow2);
minFilterGL = UtilsGL::toGLMinFilter(descriptor.minFilter, hasMipmaps, isPow2);
}
if (descriptor.sAddressMode != SamplerAddressMode::DONT_CARE)
@ -37,19 +54,8 @@ void TextureInfoGL::applySamplerDescriptor(const SamplerDescriptor& descriptor,
Texture2DGL::Texture2DGL(const TextureDescriptor& descriptor) : Texture2D(descriptor)
{
glGenTextures(1, &_textureInfo.texture);
UtilsGL::toGLTypes(_textureFormat, _textureInfo.internalFormat, _textureInfo.format, _textureInfo.type, _isCompressed);
bool isPow2 = ISPOW2(_width) && ISPOW2(_height);
_textureInfo.magFilterGL = UtilsGL::toGLMagFilter(descriptor.samplerDescriptor.magFilter);
_textureInfo.minFilterGL = UtilsGL::toGLMinFilter(descriptor.samplerDescriptor.minFilter,
descriptor.samplerDescriptor.mipmapFilter, _isMipmapEnabled, isPow2);
_textureInfo.sAddressModeGL = UtilsGL::toGLAddressMode(descriptor.samplerDescriptor.sAddressMode, isPow2);
_textureInfo.tAddressModeGL = UtilsGL::toGLAddressMode(descriptor.samplerDescriptor.tAddressMode, isPow2);
// Update data here because `updateData()` may not be invoked later.
// For example, a texture used as depth buffer will not invoke updateData().
initWithZeros();
updateTextureDescriptor(descriptor);
#if CC_ENABLE_CACHE_TEXTURE_DATA
// Listen this event to restored texture id after coming to foreground on Android.
@ -66,7 +72,7 @@ void Texture2DGL::initWithZeros()
auto size = _width * _height * _bitsPerElement / 8;
uint8_t* data = (uint8_t*)malloc(size);
memset(data, 0, size);
updateData(data);
updateData(data, _width, _height, 0);
free(data);
}
@ -74,9 +80,18 @@ void Texture2DGL::updateTextureDescriptor(const cocos2d::backend::TextureDescrip
{
Texture::updateTextureDescriptor(descriptor);
UtilsGL::toGLTypes(descriptor.textureFormat, _textureInfo.internalFormat, _textureInfo.format, _textureInfo.type, _isCompressed);
_width = descriptor.width;
_height = descriptor.height;
bool isPow2 = ISPOW2(_width) && ISPOW2(_height);
_textureInfo.magFilterGL = UtilsGL::toGLMagFilter(descriptor.samplerDescriptor.magFilter);
_textureInfo.minFilterGL = UtilsGL::toGLMinFilter(descriptor.samplerDescriptor.minFilter, _hasMipmaps, isPow2);
_textureInfo.sAddressModeGL = UtilsGL::toGLAddressMode(descriptor.samplerDescriptor.sAddressMode, isPow2);
_textureInfo.tAddressModeGL = UtilsGL::toGLAddressMode(descriptor.samplerDescriptor.tAddressMode, isPow2);
updateSamplerDescriptor(descriptor.samplerDescriptor);
// Update data here because `updateData()` may not be invoked later.
// For example, a texture used as depth buffer will not invoke updateData().
initWithZeros();
}
@ -92,7 +107,7 @@ Texture2DGL::~Texture2DGL()
void Texture2DGL::updateSamplerDescriptor(const SamplerDescriptor &sampler) {
bool isPow2 = ISPOW2(_width) && ISPOW2(_height);
_textureInfo.applySamplerDescriptor(sampler, isPow2);
_textureInfo.applySamplerDescriptor(sampler, isPow2, _hasMipmaps);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, _textureInfo.texture);
@ -118,15 +133,14 @@ void Texture2DGL::updateSamplerDescriptor(const SamplerDescriptor &sampler) {
}
}
void Texture2DGL::updateData(uint8_t* data)
void Texture2DGL::updateData(uint8_t* data, uint32_t width , uint32_t height, uint32_t level)
{
// TODO: support texture cube, and compressed data.
//Set the row align only when mipmapsNum == 1 and the data is uncompressed
if(!_isMipmapEnabled && !_isCompressed)
auto mipmapEnalbed = isMipmapEnabled(_textureInfo.minFilterGL) || isMipmapEnabled(_textureInfo.magFilterGL);
if(!mipmapEnalbed)
{
unsigned int bytesPerRow = _width * _bitsPerElement / 8;
unsigned int bytesPerRow = width * _bitsPerElement / 8;
if(bytesPerRow % 8 == 0)
{
glPixelStorei(GL_UNPACK_ALIGNMENT, 8);
@ -148,7 +162,7 @@ void Texture2DGL::updateData(uint8_t* data)
{
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
}
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, _textureInfo.texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, _textureInfo.magFilterGL);
@ -157,39 +171,55 @@ void Texture2DGL::updateData(uint8_t* data)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, _textureInfo.tAddressModeGL);
if(_isCompressed)
{
auto datalen = _width * _height * _bitsPerElement / 8;
glCompressedTexImage2D(GL_TEXTURE_2D, 0, _textureInfo.internalFormat, (GLsizei)_width, (GLsizei)_height, 0, datalen, data);
}
else
{
glTexImage2D(GL_TEXTURE_2D,
0,
_textureInfo.internalFormat,
_width,
_height,
0,
_textureInfo.format,
_textureInfo.type,
data);
}
glTexImage2D(GL_TEXTURE_2D,
level,
_textureInfo.internalFormat,
width,
height,
0,
_textureInfo.format,
_textureInfo.type,
data);
CHECK_GL_ERROR_DEBUG();
if(_isMipmapEnabled)
{
_isMipmapGenerated = false;
generateMipmaps();
}
CHECK_GL_ERROR_DEBUG();
if(!_hasMipmaps && level > 0)
_hasMipmaps = true;
}
void Texture2DGL::updateSubData(unsigned int xoffset, unsigned int yoffset, unsigned int width, unsigned int height, uint8_t* data)
void Texture2DGL::updateCompressedData(uint8_t *data, uint32_t width, uint32_t height,
uint32_t dataLen, uint32_t level)
{
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, _textureInfo.texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, _textureInfo.magFilterGL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, _textureInfo.minFilterGL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, _textureInfo.sAddressModeGL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, _textureInfo.tAddressModeGL);
glCompressedTexImage2D(GL_TEXTURE_2D,
level,
_textureInfo.internalFormat,
(GLsizei)width,
(GLsizei)height,
0,
dataLen,
data);
CHECK_GL_ERROR_DEBUG();
if(!_hasMipmaps && level > 0)
_hasMipmaps = true;
}
void Texture2DGL::updateSubData(uint32_t xoffset, uint32_t yoffset, uint32_t width, uint32_t height, uint32_t level, uint8_t* data)
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, _textureInfo.texture);
glTexSubImage2D(GL_TEXTURE_2D,
0,
level,
xoffset,
yoffset,
width,
@ -199,12 +229,30 @@ void Texture2DGL::updateSubData(unsigned int xoffset, unsigned int yoffset, unsi
data);
CHECK_GL_ERROR_DEBUG();
if(_isMipmapEnabled)
{
_isMipmapGenerated = false;
generateMipmaps();
}
if(!_hasMipmaps && level > 0)
_hasMipmaps = true;
}
void Texture2DGL::updateCompressedSubData(uint32_t xoffset, uint32_t yoffset, uint32_t width,
uint32_t height, uint32_t dataLen, uint32_t level,
uint8_t *data)
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, _textureInfo.texture);
glCompressedTexSubImage2D(GL_TEXTURE_2D,
level,
xoffset,
yoffset,
width,
height,
_textureInfo.format,
dataLen,
data);
CHECK_GL_ERROR_DEBUG();
if(!_hasMipmaps && level > 0)
_hasMipmaps = true;
}
void Texture2DGL::apply(int index) const
@ -218,9 +266,9 @@ void Texture2DGL::generateMipmaps()
if (TextureUsage::RENDER_TARGET == _textureUsage)
return;
if(!_isMipmapGenerated)
if(!_hasMipmaps)
{
_isMipmapGenerated = true;
_hasMipmaps = true;
glGenerateMipmap(GL_TEXTURE_2D);
}
}
@ -264,8 +312,7 @@ void Texture2DGL::getBytes(int x, int y, int width, int height, bool flipImage,
TextureCubeGL::TextureCubeGL(const TextureDescriptor& descriptor)
:TextureCubemap(descriptor)
{
assert(descriptor.width == descriptor.height);
_size = descriptor.width;
assert(_width == _height);
_textureType = TextureType::TEXTURE_CUBE;
UtilsGL::toGLTypes(_textureFormat, _textureInfo.internalFormat, _textureInfo.format, _textureInfo.type, _isCompressed);
glGenTextures(1, &_textureInfo.texture);
@ -299,7 +346,6 @@ void TextureCubeGL::updateTextureDescriptor(const cocos2d::backend::TextureDescr
{
UtilsGL::toGLTypes(descriptor.textureFormat, _textureInfo.internalFormat, _textureInfo.format, _textureInfo.type, _isCompressed);
_textureFormat = descriptor.textureFormat;
_size = descriptor.width;
updateSamplerDescriptor(descriptor.samplerDescriptor);
}
@ -316,7 +362,7 @@ TextureCubeGL::~TextureCubeGL()
void TextureCubeGL::updateSamplerDescriptor(const SamplerDescriptor &sampler)
{
_textureInfo.applySamplerDescriptor(sampler, true);
_textureInfo.applySamplerDescriptor(sampler, true, _hasMipmaps);
setTexParameters();
}
@ -336,17 +382,13 @@ void TextureCubeGL::updateFaceData(TextureCubeFace side, void *data)
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i,
0, // level
GL_RGBA, // internal format
_size, // width
_size, // height
_width, // width
_height, // height
0, // border
_textureInfo.internalFormat, // format
_textureInfo.type, // type
data); // pixel data
if(_isMipmapEnabled)
{
_isMipmapGenerated = false;
generateMipmaps();
}
CHECK_GL_ERROR_DEBUG();
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
}
@ -391,9 +433,9 @@ void TextureCubeGL::generateMipmaps()
if (TextureUsage::RENDER_TARGET == _textureUsage)
return;
if(!_isMipmapGenerated)
if(!_hasMipmaps)
{
_isMipmapGenerated = true;
_hasMipmaps = true;
glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
}
}

9
cocos/renderer/backend/opengl/TextureGL.h
View File

@ -8,7 +8,7 @@ CC_BACKEND_BEGIN
struct TextureInfoGL
{
void applySamplerDescriptor(const SamplerDescriptor &desc, bool isPow2);
void applySamplerDescriptor(const SamplerDescriptor &desc, bool isPow2, bool hasMipmaps);
GLint magFilterGL = GL_LINEAR;
GLint minFilterGL = GL_LINEAR;
@ -29,8 +29,10 @@ public:
Texture2DGL(const TextureDescriptor& descriptor);
~Texture2DGL();
virtual void updateData(uint8_t* data) override;
virtual void updateSubData(unsigned int xoffset, unsigned int yoffset, unsigned int width, unsigned int height, uint8_t* data) override;
virtual void updateData(uint8_t* data, uint32_t width , uint32_t height, uint32_t level) override;
virtual void updateCompressedData(uint8_t* data, uint32_t width , uint32_t height, uint32_t dataLen, uint32_t level) override;
virtual void updateSubData(uint32_t xoffset, uint32_t yoffset, uint32_t width, uint32_t height, uint32_t level, uint8_t* data) override;
virtual void updateCompressedSubData(uint32_t xoffset, uint32_t yoffset, uint32_t width, uint32_t height, uint32_t dataLen, uint32_t level, uint8_t* data) override;
virtual void updateSamplerDescriptor(const SamplerDescriptor &sampler) override;
virtual void getBytes(int x, int y, int width, int height, bool flipImage, std::function<void(const unsigned char*, int, int)> callback) override;
virtual void generateMipmaps() override;
@ -44,7 +46,6 @@ private:
void initWithZeros();
SamplerDescriptor _samplerDescriptor;
bool _isCompressed = false;
TextureInfoGL _textureInfo;
EventListener* _backToForegroundListener = nullptr;
};

105
cocos/renderer/backend/opengl/UtilsGL.cpp
View File

@ -126,50 +126,35 @@ GLint UtilsGL::toGLMagFilter(SamplerFilter magFilter)
return ret;
}
GLint UtilsGL::toGLMinFilter(SamplerFilter minFilter, SamplerFilter mipmapFilter, bool mipmapEnabled, bool isPow2)
GLint UtilsGL::toGLMinFilter(SamplerFilter minFilter, bool hasMipmaps, bool isPow2)
{
if (mipmapEnabled)
{
if (!isPow2)
{
cocos2d::log("Change minification filter to either NEAREST or LINEAR since non-power-of-two texture occur in %s %s %d", __FILE__, __FUNCTION__, __LINE__);
if (SamplerFilter::LINEAR == minFilter)
return GL_LINEAR;
else
return GL_NEAREST;
}
switch (minFilter)
{
case SamplerFilter::LINEAR:
switch (mipmapFilter)
{
case SamplerFilter::LINEAR:
return GL_LINEAR_MIPMAP_LINEAR;
case SamplerFilter::NEAREST:
return GL_LINEAR_MIPMAP_NEAREST;
case SamplerFilter::DONT_CARE:
return GL_LINEAR_MIPMAP_NEAREST;
}
case SamplerFilter::NEAREST:
switch (mipmapFilter)
{
case SamplerFilter::LINEAR:
return GL_NEAREST_MIPMAP_LINEAR;
case SamplerFilter::NEAREST:
return GL_NEAREST_MIPMAP_NEAREST;
case SamplerFilter::DONT_CARE:
return GL_LINEAR_MIPMAP_NEAREST;
}
}
}
else
if (hasMipmaps && !isPow2)
{
CCLOG("Change minification filter to either NEAREST or LINEAR since non-power-of-two texture occur in %s %s %d", __FILE__, __FUNCTION__, __LINE__);
if (SamplerFilter::LINEAR == minFilter)
return GL_LINEAR;
else
return GL_NEAREST;
}
switch (minFilter)
{
case SamplerFilter::LINEAR:
return GL_LINEAR;
case SamplerFilter::LINEAR_MIPMAP_LINEAR:
return GL_LINEAR_MIPMAP_LINEAR;
case SamplerFilter::LINEAR_MIPMAP_NEAREST:
return GL_LINEAR_MIPMAP_NEAREST;
case SamplerFilter::NEAREST:
return GL_NEAREST;
case SamplerFilter::NEAREST_MIPMAP_NEAREST:
return GL_NEAREST_MIPMAP_NEAREST;
case SamplerFilter::NEAREST_MIPMAP_LINEAR:
return GL_NEAREST_MIPMAP_LINEAR;
default:
break;
}
return GL_NEAREST;
}
@ -178,7 +163,7 @@ GLint UtilsGL::toGLAddressMode(SamplerAddressMode addressMode, bool isPow2)
GLint ret = GL_REPEAT;
if (!isPow2 && (addressMode != SamplerAddressMode::CLAMP_TO_EDGE))
{
cocos2d::log("Change texture wrap mode to CLAMP_TO_EDGE since non-power-of-two texture occur in %s %s %d", __FILE__, __FUNCTION__, __LINE__);
CCLOG("Change texture wrap mode to CLAMP_TO_EDGE since non-power-of-two texture occur in %s %s %d", __FILE__, __FUNCTION__, __LINE__);
return GL_CLAMP_TO_EDGE;
}
@ -200,52 +185,52 @@ GLint UtilsGL::toGLAddressMode(SamplerAddressMode addressMode, bool isPow2)
}
void UtilsGL::toGLTypes(TextureFormat textureFormat, GLint &internalFormat, GLuint &format, GLenum &type, bool &isCompressed)
void UtilsGL::toGLTypes(PixelFormat textureFormat, GLint &internalFormat, GLuint &format, GLenum &type, bool &isCompressed)
{
switch (textureFormat)
{
case TextureFormat::R8G8B8A8:
case PixelFormat::RGBA8888:
internalFormat = GL_RGBA;
format = GL_RGBA;
type = GL_UNSIGNED_BYTE;
break;
case TextureFormat::R8G8B8:
case PixelFormat::RGB888:
internalFormat = GL_RGB;
format = GL_RGB;
type = GL_UNSIGNED_BYTE;
break;
case TextureFormat::RGBA4444:
case PixelFormat::RGBA4444:
internalFormat = GL_RGBA;
format = GL_RGBA;
type = GL_UNSIGNED_SHORT_4_4_4_4;
break;
case TextureFormat::A8:
case PixelFormat::A8:
internalFormat = GL_ALPHA;
format = GL_ALPHA;
type = GL_UNSIGNED_BYTE;
break;
case TextureFormat::I8:
case PixelFormat::I8:
internalFormat = GL_LUMINANCE;
format = GL_LUMINANCE;
type = GL_UNSIGNED_BYTE;
break;
case TextureFormat::AI88:
case PixelFormat::AI88:
internalFormat = GL_LUMINANCE_ALPHA;
format = GL_LUMINANCE_ALPHA;
type = GL_UNSIGNED_BYTE;
break;
case TextureFormat::RGB565:
case PixelFormat::RGB565:
internalFormat = GL_RGB;
format = GL_RGB;
type = GL_UNSIGNED_SHORT_5_6_5;
break;
case TextureFormat::RGB5A1:
case PixelFormat::RGB5A1:
internalFormat = GL_RGBA;
format = GL_RGBA;
type = GL_UNSIGNED_SHORT_5_5_5_1;
break;
#ifdef GL_ETC1_RGB8_OES
case TextureFormat::ETC1:
case PixelFormat::ETC:
internalFormat = GL_ETC1_RGB8_OES;
format = 0xFFFFFFFF;
type = 0xFFFFFFFF;
@ -253,7 +238,7 @@ void UtilsGL::toGLTypes(TextureFormat textureFormat, GLint &internalFormat, GLui
break;
#endif // GL_ETC1_RGB8_OES
#ifdef GL_ATC_RGB_AMD
case TextureFormat::ATC_RGB:
case PixelFormat::ATC_RGB:
internalFormat = GL_ATC_RGB_AMD;
format = 0xFFFFFFFF;
type = 0xFFFFFFFF;
@ -261,14 +246,14 @@ void UtilsGL::toGLTypes(TextureFormat textureFormat, GLint &internalFormat, GLui
break;
#endif // GL_ATC_RGB_AMD
#ifdef GL_ATC_RGBA_EXPLICIT_ALPHA_AMD
case TextureFormat::ATC_EXPLICIT_ALPHA:
case PixelFormat::ATC_EXPLICIT_ALPHA:
internalFormat = GL_ATC_RGBA_EXPLICIT_ALPHA_AMD;
format = 0xFFFFFFFF;
type = 0xFFFFFFFF;
isCompressed = true;
#endif // GL_ATC_RGBA_EXPLICIT_ALPHA_AMD
#ifdef GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD
case TextureFormat::ATC_INTERPOLATED_ALPHA:
case PixelFormat::ATC_INTERPOLATED_ALPHA:
internalFormat = GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD;
format = 0xFFFFFFFF;
type = 0xFFFFFFFF;
@ -277,7 +262,7 @@ void UtilsGL::toGLTypes(TextureFormat textureFormat, GLint &internalFormat, GLui
#endif // GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD
#ifdef GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG
case TextureFormat::PVRTC2:
case PixelFormat::PVRTC2:
internalFormat = GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
format = 0xFFFFFFFF;
type = 0xFFFFFFFF;
@ -285,7 +270,7 @@ void UtilsGL::toGLTypes(TextureFormat textureFormat, GLint &internalFormat, GLui
break;
#endif
#ifdef GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG
case TextureFormat::PVRTC2A:
case PixelFormat::PVRTC2A:
internalFormat = GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
format = 0xFFFFFFFF;
type = 0xFFFFFFFF;
@ -293,7 +278,7 @@ void UtilsGL::toGLTypes(TextureFormat textureFormat, GLint &internalFormat, GLui
break;
#endif
#ifdef GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG
case TextureFormat::PVRTC4:
case PixelFormat::PVRTC4:
internalFormat = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
format = 0xFFFFFFFF;
type = 0xFFFFFFFF;
@ -301,7 +286,7 @@ void UtilsGL::toGLTypes(TextureFormat textureFormat, GLint &internalFormat, GLui
break;
#endif
#ifdef GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
case TextureFormat::PVRTC4A:
case PixelFormat::PVRTC4A:
internalFormat = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
format = 0xFFFFFFFF;
type = 0xFFFFFFFF;
@ -309,7 +294,7 @@ void UtilsGL::toGLTypes(TextureFormat textureFormat, GLint &internalFormat, GLui
break;
#endif
#ifdef GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
case TextureFormat::S3TC_DXT1:
case PixelFormat::S3TC_DXT1:
internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
format = 0xFFFFFFFF;
type = 0xFFFFFFFF;
@ -317,7 +302,7 @@ void UtilsGL::toGLTypes(TextureFormat textureFormat, GLint &internalFormat, GLui
break;
#endif
#ifdef GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
case TextureFormat::S3TC_DXT3:
case PixelFormat::S3TC_DXT3:
internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
format = 0xFFFFFFFF;
type = 0xFFFFFFFF;
@ -325,18 +310,18 @@ void UtilsGL::toGLTypes(TextureFormat textureFormat, GLint &internalFormat, GLui
break;
#endif
#ifdef GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
case TextureFormat::S3TC_DXT5:
case PixelFormat::S3TC_DXT5:
internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
format = 0xFFFFFFFF;
type = 0xFFFFFFFF;
isCompressed = true;
break;
#endif
// case TextureFormat::D16:
// case PixelFormat::D16:
// format = GL_DEPTH_COMPONENT;
// internalFormat = GL_DEPTH_COMPONENT;
// type = GL_UNSIGNED_INT;
case TextureFormat::D24S8:
case PixelFormat::D24S8:
#ifdef CC_USE_GLES
format = GL_DEPTH_STENCIL_OES;
internalFormat = GL_DEPTH_STENCIL_OES;

4
cocos/renderer/backend/opengl/UtilsGL.h
View File

@ -14,9 +14,9 @@ public:
static GLsizei getGLDataTypeSize(GLenum size);
static GLint toGLMagFilter(SamplerFilter magFilter);
static GLint toGLMinFilter(SamplerFilter minFilter, SamplerFilter mipmapFilter, bool mipmapEnabled, bool isPow2);
static GLint toGLMinFilter(SamplerFilter minFilter, bool hasMipmaps, bool isPow2);
static GLint toGLAddressMode(SamplerAddressMode addressMode, bool isPow2);
static void toGLTypes(TextureFormat textureFormat, GLint &internalFormat, GLuint &format, GLenum &type, bool &isCompressed);
static void toGLTypes(PixelFormat textureFormat, GLint &internalFormat, GLuint &format, GLenum &type, bool &isCompressed);
static GLenum toGLComareFunction(CompareFunction compareFunction);
static GLenum toGLStencilOperation(StencilOperation stencilOperation);

24
cocos/scripting/deprecated/CCDeprecated.h
View File

@ -873,19 +873,19 @@ CC_DEPRECATED_ATTRIBUTE const TextHAlignment kCCTextAlignmentLeft = TextHAlignme
CC_DEPRECATED_ATTRIBUTE const TextHAlignment kCCTextAlignmentCenter = TextHAlignment::CENTER;
CC_DEPRECATED_ATTRIBUTE const TextHAlignment kCCTextAlignmentRight = TextHAlignment::RIGHT;
CC_DEPRECATED_ATTRIBUTE const Texture2D::PixelFormat kCCTexture2DPixelFormat_RGBA8888 = Texture2D::PixelFormat::RGBA8888;
CC_DEPRECATED_ATTRIBUTE const Texture2D::PixelFormat kCCTexture2DPixelFormat_RGB888 = Texture2D::PixelFormat::RGB888;
CC_DEPRECATED_ATTRIBUTE const Texture2D::PixelFormat kCCTexture2DPixelFormat_RGB565 = Texture2D::PixelFormat::RGB565;
CC_DEPRECATED_ATTRIBUTE const Texture2D::PixelFormat kCCTexture2DPixelFormat_A8 = Texture2D::PixelFormat::A8;
CC_DEPRECATED_ATTRIBUTE const Texture2D::PixelFormat kCCTexture2DPixelFormat_I8 = Texture2D::PixelFormat::I8;
CC_DEPRECATED_ATTRIBUTE const Texture2D::PixelFormat kCCTexture2DPixelFormat_AI88 = Texture2D::PixelFormat::AI88;
CC_DEPRECATED_ATTRIBUTE const Texture2D::PixelFormat kCCTexture2DPixelFormat_RGBA4444 = Texture2D::PixelFormat::RGBA4444;
CC_DEPRECATED_ATTRIBUTE const Texture2D::PixelFormat kCCTexture2DPixelFormat_RGB5A1 = Texture2D::PixelFormat::RGB5A1;
CC_DEPRECATED_ATTRIBUTE const Texture2D::PixelFormat kCCTexture2DPixelFormat_PVRTC4 = Texture2D::PixelFormat::PVRTC4;
CC_DEPRECATED_ATTRIBUTE const Texture2D::PixelFormat kCCTexture2DPixelFormat_PVRTC2 = Texture2D::PixelFormat::PVRTC2;
CC_DEPRECATED_ATTRIBUTE const Texture2D::PixelFormat kCCTexture2DPixelFormat_Default = Texture2D::PixelFormat::DEFAULT;
CC_DEPRECATED_ATTRIBUTE const backend::PixelFormat kCCTexture2DPixelFormat_RGBA8888 = backend::PixelFormat::RGBA8888;
CC_DEPRECATED_ATTRIBUTE const backend::PixelFormat kCCTexture2DPixelFormat_RGB888 = backend::PixelFormat::RGB888;
CC_DEPRECATED_ATTRIBUTE const backend::PixelFormat kCCTexture2DPixelFormat_RGB565 = backend::PixelFormat::RGB565;
CC_DEPRECATED_ATTRIBUTE const backend::PixelFormat kCCTexture2DPixelFormat_A8 = backend::PixelFormat::A8;
CC_DEPRECATED_ATTRIBUTE const backend::PixelFormat kCCTexture2DPixelFormat_I8 = backend::PixelFormat::I8;
CC_DEPRECATED_ATTRIBUTE const backend::PixelFormat kCCTexture2DPixelFormat_AI88 = backend::PixelFormat::AI88;
CC_DEPRECATED_ATTRIBUTE const backend::PixelFormat kCCTexture2DPixelFormat_RGBA4444 = backend::PixelFormat::RGBA4444;
CC_DEPRECATED_ATTRIBUTE const backend::PixelFormat kCCTexture2DPixelFormat_RGB5A1 = backend::PixelFormat::RGB5A1;
CC_DEPRECATED_ATTRIBUTE const backend::PixelFormat kCCTexture2DPixelFormat_PVRTC4 = backend::PixelFormat::PVRTC4;
CC_DEPRECATED_ATTRIBUTE const backend::PixelFormat kCCTexture2DPixelFormat_PVRTC2 = backend::PixelFormat::PVRTC2;
CC_DEPRECATED_ATTRIBUTE const backend::PixelFormat kCCTexture2DPixelFormat_Default = backend::PixelFormat::DEFAULT;
CC_DEPRECATED_ATTRIBUTE typedef Texture2D::PixelFormat CCTexture2DPixelFormat;
CC_DEPRECATED_ATTRIBUTE typedef backend::PixelFormat CCTexture2DPixelFormat;
CC_DEPRECATED_ATTRIBUTE const int kCCParticleDurationInfinity = ParticleSystem::DURATION_INFINITY;

66
cocos/scripting/lua-bindings/auto/lua_cocos2dx_auto.cpp
View File

@ -762,7 +762,7 @@ int lua_cocos2dx_Texture2D_initWithImage(lua_State* tolua_S)
ok &= luaval_to_object<cocos2d::Image>(tolua_S, 2, "cc.Image",&arg0, "cc.Texture2D:initWithImage");
if (!ok) { break; }
cocos2d::Texture2D::PixelFormat arg1;
cocos2d::backend::PixelFormat arg1;
ok &= luaval_to_int32(tolua_S, 3,(int *)&arg1, "cc.Texture2D:initWithImage");
if (!ok) { break; }
@ -1005,7 +1005,7 @@ int lua_cocos2dx_Texture2D_getBitsPerPixelForFormat(lua_State* tolua_S)
argc = lua_gettop(tolua_S)-1;
do{
if (argc == 1) {
cocos2d::Texture2D::PixelFormat arg0;
cocos2d::backend::PixelFormat arg0;
ok &= luaval_to_int32(tolua_S, 2,(int *)&arg0, "cc.Texture2D:getBitsPerPixelForFormat");
if (!ok) { break; }
@ -1033,53 +1033,6 @@ int lua_cocos2dx_Texture2D_getBitsPerPixelForFormat(lua_State* tolua_S)
return 0;
}
int lua_cocos2dx_Texture2D_getName(lua_State* tolua_S)
{
int argc = 0;
cocos2d::Texture2D* cobj = nullptr;
bool ok = true;
#if COCOS2D_DEBUG >= 1
tolua_Error tolua_err;
#endif
#if COCOS2D_DEBUG >= 1
if (!tolua_isusertype(tolua_S,1,"cc.Texture2D",0,&tolua_err)) goto tolua_lerror;
#endif
cobj = (cocos2d::Texture2D*)tolua_tousertype(tolua_S,1,0);
#if COCOS2D_DEBUG >= 1
if (!cobj)
{
tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_Texture2D_getName'", nullptr);
return 0;
}
#endif
argc = lua_gettop(tolua_S)-1;
if (argc == 0)
{
if(!ok)
{
tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_Texture2D_getName'", nullptr);
return 0;
}
unsigned int ret = cobj->getName();
tolua_pushnumber(tolua_S,(lua_Number)ret);
return 1;
}
luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d \n", "cc.Texture2D:getName",argc, 0);
return 0;
#if COCOS2D_DEBUG >= 1
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_Texture2D_getName'.",&tolua_err);
#endif
return 0;
}
int lua_cocos2dx_Texture2D_initWithString(lua_State* tolua_S)
{
int argc = 0;
@ -1991,7 +1944,7 @@ int lua_cocos2dx_Texture2D_setDefaultAlphaPixelFormat(lua_State* tolua_S)
if (argc == 1)
{
cocos2d::Texture2D::PixelFormat arg0;
cocos2d::backend::PixelFormat arg0;
ok &= luaval_to_int32(tolua_S, 2,(int *)&arg0, "cc.Texture2D:setDefaultAlphaPixelFormat");
if(!ok)
{
@ -2103,7 +2056,6 @@ int lua_register_cocos2dx_Texture2D(lua_State* tolua_S)
tolua_function(tolua_S,"getPixelsHigh",lua_cocos2dx_Texture2D_getPixelsHigh);
tolua_function(tolua_S,"getAlphaTextureName",lua_cocos2dx_Texture2D_getAlphaTextureName);
tolua_function(tolua_S,"getBitsPerPixelForFormat",lua_cocos2dx_Texture2D_getBitsPerPixelForFormat);
tolua_function(tolua_S,"getName",lua_cocos2dx_Texture2D_getName);
tolua_function(tolua_S,"initWithString",lua_cocos2dx_Texture2D_initWithString);
tolua_function(tolua_S,"setMaxT",lua_cocos2dx_Texture2D_setMaxT);
tolua_function(tolua_S,"getPath",lua_cocos2dx_Texture2D_getPath);
@ -77406,11 +77358,11 @@ int lua_cocos2dx_RenderTexture_initWithWidthAndHeight(lua_State* tolua_S)
ok &= luaval_to_int32(tolua_S, 3,(int *)&arg1, "cc.RenderTexture:initWithWidthAndHeight");
if (!ok) { break; }
cocos2d::Texture2D::PixelFormat arg2;
cocos2d::backend::PixelFormat arg2;
ok &= luaval_to_int32(tolua_S, 4,(int *)&arg2, "cc.RenderTexture:initWithWidthAndHeight");
if (!ok) { break; }
cocos2d::backend::TextureFormat arg3;
cocos2d::backend::PixelFormat arg3;
ok &= luaval_to_int32(tolua_S, 5,(int *)&arg3, "cc.RenderTexture:initWithWidthAndHeight");
if (!ok) { break; }
@ -77430,7 +77382,7 @@ int lua_cocos2dx_RenderTexture_initWithWidthAndHeight(lua_State* tolua_S)
ok &= luaval_to_int32(tolua_S, 3,(int *)&arg1, "cc.RenderTexture:initWithWidthAndHeight");
if (!ok) { break; }
cocos2d::Texture2D::PixelFormat arg2;
cocos2d::backend::PixelFormat arg2;
ok &= luaval_to_int32(tolua_S, 4,(int *)&arg2, "cc.RenderTexture:initWithWidthAndHeight");
if (!ok) { break; }
@ -77474,7 +77426,7 @@ int lua_cocos2dx_RenderTexture_create(lua_State* tolua_S)
int arg1;
ok &= luaval_to_int32(tolua_S, 3,(int *)&arg1, "cc.RenderTexture:create");
if (!ok) { break; }
cocos2d::Texture2D::PixelFormat arg2;
cocos2d::backend::PixelFormat arg2;
ok &= luaval_to_int32(tolua_S, 4,(int *)&arg2, "cc.RenderTexture:create");
if (!ok) { break; }
cocos2d::RenderTexture* ret = cocos2d::RenderTexture::create(arg0, arg1, arg2);
@ -77493,10 +77445,10 @@ int lua_cocos2dx_RenderTexture_create(lua_State* tolua_S)
int arg1;
ok &= luaval_to_int32(tolua_S, 3,(int *)&arg1, "cc.RenderTexture:create");
if (!ok) { break; }
cocos2d::Texture2D::PixelFormat arg2;
cocos2d::backend::PixelFormat arg2;
ok &= luaval_to_int32(tolua_S, 4,(int *)&arg2, "cc.RenderTexture:create");
if (!ok) { break; }
cocos2d::backend::TextureFormat arg3;
cocos2d::backend::PixelFormat arg3;
ok &= luaval_to_int32(tolua_S, 5,(int *)&arg3, "cc.RenderTexture:create");
if (!ok) { break; }
cocos2d::RenderTexture* ret = cocos2d::RenderTexture::create(arg0, arg1, arg2, arg3);

10
cocos/scripting/lua-bindings/auto/lua_cocos2dx_backend_auto.cpp
View File

@ -75,8 +75,8 @@ int lua_register_cocos2dx_backend_VertexFormat(lua_State* tolua_S)
int lua_register_cocos2dx_backend_TextureFormat(lua_State* tolua_S)
{
tolua_module(tolua_S, "TextureFormat", 0);
tolua_beginmodule(tolua_S,"TextureFormat");
tolua_module(tolua_S, "PixelFormat", 0);
tolua_beginmodule(tolua_S,"PixelFormat");
tolua_constant(tolua_S, "NONE", 0);
tolua_constant(tolua_S, "R8G8B8A8", 1);
tolua_constant(tolua_S, "R8G8B8", 2);
@ -103,9 +103,9 @@ int lua_register_cocos2dx_backend_TextureFormat(lua_State* tolua_S)
tolua_constant(tolua_S, "S3TC_DXT5", 23);
tolua_constant(tolua_S, "SYSTEM_DEFAULT", 24);
tolua_endmodule(tolua_S);
std::string typeName = typeid(cocos2d::backend::TextureFormat).name();
g_luaType[typeName] = "ccb.TextureFormat";
g_typeCast["TextureFormat"] = "ccb.TextureFormat";
std::string typeName = typeid(cocos2d::backend::PixelFormat).name();
g_luaType[typeName] = "ccb.PixelFormat";
g_typeCast["PixelFormat"] = "ccb.PixelFormat";
return 1;
}

21
cocos/scripting/lua-bindings/manual/LuaBasicConversions.cpp
View File

@ -3205,12 +3205,6 @@ void texParams_to_luaval(lua_State* L, const cocos2d::Texture2D::TexParams& inVa
lua_pushstring(L, "sAddressMode"); /* L: table key */
lua_pushnumber(L, (lua_Number) inValue.tAddressMode); /* L: table key value*/
lua_rawset(L, -3);
lua_pushstring(L, "mipmapFilter");
lua_pushnumber(L, (lua_Number)inValue.mipmapFilter);
lua_rawset(L, -3);
lua_pushstring(L, "mipmapEnabled");
lua_pushboolean(L, inValue.mipmapEnabled);
lua_rawset(L, -3);
}
void std_vector_vec3_to_luaval(lua_State* L, const std::vector<cocos2d::Vec3>& inValue)
@ -3334,14 +3328,6 @@ bool luaval_to_samplerDescriptor(lua_State* L, int pos, cocos2d::backend::Sample
}
lua_pop(L, 1);
lua_pushstring(L, "mipmapFilter");
lua_gettable(L, pos);
if (!lua_isnil(L, -1))
{
output.mipmapFilter = static_cast<cocos2d::backend::SamplerFilter>(lua_tointeger(L, -1));
}
lua_pop(L, 1);
lua_pushstring(L, "sAddressMode");
lua_gettable(L, pos);
if (!lua_isnil(L, -1))
@ -3358,13 +3344,6 @@ bool luaval_to_samplerDescriptor(lua_State* L, int pos, cocos2d::backend::Sample
}
lua_pop(L, 1);
lua_pushstring(L, "mipmapEnabled");
lua_gettable(L, pos);
if (!lua_isnil(L, -1))
{
output.mipmapEnabled = lua_toboolean(L, -1);
}
lua_pop(L, 1);
return true;
}

2
tests/cpp-tests/Classes/ClippingNodeTest/ClippingNodeTest.cpp
View File

@ -963,7 +963,7 @@ void ClippingToRenderTextureTest::reproduceBug()
// container rendered on Texture the size of the screen and because Clipping node use stencil buffer so we need to
// create RenderTexture with depthStencil format parameter
RenderTexture* rt = RenderTexture::create(visibleSize.width, visibleSize.height, Texture2D::PixelFormat::RGBA8888, TextureFormat::D24S8);
RenderTexture* rt = RenderTexture::create(visibleSize.width, visibleSize.height, backend::PixelFormat::RGBA8888, PixelFormat::D24S8);
rt->setPosition(visibleSize.width/2, visibleSize.height/2);
this->addChild(rt);

18
tests/cpp-tests/Classes/RenderTextureTest/RenderTextureTest.cpp
View File

@ -49,7 +49,7 @@ RenderTextureSave::RenderTextureSave()
auto s = Director::getInstance()->getWinSize();
// create a render texture, this is what we are going to draw into
_target = RenderTexture::create(s.width, s.height, Texture2D::PixelFormat::RGBA8888);
_target = RenderTexture::create(s.width, s.height, backend::PixelFormat::RGBA8888);
_target->retain();
_target->setPosition(Vec2(s.width / 2, s.height / 2));
@ -191,7 +191,7 @@ RenderTextureIssue937::RenderTextureIssue937()
spr_nonpremulti->setPosition(Vec2(s.width/2-16, s.height/2-16));
/* A2 & B2 setup */
auto rend = RenderTexture::create(32, 64, Texture2D::PixelFormat::RGBA8888);
auto rend = RenderTexture::create(32, 64, backend::PixelFormat::RGBA8888);
if (nullptr == rend)
{
@ -393,7 +393,7 @@ RenderTexturePartTest::RenderTexturePartTest()
addChild(sprite2);
addChild(sprite22);
_rend = RenderTexture::create(200, 200, Texture2D::PixelFormat::RGBA8888);
_rend = RenderTexture::create(200, 200, backend::PixelFormat::RGBA8888);
_rend->retain();
_rend->setKeepMatrix(true);
Size pixelSize = Director::getInstance()->getWinSizeInPixels();
@ -448,7 +448,7 @@ RenderTextureTestDepthStencil::RenderTextureTestDepthStencil()
//! move sprite half width and height, and draw only where not marked
_spriteDraw->setPosition(_spriteDraw->getPosition() + Vec2(_spriteDraw->getContentSize().width * _spriteDraw->getScale() * 0.5, _spriteDraw->getContentSize().height * _spriteDraw->getScale() * 0.5));
_rend = RenderTexture::create(s.width, s.height, Texture2D::PixelFormat::RGBA4444, TextureFormat::D24S8);
_rend = RenderTexture::create(s.width, s.height, backend::PixelFormat::RGBA4444, PixelFormat::D24S8);
_rend->setPosition(Vec2(s.width * 0.5f, s.height * 0.5f));
@ -549,7 +549,7 @@ RenderTextureTargetNode::RenderTextureTargetNode()
auto s = Director::getInstance()->getWinSize();
/* Create the render texture */
auto renderTexture = RenderTexture::create(s.width, s.height, Texture2D::PixelFormat::RGBA4444);
auto renderTexture = RenderTexture::create(s.width, s.height, backend::PixelFormat::RGBA4444);
this->renderTexture = renderTexture;
renderTexture->setPosition(Vec2(s.width/2, s.height/2));
@ -638,7 +638,7 @@ void SpriteRenderTextureBug::SimpleSprite::draw(Renderer *renderer, const Mat4 &
if (_rt == nullptr)
{
auto s = Director::getInstance()->getWinSize();
_rt = RenderTexture::create(s.width, s.height, Texture2D::PixelFormat::RGBA8888);
_rt = RenderTexture::create(s.width, s.height, backend::PixelFormat::RGBA8888);
_rt->retain();
}
_rt->beginWithClear(0.0f, 0.0f, 0.0f, 1.0f);
@ -726,7 +726,7 @@ Issue16113Test::Issue16113Test()
auto winSize = Director::getInstance()->getVisibleSize();
auto text = Label::createWithTTF("hello world", "fonts/Marker Felt.ttf", 40);
text->setTextColor(Color4B::RED);
auto target = RenderTexture::create(winSize.width, winSize.height, Texture2D::PixelFormat::RGBA8888);
auto target = RenderTexture::create(winSize.width, winSize.height, backend::PixelFormat::RGBA8888);
target->beginWithClear(0,0,0,0);
text->setPosition(winSize.width / 2,winSize.height/2);
text->Node::visit();
@ -783,12 +783,12 @@ RenderTextureWithSprite3DIssue16894::RenderTextureWithSprite3DIssue16894()
// }
// // RenderTextures
// _renderTexDefault = RenderTexture::create(visibleSize.width, visibleSize.height, Texture2D::PixelFormat::RGBA8888);
// _renderTexDefault = RenderTexture::create(visibleSize.width, visibleSize.height, backend::PixelFormat::RGBA8888);
// _renderTexDefault->setKeepMatrix(true);
// addChild(_renderTexDefault);
// _renderTexDefault->setPosition(visibleSize.width/4 * 3, visibleSize.height/2);
// _renderTexWithBuffer = RenderTexture::create(visibleSize.width, visibleSize.height, Texture2D::PixelFormat::RGBA8888, GL_DEPTH24_STENCIL8);
// _renderTexWithBuffer = RenderTexture::create(visibleSize.width, visibleSize.height, backend::PixelFormat::RGBA8888, GL_DEPTH24_STENCIL8);
// _renderTexWithBuffer->setKeepMatrix(true);
// addChild(_renderTexWithBuffer);
// _renderTexWithBuffer->setPosition(visibleSize.width/4 * 4, visibleSize.height/2);

44
tests/cpp-tests/Classes/SpriteFrameCacheTest/SpriteFrameCacheTest.cpp
View File

@ -51,30 +51,30 @@ SpriteFrameCachePixelFormatTest::SpriteFrameCachePixelFormatTest()
addChild(infoLabel);
// load atlas definition with specified PixelFormat and check that it matches to expected format
loadSpriteFrames("Images/sprite_frames_test/test_A8.plist", Texture2D::PixelFormat::A8);
loadSpriteFrames("Images/sprite_frames_test/test_RGBA8888.plist", Texture2D::PixelFormat::RGBA8888);
loadSpriteFrames("Images/sprite_frames_test/test_AI88.plist", Texture2D::PixelFormat::AI88);
loadSpriteFrames("Images/sprite_frames_test/test_RGBA8888.plist", Texture2D::PixelFormat::RGBA8888);
loadSpriteFrames("Images/sprite_frames_test/test_RGB565.plist", Texture2D::PixelFormat::RGB565);
loadSpriteFrames("Images/sprite_frames_test/test_RGB888.plist", Texture2D::PixelFormat::RGB888);
loadSpriteFrames("Images/sprite_frames_test/test_RGBA4444.plist", Texture2D::PixelFormat::RGBA4444);
loadSpriteFrames("Images/sprite_frames_test/test_RGBA5551.plist", Texture2D::PixelFormat::RGB5A1);
loadSpriteFrames("Images/sprite_frames_test/test_A8.plist", backend::PixelFormat::A8);
loadSpriteFrames("Images/sprite_frames_test/test_RGBA8888.plist", backend::PixelFormat::RGBA8888);
loadSpriteFrames("Images/sprite_frames_test/test_AI88.plist", backend::PixelFormat::AI88);
loadSpriteFrames("Images/sprite_frames_test/test_RGBA8888.plist", backend::PixelFormat::RGBA8888);
loadSpriteFrames("Images/sprite_frames_test/test_RGB565.plist", backend::PixelFormat::RGB565);
loadSpriteFrames("Images/sprite_frames_test/test_RGB888.plist", backend::PixelFormat::RGB888);
loadSpriteFrames("Images/sprite_frames_test/test_RGBA4444.plist", backend::PixelFormat::RGBA4444);
loadSpriteFrames("Images/sprite_frames_test/test_RGBA5551.plist", backend::PixelFormat::RGB5A1);
if (Configuration::getInstance()->supportsPVRTC()) {
loadSpriteFrames("Images/sprite_frames_test/test_PVRTC2.plist", Texture2D::PixelFormat::PVRTC2A);
loadSpriteFrames("Images/sprite_frames_test/test_PVRTC4.plist", Texture2D::PixelFormat::PVRTC4A);
loadSpriteFrames("Images/sprite_frames_test/test_PVRTC2_NOALPHA.plist", Texture2D::PixelFormat::PVRTC2);
loadSpriteFrames("Images/sprite_frames_test/test_PVRTC2.plist", backend::PixelFormat::PVRTC2A);
loadSpriteFrames("Images/sprite_frames_test/test_PVRTC4.plist", backend::PixelFormat::PVRTC4A);
loadSpriteFrames("Images/sprite_frames_test/test_PVRTC2_NOALPHA.plist", backend::PixelFormat::PVRTC2);
}
// test loading atlases without PixelFormat specified
Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::RGB5A1);
loadSpriteFrames("Images/sprite_frames_test/test_NoFormat.plist", Texture2D::PixelFormat::RGB5A1);
Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat::RGB5A1);
loadSpriteFrames("Images/sprite_frames_test/test_NoFormat.plist", backend::PixelFormat::RGB5A1);
// restore default alpha pixel format
Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::RGBA8888);
Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat::RGBA8888);
}
void SpriteFrameCachePixelFormatTest::loadSpriteFrames(const std::string &file, cocos2d::Texture2D::PixelFormat expectedFormat)
void SpriteFrameCachePixelFormatTest::loadSpriteFrames(const std::string &file, cocos2d::backend::PixelFormat expectedFormat)
{
SpriteFrameCache::getInstance()->addSpriteFramesWithFile(file);
SpriteFrame *spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName("grossini.png");
@ -97,14 +97,14 @@ SpriteFrameCacheLoadMultipleTimes::SpriteFrameCacheLoadMultipleTimes()
const Size screenSize = Director::getInstance()->getWinSize();
// load atlas definition with specified PixelFormat and check that it matches to expected format
loadSpriteFrames("Images/sprite_frames_test/test_RGBA8888.plist", Texture2D::PixelFormat::RGBA8888);
loadSpriteFrames("Images/sprite_frames_test/test_RGBA8888.plist", Texture2D::PixelFormat::RGBA8888);
loadSpriteFrames("Images/sprite_frames_test/test_RGBA8888.plist", Texture2D::PixelFormat::RGBA8888);
loadSpriteFrames("Images/sprite_frames_test/test_RGBA8888.plist", Texture2D::PixelFormat::RGBA8888);
loadSpriteFrames("Images/sprite_frames_test/test_RGBA8888.plist", backend::PixelFormat::RGBA8888);
loadSpriteFrames("Images/sprite_frames_test/test_RGBA8888.plist", backend::PixelFormat::RGBA8888);
loadSpriteFrames("Images/sprite_frames_test/test_RGBA8888.plist", backend::PixelFormat::RGBA8888);
loadSpriteFrames("Images/sprite_frames_test/test_RGBA8888.plist", backend::PixelFormat::RGBA8888);
}
void SpriteFrameCacheLoadMultipleTimes::loadSpriteFrames(const std::string &file, cocos2d::Texture2D::PixelFormat expectedFormat)
void SpriteFrameCacheLoadMultipleTimes::loadSpriteFrames(const std::string &file, cocos2d::backend::PixelFormat expectedFormat)
{
SpriteFrameCache::getInstance()->addSpriteFramesWithFile(file);
SpriteFrame *spriteFrame = SpriteFrameCache::getInstance()->getSpriteFrameByName("grossini.png");
@ -120,10 +120,10 @@ SpriteFrameCacheFullCheck::SpriteFrameCacheFullCheck()
{
const Size screenSize = Director::getInstance()->getWinSize();
// load atlas definition with specified PixelFormat and check that it matches to expected format
loadSpriteFrames("Images/test_polygon.plist", Texture2D::PixelFormat::RGBA8888);
loadSpriteFrames("Images/test_polygon.plist", backend::PixelFormat::RGBA8888);
}
void SpriteFrameCacheFullCheck::loadSpriteFrames(const std::string &file, cocos2d::Texture2D::PixelFormat expectedFormat)
void SpriteFrameCacheFullCheck::loadSpriteFrames(const std::string &file, cocos2d::backend::PixelFormat expectedFormat)
{
auto cache = SpriteFrameCache::getInstance();

6
tests/cpp-tests/Classes/SpriteFrameCacheTest/SpriteFrameCacheTest.h
View File

@ -41,7 +41,7 @@ public:
SpriteFrameCachePixelFormatTest();
private:
void loadSpriteFrames(const std::string &file, cocos2d::Texture2D::PixelFormat expectedFormat);
void loadSpriteFrames(const std::string &file, cocos2d::backend::PixelFormat expectedFormat);
private:
cocos2d::Label *infoLabel;
@ -58,7 +58,7 @@ public:
SpriteFrameCacheLoadMultipleTimes();
private:
void loadSpriteFrames(const std::string &file, cocos2d::Texture2D::PixelFormat expectedFormat);
void loadSpriteFrames(const std::string &file, cocos2d::backend::PixelFormat expectedFormat);
};
@ -74,6 +74,6 @@ public:
SpriteFrameCacheFullCheck();
private:
void loadSpriteFrames(const std::string &file, cocos2d::Texture2D::PixelFormat expectedFormat);
void loadSpriteFrames(const std::string &file, cocos2d::backend::PixelFormat expectedFormat);
};

119
tests/cpp-tests/Classes/Texture2dTest/Texture2dTest.cpp
View File

@ -304,10 +304,13 @@ void TextureMipMap::onEnter()
auto s = Director::getInstance()->getWinSize();
auto texture0 = Director::getInstance()->getTextureCache()->addImage("Images/grossini_dance_atlas.png");
//TODO: minggo
// texture0->generateMipmap();
// Texture2D::TexParams texParams = { GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE };
// texture0->setSamplerDescriptor(texParams);
texture0->generateMipmap();
Texture2D::TexParams texParams = {
backend::SamplerFilter::LINEAR_MIPMAP_LINEAR,
backend::SamplerFilter::LINEAR,
backend::SamplerAddressMode::CLAMP_TO_EDGE,
backend::SamplerAddressMode::CLAMP_TO_EDGE };
texture0->setTexParameters(texParams);
auto texture1 = Director::getInstance()->getTextureCache()->addImage("Images/grossini_dance_atlas_nomipmap.png");
@ -362,9 +365,12 @@ void TexturePVRMipMap::onEnter()
addChild(imgMipMap);
// support mipmap filtering
//TODO minggo
// Texture2D::TexParams texParams = { GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE };
// imgMipMap->getTexture()->setSamplerDescriptor(texParams);
Texture2D::TexParams texParams = {
backend::SamplerFilter::LINEAR_MIPMAP_LINEAR,
backend::SamplerFilter::LINEAR,
backend::SamplerAddressMode::CLAMP_TO_EDGE,
backend::SamplerAddressMode::CLAMP_TO_EDGE };
imgMipMap->getTexture()->setTexParameters(texParams);
}
auto img = Sprite::create("Images/logo-nomipmap.pvr");
@ -409,9 +415,12 @@ void TexturePVRMipMap2::onEnter()
addChild(imgMipMap);
// support mipmap filtering
//TODO minggo
// Texture2D::TexParams texParams = { GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE };
// imgMipMap->getTexture()->setSamplerDescriptor(texParams);
Texture2D::TexParams texParams = {
backend::SamplerFilter::LINEAR_MIPMAP_LINEAR,
backend::SamplerFilter::LINEAR,
backend::SamplerAddressMode::CLAMP_TO_EDGE,
backend::SamplerAddressMode::CLAMP_TO_EDGE };
imgMipMap->getTexture()->setTexParameters(texParams);
auto img = Sprite::create("Images/test_image.png");
img->setPosition(Vec2( s.width/2.0f+100, s.height/2.0f));
@ -1360,7 +1369,7 @@ void TexturePixelFormat::onEnter()
addChild(background, -1);
// RGBA 8888 image (32-bit)
Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::RGBA8888);
Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat::RGBA8888);
auto sprite1 = Sprite::create("Images/test-rgba1.png");
sprite1->setPosition(Vec2(1*s.width/7, s.height/2+32));
addChild(sprite1, 0);
@ -1369,7 +1378,7 @@ void TexturePixelFormat::onEnter()
Director::getInstance()->getTextureCache()->removeTexture(sprite1->getTexture());
// RGBA 4444 image (16-bit)
Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::RGBA4444);
Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat::RGBA4444);
auto sprite2 = Sprite::create("Images/test-rgba1.png");
sprite2->setPosition(Vec2(2*s.width/7, s.height/2-32));
addChild(sprite2, 0);
@ -1378,7 +1387,7 @@ void TexturePixelFormat::onEnter()
Director::getInstance()->getTextureCache()->removeTexture(sprite2->getTexture());
// RGB5A1 image (16-bit)
Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::RGB5A1);
Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat::RGB5A1);
auto sprite3 = Sprite::create("Images/test-rgba1.png");
sprite3->setPosition(Vec2(3*s.width/7, s.height/2+32));
addChild(sprite3, 0);
@ -1387,7 +1396,7 @@ void TexturePixelFormat::onEnter()
Director::getInstance()->getTextureCache()->removeTexture(sprite3->getTexture());
// RGB888 image
Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::RGB888);
Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat::RGB888);
auto sprite4 = Sprite::create("Images/test-rgba1.png");
sprite4->setPosition(Vec2(4*s.width/7, s.height/2-32));
addChild(sprite4, 0);
@ -1396,7 +1405,7 @@ void TexturePixelFormat::onEnter()
Director::getInstance()->getTextureCache()->removeTexture(sprite4->getTexture());
// RGB565 image (16-bit)
Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::RGB565);
Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat::RGB565);
auto sprite5 = Sprite::create("Images/test-rgba1.png");
sprite5->setPosition(Vec2(5*s.width/7, s.height/2+32));
addChild(sprite5, 0);
@ -1405,7 +1414,7 @@ void TexturePixelFormat::onEnter()
Director::getInstance()->getTextureCache()->removeTexture(sprite5->getTexture());
// A8 image (8-bit)
Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::A8);
Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat::A8);
auto sprite6 = Sprite::create("Images/test-rgba1.png");
sprite6->setPosition(Vec2(6*s.width/7, s.height/2-32));
addChild(sprite6, 0);
@ -1429,7 +1438,7 @@ void TexturePixelFormat::onEnter()
sprite5->runAction(seq_4ever5);
// restore default
Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::DEFAULT);
Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat::DEFAULT);
log("%s\n", Director::getInstance()->getTextureCache()->getCachedTextureInfo().c_str());
}
@ -1987,7 +1996,7 @@ TexturePVRv3Premult::TexturePVRv3Premult()
transformSprite(pvr2);
// PNG
Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::RGBA8888);
Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat::RGBA8888);
Director::getInstance()->getTextureCache()->removeTextureForKey("Images/grossinis_sister1-testalpha.png");
auto png = Sprite::create("Images/grossinis_sister1-testalpha.png");
addChild(png, 0);
@ -2195,7 +2204,7 @@ std::string TextureATITCInterpolated::subtitle() const
return "ATITC RGBA Interpolated Alpha compressed texture test";
}
static void addImageToDemo(TextureDemo& demo, float x, float y, const char* path, Texture2D::PixelFormat format)
static void addImageToDemo(TextureDemo& demo, float x, float y, const char* path, backend::PixelFormat format)
{
Texture2D::setDefaultAlphaPixelFormat(format);
auto sprite = Sprite::create(path);
@ -2217,17 +2226,17 @@ void TextureConvertRGB888::onEnter()
addChild(background, -1);
const char* img = "Images/test_image_rgb888.png";
addImageToDemo(*this, 1*s.width/9, s.height/2+32, img, Texture2D::PixelFormat::RGBA8888);
addImageToDemo(*this, 2*s.width/9, s.height/2-32, img, Texture2D::PixelFormat::RGB888);
addImageToDemo(*this, 3*s.width/9, s.height/2+32, img, Texture2D::PixelFormat::RGB565);
addImageToDemo(*this, 4*s.width/9, s.height/2-32, img, Texture2D::PixelFormat::A8);
addImageToDemo(*this, 5*s.width/9, s.height/2+32, img, Texture2D::PixelFormat::I8);
addImageToDemo(*this, 6*s.width/9, s.height/2-32, img, Texture2D::PixelFormat::AI88);
addImageToDemo(*this, 7*s.width/9, s.height/2+32, img, Texture2D::PixelFormat::RGBA4444);
addImageToDemo(*this, 8*s.width/9, s.height/2-32, img, Texture2D::PixelFormat::RGB5A1);
addImageToDemo(*this, 1*s.width/9, s.height/2+32, img, backend::PixelFormat::RGBA8888);
addImageToDemo(*this, 2*s.width/9, s.height/2-32, img, backend::PixelFormat::RGB888);
addImageToDemo(*this, 3*s.width/9, s.height/2+32, img, backend::PixelFormat::RGB565);
addImageToDemo(*this, 4*s.width/9, s.height/2-32, img, backend::PixelFormat::A8);
addImageToDemo(*this, 5*s.width/9, s.height/2+32, img, backend::PixelFormat::I8);
addImageToDemo(*this, 6*s.width/9, s.height/2-32, img, backend::PixelFormat::AI88);
addImageToDemo(*this, 7*s.width/9, s.height/2+32, img, backend::PixelFormat::RGBA4444);
addImageToDemo(*this, 8*s.width/9, s.height/2-32, img, backend::PixelFormat::RGB5A1);
// restore default
Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::DEFAULT);
Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat::DEFAULT);
log("%s\n", Director::getInstance()->getTextureCache()->getCachedTextureInfo().c_str());
}
@ -2251,17 +2260,17 @@ void TextureConvertRGBA8888::onEnter()
addChild(background, -1);
const char* img = "Images/test_image_rgba8888.png";
addImageToDemo(*this, 1*s.width/9, s.height/2+32, img, Texture2D::PixelFormat::RGBA8888);
addImageToDemo(*this, 2*s.width/9, s.height/2-32, img, Texture2D::PixelFormat::RGB888);
addImageToDemo(*this, 3*s.width/9, s.height/2+32, img, Texture2D::PixelFormat::RGB565);
addImageToDemo(*this, 4*s.width/9, s.height/2-32, img, Texture2D::PixelFormat::A8);
addImageToDemo(*this, 5*s.width/9, s.height/2+32, img, Texture2D::PixelFormat::I8);
addImageToDemo(*this, 6*s.width/9, s.height/2-32, img, Texture2D::PixelFormat::AI88);
addImageToDemo(*this, 7*s.width/9, s.height/2+32, img, Texture2D::PixelFormat::RGBA4444);
addImageToDemo(*this, 8*s.width/9, s.height/2-32, img, Texture2D::PixelFormat::RGB5A1);
addImageToDemo(*this, 1*s.width/9, s.height/2+32, img, backend::PixelFormat::RGBA8888);
addImageToDemo(*this, 2*s.width/9, s.height/2-32, img, backend::PixelFormat::RGB888);
addImageToDemo(*this, 3*s.width/9, s.height/2+32, img, backend::PixelFormat::RGB565);
addImageToDemo(*this, 4*s.width/9, s.height/2-32, img, backend::PixelFormat::A8);
addImageToDemo(*this, 5*s.width/9, s.height/2+32, img, backend::PixelFormat::I8);
addImageToDemo(*this, 6*s.width/9, s.height/2-32, img, backend::PixelFormat::AI88);
addImageToDemo(*this, 7*s.width/9, s.height/2+32, img, backend::PixelFormat::RGBA4444);
addImageToDemo(*this, 8*s.width/9, s.height/2-32, img, backend::PixelFormat::RGB5A1);
// restore default
Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::DEFAULT);
Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat::DEFAULT);
log("%s\n", Director::getInstance()->getTextureCache()->getCachedTextureInfo().c_str());
}
@ -2285,17 +2294,17 @@ void TextureConvertI8::onEnter()
addChild(background, -1);
const char* img = "Images/test_image_i8.png";
addImageToDemo(*this, 1*s.width/9, s.height/2+32, img, Texture2D::PixelFormat::RGBA8888);
addImageToDemo(*this, 2*s.width/9, s.height/2-32, img, Texture2D::PixelFormat::RGB888);
addImageToDemo(*this, 3*s.width/9, s.height/2+32, img, Texture2D::PixelFormat::RGB565);
addImageToDemo(*this, 4*s.width/9, s.height/2-32, img, Texture2D::PixelFormat::A8);
addImageToDemo(*this, 5*s.width/9, s.height/2+32, img, Texture2D::PixelFormat::I8);
addImageToDemo(*this, 6*s.width/9, s.height/2-32, img, Texture2D::PixelFormat::AI88);
addImageToDemo(*this, 7*s.width/9, s.height/2+32, img, Texture2D::PixelFormat::RGBA4444);
addImageToDemo(*this, 8*s.width/9, s.height/2-32, img, Texture2D::PixelFormat::RGB5A1);
addImageToDemo(*this, 1*s.width/9, s.height/2+32, img, backend::PixelFormat::RGBA8888);
addImageToDemo(*this, 2*s.width/9, s.height/2-32, img, backend::PixelFormat::RGB888);
addImageToDemo(*this, 3*s.width/9, s.height/2+32, img, backend::PixelFormat::RGB565);
addImageToDemo(*this, 4*s.width/9, s.height/2-32, img, backend::PixelFormat::A8);
addImageToDemo(*this, 5*s.width/9, s.height/2+32, img, backend::PixelFormat::I8);
addImageToDemo(*this, 6*s.width/9, s.height/2-32, img, backend::PixelFormat::AI88);
addImageToDemo(*this, 7*s.width/9, s.height/2+32, img, backend::PixelFormat::RGBA4444);
addImageToDemo(*this, 8*s.width/9, s.height/2-32, img, backend::PixelFormat::RGB5A1);
// restore default
Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::DEFAULT);
Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat::DEFAULT);
log("%s\n", Director::getInstance()->getTextureCache()->getCachedTextureInfo().c_str());
}
@ -2319,17 +2328,17 @@ void TextureConvertAI88::onEnter()
addChild(background, -1);
const char* img = "Images/test_image_ai88.png";
addImageToDemo(*this, 1*s.width/9, s.height/2+32, img, Texture2D::PixelFormat::RGBA8888);
addImageToDemo(*this, 2*s.width/9, s.height/2-32, img, Texture2D::PixelFormat::RGB888);
addImageToDemo(*this, 3*s.width/9, s.height/2+32, img, Texture2D::PixelFormat::RGB565);
addImageToDemo(*this, 4*s.width/9, s.height/2-32, img, Texture2D::PixelFormat::A8);
addImageToDemo(*this, 5*s.width/9, s.height/2+32, img, Texture2D::PixelFormat::I8);
addImageToDemo(*this, 6*s.width/9, s.height/2-32, img, Texture2D::PixelFormat::AI88);
addImageToDemo(*this, 7*s.width/9, s.height/2+32, img, Texture2D::PixelFormat::RGBA4444);
addImageToDemo(*this, 8*s.width/9, s.height/2-32, img, Texture2D::PixelFormat::RGB5A1);
addImageToDemo(*this, 1*s.width/9, s.height/2+32, img, backend::PixelFormat::RGBA8888);
addImageToDemo(*this, 2*s.width/9, s.height/2-32, img, backend::PixelFormat::RGB888);
addImageToDemo(*this, 3*s.width/9, s.height/2+32, img, backend::PixelFormat::RGB565);
addImageToDemo(*this, 4*s.width/9, s.height/2-32, img, backend::PixelFormat::A8);
addImageToDemo(*this, 5*s.width/9, s.height/2+32, img, backend::PixelFormat::I8);
addImageToDemo(*this, 6*s.width/9, s.height/2-32, img, backend::PixelFormat::AI88);
addImageToDemo(*this, 7*s.width/9, s.height/2+32, img, backend::PixelFormat::RGBA4444);
addImageToDemo(*this, 8*s.width/9, s.height/2-32, img, backend::PixelFormat::RGB5A1);
// restore default
Texture2D::setDefaultAlphaPixelFormat(Texture2D::PixelFormat::DEFAULT);
Texture2D::setDefaultAlphaPixelFormat(backend::PixelFormat::DEFAULT);
log("%s\n", Director::getInstance()->getTextureCache()->getCachedTextureInfo().c_str());
}