CUGL 2.0
Cornell University Game Library
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
cugl::scene2::TexturedNode Class Referenceabstract

#include <CUTexturedNode.h>

Inheritance diagram for cugl::scene2::TexturedNode:
cugl::scene2::SceneNode cugl::scene2::PathNode cugl::scene2::PolygonNode cugl::scene2::WireNode cugl::scene2::AnimationNode

Public Member Functions

 TexturedNode ()
 
 ~TexturedNode ()
 
virtual void dispose () override
 
virtual bool init () override
 
bool init (const std::vector< Vec2 > &vertices)
 
bool init (const Poly2 &poly)
 
bool init (const Rect rect)
 
bool initWithFile (const std::string &filename)
 
bool initWithFile (const std::string &filename, const std::vector< Vec2 > &vertices)
 
bool initWithFile (const std::string &filename, const Poly2 &poly)
 
bool initWithFile (const std::string &filename, const Rect rect)
 
bool initWithTexture (const std::shared_ptr< Texture > &texture)
 
bool initWithTexture (const std::shared_ptr< Texture > &texture, const std::vector< Vec2 > &vertices)
 
bool initWithTexture (const std::shared_ptr< Texture > &texture, const Poly2 &poly)
 
bool initWithTexture (const std::shared_ptr< Texture > &texture, const Rect rect)
 
virtual bool initWithData (const Scene2Loader *loader, const std::shared_ptr< JsonValue > &data) override
 
void setTexture (const std::string &filename)
 
void setTexture (const std::shared_ptr< Texture > &texture)
 
std::shared_ptr< Texture > & getTexture ()
 
const std::shared_ptr< Texture > & getTexture () const
 
virtual void setPolygon (const std::vector< Vec2 > &vertices)=0
 
virtual void setPolygon (const Poly2 &poly)
 
virtual void setPolygon (const Rect rect)=0
 
const Poly2getPolygon () const
 
virtual void shiftPolygon (float dx, float dy)
 
const Rect getBoundingRect () const
 
void setBlendFunc (GLenum srcFactor, GLenum dstFactor)
 
GLenum getSourceBlendFactor () const
 
GLenum getDestinationBlendFactor () const
 
void setBlendEquation (GLenum equation)
 
GLenum getBlendEquation () const
 
void flipHorizontal (bool flag)
 
bool isFlipHorizontal () const
 
void flipVertical (bool flag)
 
bool isFlipVertical () const
 
virtual std::string toString (bool verbose=false) const override
 
bool isAbsolute () const
 
void setAbsolute (bool flag)
 
virtual void setAnchor (const Vec2 anchor) override
 
virtual void setContentSize (const Size size) override
 
virtual void setContentSize (float width, float height) override
 
virtual void draw (const std::shared_ptr< SpriteBatch > &batch, const Mat4 &transform, Color4 tint) override=0
 
void refresh ()
 
const std::shared_ptr< Gradient > & getGradient () const
 
void setGradient (const std::shared_ptr< Gradient > &gradient)
 
- Public Member Functions inherited from cugl::scene2::SceneNode
 SceneNode ()
 
 ~SceneNode ()
 
virtual bool initWithPosition (const Vec2 pos)
 
bool initWithPosition (float x, float y)
 
virtual bool initWithBounds (const Size size)
 
bool initWithBounds (float width, float height)
 
virtual bool initWithBounds (const Rect rect)
 
bool initWithBounds (float x, float y, float width, float height)
 
virtual SceneNodecopy (SceneNode *dst)
 
unsigned int getTag () const
 
void setTag (unsigned int tag)
 
const std::string & getName () const
 
void setName (const std::string &name)
 
 operator std::string () const
 
const Vec2 getPosition () const
 
void setPosition (const Vec2 &position)
 
void setPosition (float x, float y)
 
float getPositionX (void) const
 
void setPositionX (float x)
 
float getPositionY (void) const
 
void setPositionY (float y)
 
Vec2 getWorldPosition () const
 
const Size getContentSize () const
 
float getContentWidth () const
 
void setContentWidth (float width)
 
float getContentHeight () const
 
void setContentHeight (float height)
 
Size getSize () const
 
float getWidth () const
 
float getHeight () const
 
Rect getBoundingBox () const
 
void setAnchor (float x, float y)
 
const Vec2 getAnchor () const
 
Vec2 getAnchorInPixels ()
 
Color4 getColor () const
 
virtual void setColor (Color4 color)
 
Color4 getAbsoluteColor ()
 
bool isVisible () const
 
void setVisible (bool visible)
 
bool hasRelativeColor ()
 
void setRelativeColor (bool flag)
 
std::shared_ptr< ScissorgetScissor () const
 
void setScissor (const std::shared_ptr< Scissor > &scissor)
 
void setScissor ()
 
const Vec2 getScale () const
 
float getScaleX () const
 
float getScaleY () const
 
void setScale (float scale)
 
void setScale (const Vec2 vec)
 
void setScale (float sx, float sy)
 
float getAngle ()
 
void setAngle (float angle)
 
const Mat4getAlternateTransform ()
 
void setAlternateTransform (const Mat4 &transform)
 
bool withAlternateTransform ()
 
void chooseAlternateTransform (bool active)
 
const Mat4getNodeToParentTransform () const
 
Mat4 getParentToNodeTransform () const
 
Mat4 getNodeToWorldTransform () const
 
Mat4 getWorldToNodeTransform () const
 
Vec2 screenToNodeCoords (const Vec2 screenPoint) const
 
Vec2 worldToNodeCoords (const Vec2 worldPoint) const
 
Vec2 nodeToScreenCoords (const Vec2 nodePoint) const
 
Vec2 nodeToWorldCoords (const Vec2 nodePoint) const
 
Vec2 parentToNodeCoords (const Vec2 parentPoint) const
 
Vec2 nodeToParentCoords (const Vec2 nodePoint) const
 
void setZOrder (int z)
 
int getZOrder () const
 
bool isZDirty () const
 
void sortZOrder ()
 
size_t getChildCount () const
 
std::shared_ptr< SceneNodegetChild (unsigned int pos)
 
const std::shared_ptr< SceneNode > & getChild (unsigned int pos) const
 
template<typename T >
std::shared_ptr< T > getChild (unsigned int pos) const
 
std::shared_ptr< SceneNodegetChildByTag (unsigned int tag) const
 
template<typename T >
std::shared_ptr< T > getChildByTag (unsigned int tag) const
 
std::shared_ptr< SceneNodegetChildByName (const std::string name) const
 
template<typename T >
std::shared_ptr< T > getChildByName (const std::string name) const
 
std::vector< std::shared_ptr< SceneNode > > getChildren ()
 
const std::vector< std::shared_ptr< SceneNode > > & getChildren () const
 
void addChild (std::shared_ptr< SceneNode > child)
 
virtual void addChild (const std::shared_ptr< SceneNode > &child, int zval)
 
void addChildWithTag (const std::shared_ptr< SceneNode > &child, unsigned int tag)
 
void addChildWithTag (const std::shared_ptr< SceneNode > &child, unsigned int tag, int zval)
 
void addChildWithName (const std::shared_ptr< SceneNode > &child, const std::string &name)
 
void addChildWithName (const std::shared_ptr< SceneNode > &child, const std::string &name, int zval)
 
void swapChild (const std::shared_ptr< SceneNode > &child1, const std::shared_ptr< SceneNode > &child2, bool inherit=false)
 
SceneNodegetParent ()
 
const SceneNodegetParent () const
 
Scene2getScene ()
 
const Scene2getScene () const
 
void removeFromParent ()
 
virtual void removeChild (unsigned int pos)
 
void removeChild (const std::shared_ptr< SceneNode > &child)
 
void removeChildByTag (unsigned int tag)
 
void removeChildByName (const std::string name)
 
virtual void removeAllChildren ()
 
virtual void render (const std::shared_ptr< SpriteBatch > &batch, const Mat4 &transform, Color4 tint)
 
virtual void render (const std::shared_ptr< SpriteBatch > &batch)
 
const std::shared_ptr< Layout > & getLayout () const
 
void setLayout (const std::shared_ptr< Layout > &layout)
 
virtual void doLayout ()
 

Protected Member Functions

virtual void generateRenderData ()
 
void clearRenderData ()
 
void updateTextureCoords ()
 
 CU_DISALLOW_COPY_AND_ASSIGN (TexturedNode)
 

Protected Attributes

std::string _classname
 
std::shared_ptr< Texture_texture
 
Poly2 _polygon
 
bool _absolute
 
bool _stretch
 
bool _rendered
 
Mesh< SpriteVertex2_mesh
 
GLenum _blendEquation
 
GLenum _srcFactor
 
GLenum _dstFactor
 
bool _flipHorizontal
 
bool _flipVertical
 
std::shared_ptr< Gradient_gradient
 
std::shared_ptr< Gradient_spriteGrad
 
- Protected Attributes inherited from cugl::scene2::SceneNode
Vec2 _position
 
Vec2 _anchor
 
Size _contentSize
 
Color4 _tintColor
 
bool _hasParentColor
 
bool _isVisible
 
std::shared_ptr< Scissor_scissor
 
Vec2 _scale
 
float _angle
 
Mat4 _transform
 
bool _useTransform
 
Mat4 _combined
 
std::vector< std::shared_ptr< SceneNode > > _children
 
SceneNode_parent
 
Scene2_graph
 
std::shared_ptr< Layout_layout
 
int _childOffset
 
unsigned int _tag
 
std::string _name
 
size_t _hashOfName
 
int _zOrder
 
bool _zDirty
 
std::shared_ptr< JsonValue_json
 

Additional Inherited Members

- Static Public Member Functions inherited from cugl::scene2::SceneNode
static std::shared_ptr< SceneNodealloc ()
 
static std::shared_ptr< SceneNodeallocWithPosition (const Vec2 pos)
 
static std::shared_ptr< SceneNodeallocWithPosition (float x, float y)
 
static std::shared_ptr< SceneNodeallocWithBounds (const Size size)
 
static std::shared_ptr< SceneNodeallocWithBounds (float width, float height)
 
static std::shared_ptr< SceneNodeallocWithBounds (const Rect rect)
 
static std::shared_ptr< SceneNodeallocWithBounds (float x, float y, float width, float height)
 
static std::shared_ptr< SceneNodeallocWithData (const Scene2Loader *loader, const std::shared_ptr< JsonValue > &data)
 

Detailed Description

This class is an abstract scene graph node representing a textured shape.

This class cannot be instantiated directly. Instead, you must use one of the subclasses: PolygonNode, PathNode, WireNode.

The node shape is stored as polygon. This is true regardless of whether the node is displaying solid shapes or a wireframe. The polygon is itself specified in image coordinates. Image coordinates are different from texture coordinates. Their origin is at the bottom-left corner of the file, and each pixel is one unit. This makes specifying a polygon more natural for irregular shapes.

This means that a polygon with vertices (0,0), (width,0), (width,height), and (0,height) would be identical to a sprite node. However, a polygon with vertices (0,0), (2*width,0), (2*width,2*height), and (0,2*height) would tile the sprite (given the wrap settings) twice both horizontally and vertically.

The content size of this node is defined by the size (but not the offset) of the bounding box. The anchor point is relative to this content size. The default anchor point in TexturedNode is (0.5, 0.5). This means that a uniform translation of the polygon (in contrast to the node itself) will not move the shape on the the screen. Instead, it will just change the part of the texture it uses.

For example, suppose the texture has given width and height. We have one polygon with vertices (0,0), (width/2,0), (width/2,height/2), and (0,height/2). We have another polygon with vertices (width/2,height/2), (width,height/2), (width,height), and (width/2,height). Both polygons would create a rectangle of size (width/2,height/2). centered at the node position. However, the first would use the bottom left part of the texture, while the second would use the top right.

You can disable these features at any time by setting the attribute absolute to true. Do this will place the polygon vertices in their absolute positions in Node space. This will also disable anchor functions (setting the anchor as the bottom left corner), since anchors do not make sense when we are drawing vertices directly into the coordinate space.

Constructor & Destructor Documentation

◆ TexturedNode()

cugl::scene2::TexturedNode::TexturedNode ( )

Creates an empty polygon with the degenerate texture.

This constructor should never be called directly, as this is an abstract class.

◆ ~TexturedNode()

cugl::scene2::TexturedNode::~TexturedNode ( )
inline

Deletes this node, releasing all resources.

Member Function Documentation

◆ clearRenderData()

void cugl::scene2::TexturedNode::clearRenderData ( )
protected

Clears the render data, releasing all vertices and indices.

◆ CU_DISALLOW_COPY_AND_ASSIGN()

cugl::scene2::TexturedNode::CU_DISALLOW_COPY_AND_ASSIGN ( TexturedNode  )
protected

This macro disables the copy constructor (not allowed on scene graphs)

◆ dispose()

virtual void cugl::scene2::TexturedNode::dispose ( )
overridevirtual

Disposes all of the resources used by this node.

A disposed Node can be safely reinitialized. Any children owned by this node will be released. They will be deleted if no other object owns them.

It is unsafe to call this on a Node that is still currently inside of a scene graph.

Reimplemented from cugl::scene2::SceneNode.

◆ draw()

virtual void cugl::scene2::TexturedNode::draw ( const std::shared_ptr< SpriteBatch > &  batch,
const Mat4 transform,
Color4  tint 
)
overridepure virtual

Draws this Node via the given SpriteBatch.

This method only worries about drawing the current node. It does not attempt to render the children.

This is the method that you should override to implement your custom drawing code. You are welcome to use any OpenGL commands that you wish. You can even skip use of the SpriteBatch. However, if you do so, you must flush the SpriteBatch by calling end() at the start of the method. in addition, you should remember to call begin() at the start of the method.

This method provides the correct transformation matrix and tint color. You do not need to worry about whether the node uses relative color. This method is called by render() and these values are guaranteed to be correct. In addition, this method does not need to check for visibility, as it is guaranteed to only be called when the node is visible.

Parameters
batchThe SpriteBatch to draw with.
transformThe global transformation matrix.
tintThe tint to blend with the Node color.

Reimplemented from cugl::scene2::SceneNode.

Implemented in cugl::scene2::PathNode, cugl::scene2::WireNode, and cugl::scene2::PolygonNode.

◆ flipHorizontal()

void cugl::scene2::TexturedNode::flipHorizontal ( bool  flag)
inline

Flips the texture coordinates horizontally if flag is true.

Flipping the texture coordinates replaces each u coordinate with 1-u. Hence this operation is defined even if the texture coordinates are outside the range 0..1.

Parameters
flagwhether to flip the coordinates horizontally

◆ flipVertical()

void cugl::scene2::TexturedNode::flipVertical ( bool  flag)
inline

Flips the texture coordinates vertically if flag is true.

Flipping the texture coordinates replaces each v coordinate with 1-v. Hence this operation is defined even if the texture coordinates are outside the range 0..1.

Parameters
flagwhether to flip the coordinates vertically

◆ generateRenderData()

virtual void cugl::scene2::TexturedNode::generateRenderData ( )
protectedvirtual

Allocates the render data necessary to render this node.

◆ getBlendEquation()

GLenum cugl::scene2::TexturedNode::getBlendEquation ( ) const
inline

Returns the blending equation for this textured node

By default this value is GL_FUNC_ADD. For other options, see

 https://www.opengl.org/sdk/docs/man/html/glBlendEquation.xhtml

This blending equation only affects the texture of the current node. It does not affect any children of the node.

Returns
the blending equation for this sprite batch

◆ getBoundingRect()

const Rect cugl::scene2::TexturedNode::getBoundingRect ( ) const
inline

Returns the rect of the Polygon in points

The bounding rect is the smallest rectangle containing all of the points in the polygon.

This value also defines the content size of the node. The polygon will be shifted so that its bounding rect is centered at the node center.

◆ getDestinationBlendFactor()

GLenum cugl::scene2::TexturedNode::getDestinationBlendFactor ( ) const
inline

Returns the destination blending factor

By default this value is GL_ONE_MINUS_SRC_ALPHA. For other options, see

 https://www.opengl.org/sdk/docs/man/html/glBlendFunc.xhtml

This blending factor only affects the texture of the current node. It does not affect any children of the node.

Returns
the destination blending factor

◆ getGradient()

const std::shared_ptr<Gradient>& cugl::scene2::TexturedNode::getGradient ( ) const
inline

Returns the gradient to use for this polygon.

Unlike colors, gradients are local. They do not apply to the children of this node.

Returns
the gradient to use for this polygon.

◆ getPolygon()

const Poly2& cugl::scene2::TexturedNode::getPolygon ( ) const
inline

Returns the texture polygon for this scene graph node

Returns
the texture polygon for this scene graph node

◆ getSourceBlendFactor()

GLenum cugl::scene2::TexturedNode::getSourceBlendFactor ( ) const
inline

Returns the source blending factor

By default this value is GL_SRC_ALPHA. For other options, see

 https://www.opengl.org/sdk/docs/man/html/glBlendFunc.xhtml

This blending factor only affects the texture of the current node. It does not affect any children of the node.

Returns
the source blending factor

◆ getTexture() [1/2]

std::shared_ptr<Texture>& cugl::scene2::TexturedNode::getTexture ( )
inline

Returns the texture used by this node.

Returns
the texture used by this node

◆ getTexture() [2/2]

const std::shared_ptr<Texture>& cugl::scene2::TexturedNode::getTexture ( ) const
inline

Returns the texture used by this node.

Returns
the texture used by this node

◆ init() [1/4]

virtual bool cugl::scene2::TexturedNode::init ( )
inlineoverridevirtual

Intializes an empty polygon with the degenerate texture.

You do not need to set the texture; rendering this into a SpriteBatch will simply use the blank texture. The polygon, however, will also be empty, and must be set via setPolygon.

Returns
true if the sprite is initialized properly, false otherwise.

Reimplemented from cugl::scene2::SceneNode.

◆ init() [2/4]

bool cugl::scene2::TexturedNode::init ( const Poly2 poly)
inline

Intializes a solid polygon given polygon shape.

You do not need to set the texture; rendering this into a SpriteBatch will simply use the blank texture. Hence the polygon will have a solid color.

Parameters
polyThe polygon to texture
Returns
true if the sprite is initialized properly, false otherwise.

◆ init() [3/4]

bool cugl::scene2::TexturedNode::init ( const Rect  rect)
inline

Intializes a solid polygon with the given rect.

You do not need to set the texture; rendering this into a SpriteBatch will simply use the blank texture. Hence the polygon will have a solid color.

The conversion of rectangle to polygon is subclass specific.

Parameters
rectThe rectangle to texture
Returns
true if the sprite is initialized properly, false otherwise.

◆ init() [4/4]

bool cugl::scene2::TexturedNode::init ( const std::vector< Vec2 > &  vertices)
inline

Intializes a solid polygon with the given vertices.

You do not need to set the texture; rendering this into a SpriteBatch will simply use the blank texture. Hence the polygon will have a solid color.

The polygon indices will be subclass specific.

Parameters
verticesThe vertices to texture (expressed in image space)
Returns
true if the sprite is initialized properly, false otherwise.

◆ initWithData()

virtual bool cugl::scene2::TexturedNode::initWithData ( const Scene2Loader loader,
const std::shared_ptr< JsonValue > &  data 
)
overridevirtual

Initializes a node with the given JSON specificaton.

This initializer is designed to receive the "data" object from the JSON passed to Scene2Loader. This JSON format supports all of the attribute values of its parent class. In addition, it supports the following additional attributes:

 "texture":  The name of a previously loaded texture asset
 "polygon":  An even array of polygon vertices (numbers)
 "indices":  An array of unsigned ints defining triangles from the
             the vertices. The array size should be a multiple of 3.

All attributes are optional. However, it is generally a good idea to specify EITHER the texture or the polygon

Parameters
loaderThe scene loader passing this JSON file
dataThe JSON object specifying the node
Returns
true if initialization was successful.

Reimplemented from cugl::scene2::SceneNode.

Reimplemented in cugl::scene2::PathNode, cugl::scene2::WireNode, and cugl::scene2::AnimationNode.

◆ initWithFile() [1/4]

bool cugl::scene2::TexturedNode::initWithFile ( const std::string &  filename)

Intializes a textured polygon from the image filename.

After creation, the polygon will be a rectangle. The vertices of this polygon will be the corners of the image.

Parameters
filenameA path to image file, e.g., "scene1/earthtile.png"
Returns
true if the sprite is initialized properly, false otherwise.

◆ initWithFile() [2/4]

bool cugl::scene2::TexturedNode::initWithFile ( const std::string &  filename,
const Poly2 poly 
)

Initializes a textured polygon from the image filename and the given polygon.

Parameters
filenameA path to image file, e.g., "scene1/earthtile.png"
polyThe polygon to texture
Returns
true if the sprite is initialized properly, false otherwise.

◆ initWithFile() [3/4]

bool cugl::scene2::TexturedNode::initWithFile ( const std::string &  filename,
const Rect  rect 
)

Initializes a textured polygon from the image filename and the given rect.

The conversion of rectangle to polygon is subclass specific.

Parameters
filenameA path to image file, e.g., "scene1/earthtile.png"
rectThe rectangle to texture
Returns
true if the sprite is initialized properly, false otherwise.

◆ initWithFile() [4/4]

bool cugl::scene2::TexturedNode::initWithFile ( const std::string &  filename,
const std::vector< Vec2 > &  vertices 
)
inline

Initializes a textured polygon from the image filename and the given vertices.

The polygon indices will be subclass specific.

Parameters
filenameA path to image file, e.g., "scene1/earthtile.png"
verticesThe vertices to texture (expressed in image space)
Returns
true if the sprite is initialized properly, false otherwise.

◆ initWithTexture() [1/4]

bool cugl::scene2::TexturedNode::initWithTexture ( const std::shared_ptr< Texture > &  texture)

Initializes a textured polygon from a Texture object.

After creation, the polygon will be a rectangle. The vertices of this polygon will be the corners of the texture.

Parameters
textureA shared pointer to a Texture object.
Returns
true if the sprite is initialized properly, false otherwise.

◆ initWithTexture() [2/4]

bool cugl::scene2::TexturedNode::initWithTexture ( const std::shared_ptr< Texture > &  texture,
const Poly2 poly 
)

Initializes a textured polygon from a Texture object and the given polygon.

Parameters
textureA shared pointer to a Texture object.
polyThe polygon to texture
Returns
true if the sprite is initialized properly, false otherwise.

◆ initWithTexture() [3/4]

bool cugl::scene2::TexturedNode::initWithTexture ( const std::shared_ptr< Texture > &  texture,
const Rect  rect 
)

Initializes a textured polygon from a Texture object and the given rect.

The conversion of rectangle to polygon is subclass specific.

Parameters
textureA shared pointer to a Texture object.
rectThe rectangle to texture
Returns
true if the sprite is initialized properly, false otherwise.

◆ initWithTexture() [4/4]

bool cugl::scene2::TexturedNode::initWithTexture ( const std::shared_ptr< Texture > &  texture,
const std::vector< Vec2 > &  vertices 
)
inline

Initializes a textured polygon from a Texture object and the given vertices.

The polygon indices will be subclass specific.

Parameters
textureA shared pointer to a Texture object.
verticesThe vertices to texture (expressed in image space)
Returns
true if the sprite is initialized properly, false otherwise.

◆ isAbsolute()

bool cugl::scene2::TexturedNode::isAbsolute ( ) const
inline

Returns true if this node is using absolute positioning.

In absolute positioning, the vertices are draw in their correct position with respect to the node origin. We no longer try to offset the polygon with respect to the anchors. This is useful when you need a scene graph node that has an external relationship to a non-child node.

Setting this value to true will disable anchor functions (and set the anchor to the bottom left). That is because anchors do not make sense when we are using absolute positioning.

Returns
true if this node is using absolute positioning.

◆ isFlipHorizontal()

bool cugl::scene2::TexturedNode::isFlipHorizontal ( ) const
inline

Returns true if the texture coordinates are flipped horizontally.

Returns
true if the texture coordinates are flipped horizontally.

◆ isFlipVertical()

bool cugl::scene2::TexturedNode::isFlipVertical ( ) const
inline

Returns true if the texture coordinates are flipped vertically.

Returns
true if the texture coordinates are flipped vertically.

◆ refresh()

void cugl::scene2::TexturedNode::refresh ( )
inline

Refreshes this node to restore the render data.

◆ setAbsolute()

void cugl::scene2::TexturedNode::setAbsolute ( bool  flag)
inline

Sets whether this node is using absolute positioning.

In absolute positioning, the vertices are draw in their correct position with respect to the node origin. We no longer try to offset the polygon with respect to the anchors. This is useful when you need a scene graph node that has an external relationship to a non-child node.

Setting this value to true will disable anchor functions (and set the anchor to the bottom left). That is because anchors do not make sense when we are using absolute positioning.

Parameters
flagWhether if this node is using absolute positioning.

◆ setAnchor()

virtual void cugl::scene2::TexturedNode::setAnchor ( const Vec2  anchor)
inlineoverridevirtual

Sets the anchor point in percentages.

The anchor point defines the relative origin of Node with respect to its parent. It is a "pin" where the Node is attached to its parent. In effect, the translation of a Node is defined by its position plus anchor point.

The anchorPoint is normalized, like a percentage. (0,0) means the bottom-left corner and (1,1) means the top-right corner. There are many anchor point constants defined in Vec2. However, there is nothing preventing an anchor point higher than (1,1) or lower than (0,0).

The default anchorPoint is (0.5,0.5), so it starts in the center of the node. Changing the anchor will not move the contents of the node in the parent space, but it will change the value of the Node position.

This function is disabled if the node is using absolute positioning.
That is because anchors do not make sense when we are drawing polygons directly to the screen.

Parameters
anchorThe anchor point of node.

Reimplemented from cugl::scene2::SceneNode.

◆ setBlendEquation()

void cugl::scene2::TexturedNode::setBlendEquation ( GLenum  equation)
inline

Sets the blending equation for this textured node

The enum must be a standard ones supported by OpenGL. See

 https://www.opengl.org/sdk/docs/man/html/glBlendEquation.xhtml

However, this setter does not do any error checking to verify that the input is valid. By default, the equation is GL_FUNC_ADD.

This blending equation only affects the texture of the current node. It does not affect any children of the node.

Parameters
equationSpecifies how source and destination colors are combined

◆ setBlendFunc()

void cugl::scene2::TexturedNode::setBlendFunc ( GLenum  srcFactor,
GLenum  dstFactor 
)
inline

Sets the blending function for this texture node.

The enums are the standard ones supported by OpenGL. See

 https://www.opengl.org/sdk/docs/man/html/glBlendFunc.xhtml

However, this setter does not do any error checking to verify that the enums are valid. By default, srcFactor is GL_SRC_ALPHA while dstFactor is GL_ONE_MINUS_SRC_ALPHA. This corresponds to non-premultiplied alpha blending.

This blending factor only affects the texture of the current node. It does not affect any children of the node.

Parameters
srcFactorSpecifies how the source blending factors are computed
dstFactorSpecifies how the destination blending factors are computed.

◆ setContentSize() [1/2]

virtual void cugl::scene2::TexturedNode::setContentSize ( const Size  size)
overridevirtual

Sets the untransformed size of the node.

The content size remains the same no matter how the node is scaled or rotated. All nodes must have a size, though it may be degenerate (0,0).

By default, the content size of a TexturedNode is the size of the bounding box of the defining polygon. Resizing a texture node will stretch the image to fill in the new size.

Parameters
sizeThe untransformed size of the node.

Reimplemented from cugl::scene2::SceneNode.

◆ setContentSize() [2/2]

virtual void cugl::scene2::TexturedNode::setContentSize ( float  width,
float  height 
)
inlineoverridevirtual

Sets the untransformed size of the node.

The content size remains the same no matter how the node is scaled or rotated. All nodes must have a size, though it may be degenerate (0,0).

By default, the content size of a TexturedNode is the size of the bounding box of the defining polygon. Resizing a texture node will stretch the image to fill in the new size.

Parameters
widthThe untransformed width of the node.
heightThe untransformed height of the node.

Reimplemented from cugl::scene2::SceneNode.

◆ setGradient()

void cugl::scene2::TexturedNode::setGradient ( const std::shared_ptr< Gradient > &  gradient)

Sets the gradient to use for this polygon.

Unlike colors, gradients are local. They do not apply to the children of this node.

Parameters
gradientThe gradient to use for this polygon.

◆ setPolygon() [1/3]

virtual void cugl::scene2::TexturedNode::setPolygon ( const Poly2 poly)
virtual

Sets the polygon to the given one in texture space.

Parameters
polyThe polygon to texture

Reimplemented in cugl::scene2::PathNode, cugl::scene2::WireNode, and cugl::scene2::PolygonNode.

◆ setPolygon() [2/3]

virtual void cugl::scene2::TexturedNode::setPolygon ( const Rect  rect)
pure virtual

Sets the texture polygon to one equivalent to the given rect.

The conversion of rectangle to polygon is subclass specific.

Parameters
rectThe rectangle to texture

Implemented in cugl::scene2::PathNode, cugl::scene2::WireNode, and cugl::scene2::PolygonNode.

◆ setPolygon() [3/3]

virtual void cugl::scene2::TexturedNode::setPolygon ( const std::vector< Vec2 > &  vertices)
pure virtual

Sets the polgon to the vertices expressed in texture space.

The polygon indices will be subclass specific.

Parameters
verticesThe vertices to texture

Implemented in cugl::scene2::PathNode, cugl::scene2::WireNode, and cugl::scene2::PolygonNode.

◆ setTexture() [1/2]

void cugl::scene2::TexturedNode::setTexture ( const std::shared_ptr< Texture > &  texture)

Sets the node texture to the one specified.

This method will have no effect on the polygon vertices. This class decouples the geometry from the texture. That is because we do not expect the vertices to match the texture perfectly.

Parameters
textureA shared pointer to a Texture object.

◆ setTexture() [2/2]

void cugl::scene2::TexturedNode::setTexture ( const std::string &  filename)
inline

Sets the node texture to a new one allocated from a filename.

This method will have no effect on the polygon vertices. This class decouples the geometry from the texture. That is because we do not expect the vertices to match the texture perfectly.

Parameters
filenameA path to image file, e.g., "scene1/earthtile.png"

◆ shiftPolygon()

virtual void cugl::scene2::TexturedNode::shiftPolygon ( float  dx,
float  dy 
)
virtual

Translates the polygon by the given amount.

Remember that translating the polygon has no effect on the shape or position. Because the polygon is expressed in image coordinates, all it does is shift the texture coords of the polygon. Hence this method can be used for animation and filmstrips.

Calling this method is faster than changing the polygon and resetting it.

Parameters
dxThe amount to shift horizontally.
dyThe amount to shift horizontally.

◆ toString()

virtual std::string cugl::scene2::TexturedNode::toString ( bool  verbose = false) const
overridevirtual

Returns a string representation of this node for debugging purposes.

If verbose is true, the string will include class information. This allows us to unambiguously identify the class.

Parameters
verboseWhether to include class information
Returns
a string representation of this node for debuggging purposes.

Reimplemented from cugl::scene2::SceneNode.

◆ updateTextureCoords()

void cugl::scene2::TexturedNode::updateTextureCoords ( )
protected

Updates the texture coordinates for this polygon

The texture coordinates are computed assuming that the polygon is defined in image space, with the origin in the bottom left corner of the texture.

Member Data Documentation

◆ _absolute

bool cugl::scene2::TexturedNode::_absolute
protected

Whether to disable anchors and draw the polygon in absolute coordinates

◆ _blendEquation

GLenum cugl::scene2::TexturedNode::_blendEquation
protected

The blending equation for this texture

◆ _classname

std::string cugl::scene2::TexturedNode::_classname
protected

The class name for the specific subclass

◆ _dstFactor

GLenum cugl::scene2::TexturedNode::_dstFactor
protected

The destination factor for the blend function

◆ _flipHorizontal

bool cugl::scene2::TexturedNode::_flipHorizontal
protected

Whether or not to flip the texture horizontally

◆ _flipVertical

bool cugl::scene2::TexturedNode::_flipVertical
protected

Whether or not to flip the texture vertically

◆ _gradient

std::shared_ptr<Gradient> cugl::scene2::TexturedNode::_gradient
protected

The gradient to use for this polygon

◆ _mesh

Mesh<SpriteVertex2> cugl::scene2::TexturedNode::_mesh
protected

The render data for this node

◆ _polygon

Poly2 cugl::scene2::TexturedNode::_polygon
protected

The polygon defining this node, with vertices in texture space

◆ _rendered

bool cugl::scene2::TexturedNode::_rendered
protected

Whether we have generated render data for this node

◆ _spriteGrad

std::shared_ptr<Gradient> cugl::scene2::TexturedNode::_spriteGrad
protected

The active gradient to use in the sprite batch pass

◆ _srcFactor

GLenum cugl::scene2::TexturedNode::_srcFactor
protected

The source factor for the blend function

◆ _stretch

bool cugl::scene2::TexturedNode::_stretch
protected

Whether to stretch the image to match the content size

◆ _texture

std::shared_ptr<Texture> cugl::scene2::TexturedNode::_texture
protected

Texture to be applied to the polygon


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