CUGL 2.0
Cornell University Game Library
|
#include <CUTexturedNode.h>
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 Poly2 & | getPolygon () 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 SceneNode * | copy (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< Scissor > | getScissor () 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 Mat4 & | getAlternateTransform () |
void | setAlternateTransform (const Mat4 &transform) |
bool | withAlternateTransform () |
void | chooseAlternateTransform (bool active) |
const Mat4 & | getNodeToParentTransform () 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< SceneNode > | getChild (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< SceneNode > | getChildByTag (unsigned int tag) const |
template<typename T > | |
std::shared_ptr< T > | getChildByTag (unsigned int tag) const |
std::shared_ptr< SceneNode > | getChildByName (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) |
SceneNode * | getParent () |
const SceneNode * | getParent () const |
Scene2 * | getScene () |
const Scene2 * | getScene () 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< SceneNode > | alloc () |
static std::shared_ptr< SceneNode > | allocWithPosition (const Vec2 pos) |
static std::shared_ptr< SceneNode > | allocWithPosition (float x, float y) |
static std::shared_ptr< SceneNode > | allocWithBounds (const Size size) |
static std::shared_ptr< SceneNode > | allocWithBounds (float width, float height) |
static std::shared_ptr< SceneNode > | allocWithBounds (const Rect rect) |
static std::shared_ptr< SceneNode > | allocWithBounds (float x, float y, float width, float height) |
static std::shared_ptr< SceneNode > | allocWithData (const Scene2Loader *loader, const std::shared_ptr< JsonValue > &data) |
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.
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.
|
inline |
Deletes this node, releasing all resources.
|
protected |
Clears the render data, releasing all vertices and indices.
|
protected |
This macro disables the copy constructor (not allowed on scene graphs)
|
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.
|
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.
batch | The SpriteBatch to draw with. |
transform | The global transformation matrix. |
tint | The tint to blend with the Node color. |
Reimplemented from cugl::scene2::SceneNode.
Implemented in cugl::scene2::PathNode, cugl::scene2::WireNode, and cugl::scene2::PolygonNode.
|
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.
flag | whether to flip the coordinates horizontally |
|
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.
flag | whether to flip the coordinates vertically |
|
protectedvirtual |
Allocates the render data necessary to render this node.
|
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.
|
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.
|
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.
|
inline |
Returns the gradient to use for this polygon.
Unlike colors, gradients are local. They do not apply to the children of this node.
|
inline |
Returns the texture polygon for this scene graph node
|
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.
|
inline |
Returns the texture used by this node.
|
inline |
Returns the texture used by this node.
|
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.
Reimplemented from cugl::scene2::SceneNode.
|
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.
poly | The polygon to texture |
|
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.
rect | The rectangle to texture |
|
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.
vertices | The vertices to texture (expressed in image space) |
|
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
loader | The scene loader passing this JSON file |
data | The JSON object specifying the node |
Reimplemented from cugl::scene2::SceneNode.
Reimplemented in cugl::scene2::PathNode, cugl::scene2::WireNode, and cugl::scene2::AnimationNode.
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.
filename | A path to image file, e.g., "scene1/earthtile.png" |
bool cugl::scene2::TexturedNode::initWithFile | ( | const std::string & | filename, |
const Poly2 & | poly | ||
) |
Initializes a textured polygon from the image filename and the given polygon.
filename | A path to image file, e.g., "scene1/earthtile.png" |
poly | The polygon to texture |
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.
filename | A path to image file, e.g., "scene1/earthtile.png" |
rect | The rectangle to texture |
|
inline |
Initializes a textured polygon from the image filename and the given vertices.
The polygon indices will be subclass specific.
filename | A path to image file, e.g., "scene1/earthtile.png" |
vertices | The vertices to texture (expressed in image space) |
bool cugl::scene2::TexturedNode::initWithTexture | ( | const std::shared_ptr< Texture > & | texture | ) |
|
inline |
Initializes a textured polygon from a Texture object and the given vertices.
The polygon indices will be subclass specific.
texture | A shared pointer to a Texture object. |
vertices | The vertices to texture (expressed in image space) |
|
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.
|
inline |
Returns true if the texture coordinates are flipped horizontally.
|
inline |
Returns true if the texture coordinates are flipped vertically.
|
inline |
Refreshes this node to restore the render data.
|
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.
flag | Whether if this node is using absolute positioning. |
|
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.
anchor | The anchor point of node. |
Reimplemented from cugl::scene2::SceneNode.
|
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.
equation | Specifies how source and destination colors are combined |
|
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.
srcFactor | Specifies how the source blending factors are computed |
dstFactor | Specifies how the destination blending factors are computed. |
|
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.
size | The untransformed size of the node. |
Reimplemented from cugl::scene2::SceneNode.
|
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.
width | The untransformed width of the node. |
height | The untransformed height of the node. |
Reimplemented from cugl::scene2::SceneNode.
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.
gradient | The gradient to use for this polygon. |
|
virtual |
Sets the polygon to the given one in texture space.
poly | The polygon to texture |
Reimplemented in cugl::scene2::PathNode, cugl::scene2::WireNode, and cugl::scene2::PolygonNode.
|
pure virtual |
Sets the texture polygon to one equivalent to the given rect.
The conversion of rectangle to polygon is subclass specific.
rect | The rectangle to texture |
Implemented in cugl::scene2::PathNode, cugl::scene2::WireNode, and cugl::scene2::PolygonNode.
|
pure virtual |
Sets the polgon to the vertices expressed in texture space.
The polygon indices will be subclass specific.
vertices | The vertices to texture |
Implemented in cugl::scene2::PathNode, cugl::scene2::WireNode, and cugl::scene2::PolygonNode.
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.
texture | A shared pointer to a Texture object. |
|
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.
filename | A path to image file, e.g., "scene1/earthtile.png" |
|
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.
dx | The amount to shift horizontally. |
dy | The amount to shift horizontally. |
|
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.
verbose | Whether to include class information |
Reimplemented from cugl::scene2::SceneNode.
|
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.
|
protected |
Whether to disable anchors and draw the polygon in absolute coordinates
|
protected |
The blending equation for this texture
|
protected |
The class name for the specific subclass
|
protected |
The destination factor for the blend function
|
protected |
Whether or not to flip the texture horizontally
|
protected |
Whether or not to flip the texture vertically
|
protected |
The gradient to use for this polygon
|
protected |
The render data for this node
|
protected |
The polygon defining this node, with vertices in texture space
|
protected |
Whether we have generated render data for this node
|
protected |
The active gradient to use in the sprite batch pass
|
protected |
The source factor for the blend function
|
protected |
Whether to stretch the image to match the content size
|
protected |
Texture to be applied to the polygon