Inheritance diagram for Chesto::Texture:

Collaboration diagram for Chesto::Texture:

Public Member Functions
void	clear (void)
	Reinitialize Texture Resets texture content, size and color. More...

bool	loadFromSurface (CST_Surface *surface)
	Loads the texture from a surface Returns true if successful. More...

bool	loadFromCache (std::string &key)
	Loads the texture from caches Returns true if successful. More...

bool	loadFromSurfaceSaveToCache (std::string &key, CST_Surface *surface)
	Loads the texture from a surface and saves the results in caches Returns true if successful. More...

void	render (Element *parent)
	Renders the texture. More...

void	resize (int w, int h)
	Resizes the texture. More...

void	setScaleMode (TextureScaleMode mode)
	Sets texture scaling mode. More...

void	getTextureSize (int w, int h)
	Return texture's original size. More...

Texture *	setSize (int w, int h)

bool	saveTo (std::string &path)
	save this texture to the given file path as a PNG More...

void	loadPath (std::string &path, bool forceReload=false)
	update and load or reload the texture More...

Public Member Functions inherited from Chesto::Element
virtual bool	process (InputEvents *event)
	process any input that is received for this element More...

virtual void	render (Element *parent)
	display the current state of the display More...

bool	onTouchDown (InputEvents *event)

bool	onTouchDrag (InputEvents *event)

bool	onTouchUp (InputEvents *event)

void	hide ()

void	unhide ()

void	renderBackground (bool fill=true)

void	addNode (std::unique_ptr< Element > node)

void	remove (Element *element)

void	removeAll ()

void	position (int x, int y)
	position the element More...

void	recalcPosition (Element *parent)

float	getEffectiveScale () const

CST_Rect	getBounds ()

CST_Renderer *	getRenderer ()

Element *	setPosition (int x, int y)

Element *	setAction (std::function< void()> func)

Element *	setAbsolute (bool isAbs)

template<typename T , typename... Args>
T *	createNode (Args &&... args)

Element *	constrain (int flags, int padding=0)

Element *	constrainToTarget (Element *target, int flags, int padding=0)

Element *	animate (int durationIn, std::function< void(float)> onStep, std::function< void()> onFinish)

Element *	moveToFront ()

Element *	setTouchable (bool touchable)

void	screenshot (std::string path)
	Take a screenshot of this element and its children, and save it to the given path. More...

Static Public Member Functions
static void	wipeEntireCache ()
	Wipes the entire texture cache (generally, should only be used to reload entire theme / text) More...

static void	wipeTextCache ()
	Similar to wipeEntireCache, but only wipes cached text textures (made by TextElement) More...

Public Attributes
int	cornerRadius = 0
	Rounded corner radius (if >0, will round) More...

SDL_BlendMode	blendMode = SDL_BLENDMODE_BLEND
	Blend mode to use for this texture. More...

Public Attributes inherited from Chesto::Element
std::function< void()>	action = NULL
	the action to call (from binded callback) on touch or button selection https://stackoverflow.com/questions/14189440/c-class-member-callback-simple-examples More...

std::function< void(InputEvents *event)>	actionWithEvents = NULL

std::vector< std::unique_ptr< Element, std::function< void(Element *)> > >	elements
	visible GUI child elements of this element More...

float	scale = 1.0f

bool	touchable = false
	whether or not this element can be touched (highlights bounds) More...

bool	dragging = false
	whether or not this element is currently being dragged More...

bool	needsRedraw = false
	whether or not this element needs the screen redrawn next time it's processed More...

int	futureRedrawCounter = 0
	whether this element needs a redraw for the next X redraws (decreases each time) (0 is no redraws) More...

int	lastMouseY = 0
	the last Y, X coordinate of the mouse (from a drag probably) More...

int	lastMouseX = 0

bool	hasBackground = false

rgb	backgroundColor = {0, 0, 0}

int	backgroundOpacity = 0xff

bool	isAbsolute = false

Element *	parent = nullptr
	the parent element (reference only, not owned) More...

bool	hidden = false
	whether this element should skip rendering or not More...

bool	isProtected = false

int	elasticCounter = 0
	how much time is left in an elastic-type flick/scroll set by the last distance traveled in a scroll, and counts down every frame More...

int	width = 0
	width and height of this element (must be manually set, isn't usually calculated (but is in some cases, like text or images)) More...

int	height = 0

int	x = 0

int	y = 0

int	xAbs = 0

int	yAbs = 0

double	angle = 0
	rotation angle in degrees More...

int	cornerRadius = 0

int	tag = 0

std::vector< std::unique_ptr< Constraint > >	constraints

std::vector< std::unique_ptr< Animation > >	animations

bool	useColorMask = false
	whether or not to overlay a color mask on top of this element More...

CST_Color	maskColor = {0,0,0,0}
	The color to overlay on top. More...

Static Public Attributes
static const std::string	textElemPrefix = "(TextElement):"

Protected Attributes
CST_Texture *	mTexture = nullptr
	The actual texture. More...

int	texW = 0
	The size of the texture. More...

int	texH = 0

CST_Color	texFirstPixel = {0,0,0,0}
	The color of the first pixel. More...

TextureScaleMode	texScaleMode = SCALE_STRETCH
	Texture's scaling mode. More...

Static Protected Attributes
static std::unordered_map< std::string, TextureData >	texCache
	Cache previously displayed textures. More...

Additional Inherited Members
Public Types inherited from Chesto::Element
typedef Element	super

Protected Member Functions inherited from Chesto::Element
void	addStackMember (Element *element)

Detailed Description

Definition at line 28 of file Texture.hpp.

Constructor & Destructor Documentation

◆ ~Texture()

Chesto::Texture::~Texture ( )

virtual

Definition at line 9 of file Texture.cpp.

10{

11}

Member Function Documentation

◆ clear()

void Chesto::Texture::clear ( void )

Reinitialize Texture Resets texture content, size and color.

Definition at line 13 of file Texture.cpp.

{
    mTexture = nullptr;
    texW = 0;
    texH = 0;
    texFirstPixel = (CST_Color){0,0,0,0};
}

References mTexture, texFirstPixel, and texW.

Referenced by Chesto::TextElement::update().

◆ getTextureSize()

void Chesto::Texture::getTextureSize	(	int *	w,
		int *	h
	)

Return texture's original size.

Definition at line 230 of file Texture.cpp.

{
    if (w)
        *w = texW;
    if (h)
        *h = texH;
}

References texW.

Referenced by Chesto::TextElement::update().

◆ loadFromCache()

bool Chesto::Texture::loadFromCache ( std::string & key )

Loads the texture from caches Returns true if successful.

Definition at line 81 of file Texture.cpp.

{
    // check if the texture is cached
    if (texCache.count(key))
    {
        TextureData *texData = &texCache[key];
        mTexture = texData->texture;
        texFirstPixel = texData->firstPixel;
        CST_QueryTexture(mTexture, &texW, &texH);
        return true;
    }
 
    return false;
}

References mTexture, texCache, texFirstPixel, and texW.

Referenced by loadPath(), Chesto::NetImageElement::NetImageElement(), and Chesto::TextElement::update().

◆ loadFromSurface()

bool Chesto::Texture::loadFromSurface ( CST_Surface * surface )

Loads the texture from a surface Returns true if successful.

Definition at line 54 of file Texture.cpp.

{
    if (!surface)
        return false;
 
    // will default MainDisplay's renderer if we don't have one in this->renderer
    CST_Renderer* renderer = getRenderer();
 
    // try to create a texture from the surface
    CST_Texture *texture = CST_CreateTextureFromSurface(renderer, surface, true);
    SDL_SetTextureBlendMode(texture, blendMode);
    if (!texture)
        return false;
 
    // load first pixel color
    auto pixelcolor = getpixel(surface, 0, 0);
    CST_GetRGBA(pixelcolor, surface->format, &texFirstPixel);
 
    // load texture size
    CST_QueryTexture(texture, &texW, &texH);
 
    // load texture
    mTexture = texture;
 
    return true;
}

References blendMode, mTexture, texFirstPixel, and texW.

Referenced by loadFromSurfaceSaveToCache().

◆ loadFromSurfaceSaveToCache()

bool Chesto::Texture::loadFromSurfaceSaveToCache	(	std::string &	key,
		CST_Surface *	surface
	)

Loads the texture from a surface and saves the results in caches Returns true if successful.

Definition at line 96 of file Texture.cpp.

{
    bool success = loadFromSurface(surface);
 
    // only save to caches if loading was successful
    // and the texture isn't already cached
    if (success && !texCache.count(key))
    {
        TextureData texData;
        texData.texture = mTexture;
        texData.firstPixel = texFirstPixel;
        texCache[key] = texData;
    }
 
    return success;
}

References loadFromSurface(), mTexture, texCache, and texFirstPixel.

Referenced by loadPath(), and Chesto::TextElement::update().

◆ loadPath()

void Chesto::Texture::loadPath	(	std::string &	path,
		bool	forceReload = `false`
	)

update and load or reload the texture

Definition at line 262 of file Texture.cpp.

                                                        {
    // Guard against empty paths
    if (path.empty()) {
        width = 0;
        height = 0;
        return;
    }
    
    if (forceReload || !loadFromCache(path))
    {
        CST_Surface *surface = IMG_Load(path.c_str());
        loadFromSurfaceSaveToCache(path, surface);
        CST_FreeSurface(surface);
    }
 
    width = texW;
    height = texH;
}

References loadFromCache(), loadFromSurfaceSaveToCache(), texW, and Chesto::Element::width.

Referenced by Chesto::ImageElement::ImageElement().

◆ render()

void Chesto::Texture::render ( Element * parent )

virtual

Renders the texture.

Reimplemented from Chesto::Element.

Definition at line 131 of file Texture.cpp.

{
    // update xAbs and yAbs
    super::render(parent);
 
    if (!mTexture)
        return;
 
    if (hidden)
        return;
 
    float effectiveScale = getEffectiveScale();
 
    // rect of element's size (scaled)
    CST_Rect rect;
    rect.x = this->xAbs;
    rect.y = this->yAbs;
    rect.w = (int)(this->width * effectiveScale);
    rect.h = (int)(this->height * effectiveScale);
 
    if (CST_isRectOffscreen(&rect))
        return;
 
    CST_Renderer* renderer = getRenderer();
 
    if (texScaleMode == SCALE_PROPORTIONAL_WITH_BG || texScaleMode == SCALE_PROPORTIONAL_NO_BG)
    {
        CST_SetDrawBlend(RootDisplay::renderer, false);
    
        // draw colored background
        if (texScaleMode == SCALE_PROPORTIONAL_WITH_BG)
        {
            CST_SetDrawColor(renderer, texFirstPixel);
            auto color = (CST_Color){ texFirstPixel.r, texFirstPixel.g, texFirstPixel.b, 0xFF };
 
            // if the first pixel is transparent, use the background color
            if (texFirstPixel.a == 0) {
                auto r = (Uint8)(backgroundColor.r * 0xff);
                auto g = (Uint8)(backgroundColor.g * 0xff);
                auto b = (Uint8)(backgroundColor.b * 0xff);
                color = (CST_Color){ r, g, b, 0xFF };
            }
 
            CST_roundedBoxRGBA(renderer, rect.x, rect.y, rect.x + rect.w, rect.y + rect.h, cornerRadius,
                color.r, color.g, color.b, 0xFF);
        }
 
        // recompute drawing rect
        if ((width * texH) > (height * texW))
        {
            // keep height, scale width
            rect.h = height;
            rect.w = (texW * rect.h) / texH;
        }
        else
        {
            // keep width, scale height
            rect.w = width;
            rect.h = (texH * rect.w) / texW;
        }
 
        // center the texture
        rect.x += (width - rect.w) / 2;
        rect.y += (height - rect.h) / 2;
    }
 
    if (angle != 0) {
        // render the texture with a rotation
        CST_SetQualityHint("best");
        CST_RenderCopyRotate(renderer, mTexture, NULL, &rect, this->angle);
    }
    else if (useColorMask) {
        // render the texture with a mask color (only can darken the texture)
        SDL_SetTextureColorMod(mTexture, maskColor.r, maskColor.g, maskColor.b);
        CST_RenderCopy(renderer, mTexture, NULL, &rect);
        SDL_SetTextureColorMod(mTexture, 0xFF, 0xFF, 0xFF);
    } else {
        // render the texture normally
        CST_RenderCopy(renderer, mTexture, NULL, &rect);
    }
}

References Chesto::Element::angle, cornerRadius, Chesto::Element::hidden, Chesto::Element::maskColor, mTexture, Chesto::Element::parent, Chesto::Element::render(), texFirstPixel, texScaleMode, texW, Chesto::Element::useColorMask, and Chesto::Element::width.

Referenced by Chesto::NetImageElement::render().

◆ resize()

void Chesto::Texture::resize	(	int	w,
		int	h
	)

Resizes the texture.

Definition at line 213 of file Texture.cpp.

{
    width = w;
    height = h;
}

References Chesto::Element::width.

◆ saveTo()

bool Chesto::Texture::saveTo ( std::string & path )

save this texture to the given file path as a PNG

Definition at line 238 of file Texture.cpp.

{
    if (!mTexture)
        return false;
 
    // render the texture to one that can be saved (TARGET ACCESS)
    CST_Texture* target = SDL_CreateTexture(getRenderer(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, texW, texH);
    if (!target)
        return false;
    
    // set the target texture
    SDL_SetRenderTarget(getRenderer(), target);
 
    // render the texture
    SDL_RenderCopy(getRenderer(), mTexture, NULL, NULL);
 
    // reset the target texture
    SDL_SetRenderTarget(getRenderer(), NULL);
 
 
    // save the surface to the path
    return CST_SavePNG(target, path.c_str());
}

References mTexture, and texW.

◆ setScaleMode()

void Chesto::Texture::setScaleMode ( TextureScaleMode mode )

Sets texture scaling mode.

Definition at line 225 of file Texture.cpp.

{
    texScaleMode = mode;
}

References texScaleMode.

◆ setSize()

Texture * Chesto::Texture::setSize	(	int	w,
		int	h
	)

Definition at line 219 of file Texture.cpp.

{
    this->resize(w, h);
    return this;
}

◆ wipeEntireCache()

void Chesto::Texture::wipeEntireCache ( )

static

Wipes the entire texture cache (generally, should only be used to reload entire theme / text)

Definition at line 113 of file Texture.cpp.

{
    texCache.clear();
}

References texCache.

◆ wipeTextCache()

void Chesto::Texture::wipeTextCache ( )

static

Similar to wipeEntireCache, but only wipes cached text textures (made by TextElement)

Definition at line 118 of file Texture.cpp.

{
    for (auto it = texCache.begin(); it != texCache.end(); )
    {
        std::string key = it->first;
        if (key.find(Texture::textElemPrefix) == 0) { // does the key start with our text prefix?
            it = texCache.erase(it);
        } else {
            ++it;
        }
    }
}

References texCache.

Member Data Documentation

◆ blendMode

SDL_BlendMode Chesto::Texture::blendMode = SDL_BLENDMODE_BLEND

Blend mode to use for this texture.

Definition at line 74 of file Texture.hpp.

Referenced by loadFromSurface().

◆ cornerRadius

int Chesto::Texture::cornerRadius = 0

Rounded corner radius (if >0, will round)

Definition at line 71 of file Texture.hpp.

Referenced by render().

◆ mTexture

CST_Texture* Chesto::Texture::mTexture = nullptr

protected

The actual texture.

Definition at line 90 of file Texture.hpp.

Referenced by clear(), loadFromCache(), loadFromSurface(), loadFromSurfaceSaveToCache(), render(), Chesto::NetImageElement::render(), and saveTo().

◆ texCache

std::unordered_map< std::string, TextureData > Chesto::Texture::texCache

staticprotected

Cache previously displayed textures.

Definition at line 87 of file Texture.hpp.

Referenced by loadFromCache(), loadFromSurfaceSaveToCache(), wipeEntireCache(), and wipeTextCache().

◆ texFirstPixel

CST_Color Chesto::Texture::texFirstPixel = {0,0,0,0}

protected

The color of the first pixel.

Definition at line 96 of file Texture.hpp.

Referenced by clear(), loadFromCache(), loadFromSurface(), loadFromSurfaceSaveToCache(), and render().

◆ texH

int Chesto::Texture::texH = 0

protected

Definition at line 93 of file Texture.hpp.

◆ texScaleMode

TextureScaleMode Chesto::Texture::texScaleMode = SCALE_STRETCH

protected

Texture's scaling mode.

Definition at line 99 of file Texture.hpp.

Referenced by render(), and setScaleMode().

◆ textElemPrefix

const std::string Chesto::Texture::textElemPrefix = "(TextElement):"

static

Definition at line 77 of file Texture.hpp.

◆ texW

int Chesto::Texture::texW = 0

protected

The size of the texture.

Definition at line 93 of file Texture.hpp.

Referenced by clear(), getTextureSize(), loadFromCache(), loadFromSurface(), loadPath(), Chesto::NetImageElement::NetImageElement(), render(), and saveTo().

The documentation for this class was generated from the following files:

src/Texture.hpp
src/Texture.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Attributes

Static Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~Texture()

Member Function Documentation

◆ clear()

◆ getTextureSize()

◆ loadFromCache()

◆ loadFromSurface()

◆ loadFromSurfaceSaveToCache()

◆ loadPath()

◆ render()

◆ resize()

◆ saveTo()

◆ setScaleMode()

◆ setSize()

◆ wipeEntireCache()

◆ wipeTextCache()

Member Data Documentation

◆ blendMode

◆ cornerRadius

◆ mTexture

◆ texCache

◆ texFirstPixel

◆ texH

◆ texScaleMode

◆ textElemPrefix

◆ texW