Example #1
0
  /**
   * Initializes an sprite with an image filepath. The rect used will be the size of the image. The
   * offset will be (0,0).
   */
  public CCSprite(String filepath) {
    assert filepath != null : "Invalid filename for sprite";

    CCTexture2D texture = CCTextureCache.sharedTextureCache().addImage(filepath);
    if (texture != null) {
      CGRect rect = CGRect.make(0, 0, 0, 0);
      rect.size = texture.getContentSize();
      init(texture, rect);
    } else {
      ccMacros.CCLOGERROR("CCSprite", "Unable to load texture from file: " + filepath);
    }
  }
Example #2
0
 /** returns whether or not a CCSpriteFrame is being displayed */
 public boolean isFrameDisplayed(CCSpriteFrame frame) {
   CGRect r = frame.rect_;
   CGPoint p = frame.offset_;
   return (CGRect.equalToRect(r, rect_)
       && frame.getTexture().name() == this.getTexture().name()
       && CGPoint.equalToPoint(p, offsetPosition_));
 }
Example #3
0
  private void setTextureRect(
      float x, float y, float w, float h, float sw, float sh, boolean rotated) {
    rect_.set(x, y, w, h);
    rectRotated_ = rotated;

    setContentSize(sw, sh);
    updateTextureCoords(rect_);

    float relativeOffsetX = unflippedOffsetPositionFromCenter_.x;
    float relativeOffsetY = unflippedOffsetPositionFromCenter_.y;

    // issue #732
    if (flipX_) relativeOffsetX = -relativeOffsetX;
    if (flipY_) relativeOffsetY = -relativeOffsetY;

    offsetPosition_.x = relativeOffsetX + (contentSize_.width - rect_.size.width) / 2;
    offsetPosition_.y = relativeOffsetY + (contentSize_.height - rect_.size.height) / 2;

    // rendering using SpriteSheet
    if (usesSpriteSheet_) {
      // update dirty_, don't update recursiveDirty_
      dirty_ = true;
    } else { // self rendering
      // Atlas: Vertex
      float x1 = 0 + offsetPosition_.x;
      float y1 = 0 + offsetPosition_.y;
      float x2 = x1 + w;
      float y2 = y1 + h;

      // Don't update Z.
      vertexes.position(0);
      tmpV[0] = x1;
      tmpV[1] = y2;
      tmpV[2] = 0;
      tmpV[3] = x1;
      tmpV[4] = y1;
      tmpV[5] = 0;
      tmpV[6] = x2;
      tmpV[7] = y2;
      tmpV[8] = 0;
      tmpV[9] = x2;
      tmpV[10] = y1;
      tmpV[11] = 0;
      BufferUtils.copyFloats(tmpV, 0, vertexes, 12);
      //            vertexes.put(x1);
      //            vertexes.put(y2);
      //            vertexes.put(0);
      //            vertexes.put(x1);
      //            vertexes.put(y1);
      //            vertexes.put(0);
      //            vertexes.put(x2);
      //            vertexes.put(y2);
      //            vertexes.put(0);
      //            vertexes.put(x2);
      //            vertexes.put(y1);
      //            vertexes.put(0);
      vertexes.position(0);
    }
  }
Example #4
0
  /**
   * Initializes an sprite with a CGImageRef and a key The key is used by the CCTextureCache to know
   * if a texture was already created with this CGImage. For example, a valid key
   * is: @"sprite_frame_01". If key is nil, then a new texture will be created each time by the
   * CCTextureCache.
   *
   * @since v0.99.0
   */
  public CCSprite(Bitmap image, String key) {
    assert image != null : "Invalid CGImageRef for sprite";

    // XXX: possible bug. See issue #349. New API should be added
    CCTexture2D texture = CCTextureCache.sharedTextureCache().addImage(image, key);

    CGSize size = texture.getContentSize();
    CGRect rect = CGRect.make(0, 0, size.width, size.height);

    init(texture, rect);
  }
Example #5
0
  protected void init() {
    texCoords = BufferProvider.createFloatBuffer(4 * 2);
    vertexes = BufferProvider.createFloatBuffer(4 * 3);
    colors = BufferProvider.createFloatBuffer(4 * 4);

    dirty_ = false;
    recursiveDirty_ = false;

    // zwoptex default values
    offsetPosition_ = CGPoint.zero();
    unflippedOffsetPositionFromCenter_ = new CGPoint();
    rect_ = CGRect.make(0, 0, 1, 1);

    // by default use "Self Render".
    // if the sprite is added to an SpriteSheet,
    // then it will automatically switch to "SpriteSheet Render"
    useSelfRender();

    opacityModifyRGB_ = true;
    opacity_ = 255;
    color_ = new ccColor3B(ccColor3B.ccWHITE);
    colorUnmodified_ = new ccColor3B(ccColor3B.ccWHITE);

    // update texture (calls updateBlendFunc)
    setTexture(null);

    flipY_ = flipX_ = false;

    // lazy alloc
    animations_ = null;

    // default transform anchor: center
    anchorPoint_.set(0.5f, 0.5f);

    honorParentTransform_ = CC_HONOR_PARENT_TRANSFORM_ALL;
    hasChildren_ = false;

    // Atlas: Color
    colors.put(1.0f).put(1.0f).put(1.0f).put(1.0f);
    colors.put(1.0f).put(1.0f).put(1.0f).put(1.0f);
    colors.put(1.0f).put(1.0f).put(1.0f).put(1.0f);
    colors.put(1.0f).put(1.0f).put(1.0f).put(1.0f);
    colors.position(0);

    // Atlas: Vertex
    // updated in "useSelfRender"
    // Atlas: TexCoords
    setTextureRect(0, 0, 0, 0, rectRotated_);
  }
  @Override
  public boolean ccTouchesBegan(MotionEvent event) {
    CGPoint touchLocation = CGPoint.make(event.getX(), event.getY());

    touchLocation = CCDirector.sharedDirector().convertToGL(touchLocation);
    touchLocation = this.convertToNodeSpace(touchLocation);

    // Verifica toque no bot��o

    for (int i = 0; i < imagens.length; i++) {
      if (CGRect.containsPoint(this.imagens[i].getBoundingBox(), touchLocation)) {
        this.buttonClicked(imagens[i]);
      }
    }
    return true;
  }
Example #7
0
/**
 * CCSprite is a 2d image ( http://en.wikipedia.org/wiki/Sprite_(computer_graphics) )
 *
 * <p>CCSprite can be created with an image, or with a sub-rectangle of an image.
 *
 * <p>If the parent or any of its ancestors is a CCSpriteSheet then the following
 * features/limitations are valid - Features when the parent is a CCSpriteSheet: - MUCH faster
 * rendering, specially if the CCSpriteSheet has many children. All the children will be drawn in a
 * single batch.
 *
 * <p>- Limitations - Camera is not supported yet (eg: CCOrbitCamera action doesn't work) - GridBase
 * actions are not supported (eg: CCLens, CCRipple, CCTwirl) - The Alias/Antialias property belongs
 * to CCSpriteSheet, so you can't individually set the aliased property. - The Blending function
 * property belongs to CCSpriteSheet, so you can't individually set the blending function property.
 * - Parallax scroller is not supported, but can be simulated with a "proxy" sprite.
 *
 * <p>If the parent is an standard CCNode, then CCSprite behaves like any other CCNode: - It
 * supports blending functions - It supports aliasing / antialiasing - But the rendering will be
 * slower: 1 draw per children.
 */
public class CCSprite extends CCNode implements CCRGBAProtocol, CCTextureProtocol {

  // XXX: Optmization
  class TransformValues {
    CGPoint pos; // position x and y
    CGPoint scale; // scale x and y
    float rotation;
    CGPoint ap; // anchor point in pixels
  }

  /// CCSprite invalid index on the CCSpriteSheet
  public static final int CCSpriteIndexNotInitialized = 0xffffffff;

  /**
   * Whether or not an CCSprite will rotate, scale or translate with it's parent. Useful in health
   * bars, when you want that the health bar translates with it's parent but you don't want it to
   * rotate with its parent.
   *
   * @since v0.99.0
   */
  // ! Translate with it's parent
  public static final int CC_HONOR_PARENT_TRANSFORM_TRANSLATE = 1 << 0;
  // ! Rotate with it's parent
  public static final int CC_HONOR_PARENT_TRANSFORM_ROTATE = 1 << 1;
  // ! Scale with it's parent
  public static final int CC_HONOR_PARENT_TRANSFORM_SCALE = 1 << 2;

  // ! All possible transformation enabled. Default value.
  public static final int CC_HONOR_PARENT_TRANSFORM_ALL =
      CC_HONOR_PARENT_TRANSFORM_TRANSLATE
          | CC_HONOR_PARENT_TRANSFORM_ROTATE
          | CC_HONOR_PARENT_TRANSFORM_SCALE;

  // Animations that belong to the sprite
  private HashMap<String, CCAnimation> animations_;

  // image is flipped
  /**
   * whether or not the sprite is flipped vertically. It only flips the texture of the sprite, and
   * not the texture of the sprite's children. Also, flipping the texture doesn't alter the
   * anchorPoint. If you want to flip the anchorPoint too, and/or to flip the children too use:
   * sprite.scaleY *= -1;
   */
  public boolean flipY_;

  /**
   * whether or not the sprite is flipped horizontally. It only flips the texture of the sprite, and
   * not the texture of the sprite's children. Also, flipping the texture doesn't alter the
   * anchorPoint. If you want to flip the anchorPoint too, and/or to flip the children too use:
   * sprite.scaleX *= -1;
   */
  public boolean flipX_;

  // opacity and RGB protocol
  /** opacity: conforms to CCRGBAProtocol protocol */
  int opacity_;

  public int getOpacity() {
    return opacity_;
  }

  public void setOpacity(int anOpacity) {
    opacity_ = anOpacity;

    // special opacity for premultiplied textures
    if (opacityModifyRGB_) setColor(colorUnmodified_);
    updateColor();
  }

  /** RGB colors: conforms to CCRGBAProtocol protocol */
  ccColor3B color_;

  ccColor3B colorUnmodified_;
  boolean opacityModifyRGB_;

  public void setOpacityModifyRGB(boolean modify) {
    if (opacityModifyRGB_ != modify) {
      ccColor3B oldColor = this.color_;
      opacityModifyRGB_ = modify;
      setColor(oldColor);
    }
  }

  public ccColor3B getColor() {
    if (opacityModifyRGB_) {
      return new ccColor3B(colorUnmodified_);
    }
    return new ccColor3B(color_);
  }

  public void setColor(ccColor3B color3) {
    color_.set(color3);
    colorUnmodified_.set(color3);

    if (opacityModifyRGB_) {
      color_.r = color3.r * opacity_ / 255;
      color_.g = color3.g * opacity_ / 255;
      color_.b = color3.b * opacity_ / 255;
    }

    updateColor();
  }

  //
  // Data used when the sprite is self-rendered
  //
  CCTexture2D texture_; // Texture used to render the sprite

  /** conforms to CCTextureProtocol protocol */
  protected ccBlendFunc blendFunc_ = new ccBlendFunc(ccConfig.CC_BLEND_SRC, ccConfig.CC_BLEND_DST);

  // texture pixels
  CGRect rect_ = CGRect.zero();
  Boolean rectRotated_ = false;

  /**
   * offset position of the sprite. Calculated automatically by editors like Zwoptex.
   *
   * @since v0.99.0
   */
  CGPoint offsetPosition_; // absolute

  CGPoint unflippedOffsetPositionFromCenter_;

  //
  // Data used when the sprite is rendered using a CCSpriteSheet
  //
  /** weak reference of the CCTextureAtlas used when the sprite is rendered using a CCSpriteSheet */
  CCTextureAtlas textureAtlas_;

  /**
   * The index used on the TextureATlas. Don't modify this value unless you know what you are doing
   */
  public int atlasIndex; // Absolute (real) Index on the SpriteSheet

  /** weak reference to the CCSpriteSheet that renders the CCSprite */
  CCSpriteSheet spriteSheet_;

  // whether or not to transform according to its parent transformations
  /**
   * whether or not to transform according to its parent transfomrations. Useful for health bars.
   * eg: Don't rotate the health bar, even if the parent rotates. IMPORTANT: Only valid if it is
   * rendered using an CCSpriteSheet.
   *
   * @since v0.99.0
   */
  int honorParentTransform_;

  /** whether or not the Sprite needs to be updated in the Atlas */
  boolean dirty_; // Sprite needs to be updated

  boolean recursiveDirty_; // Subchildren needs to be updated
  boolean hasChildren_; // optimization to check if it contain children

  // vertex coords, texture coords and color info
  /** buffers that are going to be rendered */
  /** the quad (tex coords, vertex coords and color) information */
  private FloatBuffer texCoords;

  public float[] getTexCoordsArray() {
    float ret[] = new float[texCoords.limit()];
    texCoords.get(ret, 0, texCoords.limit());
    return ret;
  }

  private FloatBuffer vertexes;

  public float[] getVertexArray() {
    float ret[] = new float[vertexes.limit()];
    vertexes.get(ret, 0, vertexes.limit());
    return ret;
  }

  public FloatBuffer getTexCoords() {
    texCoords.position(0);
    return texCoords;
  }

  public FloatBuffer getVertices() {
    vertexes.position(0);
    return vertexes;
  }

  private FloatBuffer colors;

  // whether or not it's parent is a CCSpriteSheet
  /** whether or not the Sprite is rendered using a CCSpriteSheet */
  boolean usesSpriteSheet_;

  public CGRect getTextureRect() {
    return rect_;
  }

  public Boolean getTextureRectRotated() {
    return rectRotated_;
  }

  /**
   * Creates an sprite with a texture. The rect used will be the size of the texture. The offset
   * will be (0,0).
   */
  public static CCSprite sprite(CCTexture2D texture) {
    return new CCSprite(texture);
  }

  /** Creates an sprite with a texture and a rect. The offset will be (0,0). */
  public static CCSprite sprite(CCTexture2D texture, CGRect rect) {
    return new CCSprite(texture, rect);
  }

  /** Creates an sprite with an sprite frame. */
  public static CCSprite sprite(CCSpriteFrame spriteFrame) {
    return new CCSprite(spriteFrame);
  }

  /**
   * Creates an sprite with an sprite frame name. An CCSpriteFrame will be fetched from the
   * CCSpriteFrameCache by name. If the CCSpriteFrame doesn't exist it will raise an exception.
   *
   * @since v0.9
   */
  public static CCSprite sprite(String spriteFrameName, boolean isFrame) {
    return new CCSprite(spriteFrameName, isFrame);
  }

  /**
   * Creates an sprite with an image filepath. The rect used will be the size of the image. The
   * offset will be (0,0).
   */
  public static CCSprite sprite(String filepath) {
    return new CCSprite(filepath);
  }

  /** Creates an sprite with an image filepath and a rect. The offset will be (0,0). */
  public static CCSprite sprite(String filepath, CGRect rect) {
    return new CCSprite(filepath, rect);
  }

  /**
   * Creates an sprite with a CGImageRef. BE AWARE OF the fact that copy of image is stored in
   * memory, use assets method if you can.
   *
   * @deprecated Use spriteWithCGImage:key: instead. Will be removed in v1.0 final
   */
  public static CCSprite sprite(Bitmap image) {
    return new CCSprite(image);
  }

  /**
   * Creates an sprite with a CGImageRef and a key. The key is used by the CCTextureCache to know if
   * a texture was already created with this CGImage. For example, a valid key
   * is: @"sprite_frame_01". If key is nil, then a new texture will be created each time by the
   * CCTextureCache.
   *
   * <p>BE AWARE OF the fact that copy of image is stored in memory, use assets method if you can.
   *
   * @since v0.99.0
   */
  public static CCSprite sprite(Bitmap image, String key) {
    return new CCSprite(image, key);
  }

  /** Creates an sprite with an CCSpriteSheet and a rect */
  public static CCSprite sprite(CCSpriteSheet spritesheet, CGRect rect) {
    return new CCSprite(spritesheet, rect);
  }

  /**
   * Initializes an sprite with a texture. The rect used will be the size of the texture. The offset
   * will be (0,0).
   */
  public CCSprite(CCTexture2D texture) {
    CGSize size = texture.getContentSize();
    CGRect rect = CGRect.make(0, 0, size.width, size.height);
    init(texture, rect);
  }

  public CCSprite(CCTexture2D texture, CGRect rect) {
    init(texture, rect);
  }

  /** Initializes an sprite with a texture and a rect. The offset will be (0,0). */
  protected void init(CCTexture2D texture, CGRect rect) {
    assert texture != null : "Invalid texture for sprite";
    // IMPORTANT: [self init] and not [super init];
    init();
    setTexture(texture);
    setTextureRect(rect);
  }

  /** Initializes an sprite with an sprite frame. */
  public CCSprite(CCSpriteFrame spriteFrame) {
    init(spriteFrame);
  }

  protected void init(CCSpriteFrame spriteFrame) {
    assert spriteFrame != null : "Invalid spriteFrame for sprite";

    rectRotated_ = spriteFrame.rotated_;
    init(spriteFrame.getTexture(), spriteFrame.getRect());
    setDisplayFrame(spriteFrame);
  }

  /**
   * Initializes an sprite with an sprite frame name. An CCSpriteFrame will be fetched from the
   * CCSpriteFrameCache by name. If the CCSpriteFrame doesn't exist it will raise an exception.
   *
   * @since v0.9
   */
  public CCSprite(String spriteFrameName, boolean isFrame) {
    assert spriteFrameName != null : "Invalid spriteFrameName for sprite";
    CCSpriteFrame frame =
        CCSpriteFrameCache.sharedSpriteFrameCache().getSpriteFrame(spriteFrameName);
    init(frame);
  }

  /**
   * Initializes an sprite with an image filepath. The rect used will be the size of the image. The
   * offset will be (0,0).
   */
  public CCSprite(String filepath) {
    assert filepath != null : "Invalid filename for sprite";

    CCTexture2D texture = CCTextureCache.sharedTextureCache().addImage(filepath);
    if (texture != null) {
      CGRect rect = CGRect.make(0, 0, 0, 0);
      rect.size = texture.getContentSize();
      init(texture, rect);
    } else {
      ccMacros.CCLOGERROR("CCSprite", "Unable to load texture from file: " + filepath);
    }
  }

  public CCSprite() {
    init();
  }

  /** Initializes an sprite with an image filepath, and a rect. The offset will be (0,0). */
  public CCSprite(String filepath, CGRect rect) {
    assert filepath != null : "Invalid filename for sprite";

    CCTexture2D texture = CCTextureCache.sharedTextureCache().addImage(filepath);
    if (texture != null) {
      init(texture, rect);
    }
  }

  /**
   * Initializes an sprite with a CGImageRef
   *
   * @deprecated Use spriteWithCGImage:key: instead. Will be removed in v1.0 final
   */
  public CCSprite(Bitmap image) {
    assert image != null : "Invalid CGImageRef for sprite";

    // XXX: possible bug. See issue #349. New API should be added
    String key = image.toString();
    CCTexture2D texture = CCTextureCache.sharedTextureCache().addImage(image, key);

    CGSize size = texture.getContentSize();
    CGRect rect = CGRect.make(0, 0, size.width, size.height);

    init(texture, rect);
  }

  /**
   * Initializes an sprite with a CGImageRef and a key The key is used by the CCTextureCache to know
   * if a texture was already created with this CGImage. For example, a valid key
   * is: @"sprite_frame_01". If key is nil, then a new texture will be created each time by the
   * CCTextureCache.
   *
   * @since v0.99.0
   */
  public CCSprite(Bitmap image, String key) {
    assert image != null : "Invalid CGImageRef for sprite";

    // XXX: possible bug. See issue #349. New API should be added
    CCTexture2D texture = CCTextureCache.sharedTextureCache().addImage(image, key);

    CGSize size = texture.getContentSize();
    CGRect rect = CGRect.make(0, 0, size.width, size.height);

    init(texture, rect);
  }

  /** Initializes an sprite with an CCSpriteSheet and a rect */
  public CCSprite(CCSpriteSheet spritesheet, CGRect rect) {
    init(spritesheet.getTexture(), rect);
    useSpriteSheetRender(spritesheet);
  }

  /** updates the texture rect of the CCSprite. */
  public void setTextureRect(float x, float y, float w, float h, Boolean rotated) {
    setTextureRect(x, y, w, h, w, h, rotated);
  }

  public void setTextureRect(CGRect rect, Boolean rotated) {
    setTextureRect(rect, rect.size, rotated);
  }

  public void setTextureRect(CGRect rect) {
    setTextureRect(rect, rectRotated_);
  }

  /**
   * tell the sprite to use self-render.
   *
   * @since v0.99.0
   */
  public void useSelfRender() {
    atlasIndex = CCSpriteIndexNotInitialized;
    usesSpriteSheet_ = false;
    textureAtlas_ = null;
    spriteSheet_ = null;
    dirty_ = recursiveDirty_ = false;

    float x1 = 0 + offsetPosition_.x;
    float y1 = 0 + offsetPosition_.y;
    float x2 = x1 + rect_.size.width;
    float y2 = y1 + rect_.size.height;

    vertexes.position(0);
    tmpV[0] = x1;
    tmpV[1] = y2;
    tmpV[2] = 0;
    tmpV[3] = x1;
    tmpV[4] = y1;
    tmpV[5] = 0;
    tmpV[6] = x2;
    tmpV[7] = y2;
    tmpV[8] = 0;
    tmpV[9] = x2;
    tmpV[10] = y1;
    tmpV[11] = 0;
    BufferUtils.copyFloats(tmpV, 0, vertexes, 12);
    //        vertexes.put(x1);
    //        vertexes.put(y2);
    //        vertexes.put(0);
    //        vertexes.put(x1);
    //        vertexes.put(y1);
    //        vertexes.put(0);
    //        vertexes.put(x2);
    //        vertexes.put(y2);
    //        vertexes.put(0);
    //        vertexes.put(x2);
    //        vertexes.put(y1);
    //        vertexes.put(0);
    vertexes.position(0);
  }

  /**
   * tell the sprite to use sprite sheet render.
   *
   * @since v0.99.0
   */
  public void useSpriteSheetRender(CCSpriteSheet spriteSheet) {
    usesSpriteSheet_ = true;
    textureAtlas_ = spriteSheet.getTextureAtlas(); // weak ref
    spriteSheet_ = spriteSheet; // weak ref
  }

  protected void init() {
    texCoords = BufferProvider.createFloatBuffer(4 * 2);
    vertexes = BufferProvider.createFloatBuffer(4 * 3);
    colors = BufferProvider.createFloatBuffer(4 * 4);

    dirty_ = false;
    recursiveDirty_ = false;

    // zwoptex default values
    offsetPosition_ = CGPoint.zero();
    unflippedOffsetPositionFromCenter_ = new CGPoint();
    rect_ = CGRect.make(0, 0, 1, 1);

    // by default use "Self Render".
    // if the sprite is added to an SpriteSheet,
    // then it will automatically switch to "SpriteSheet Render"
    useSelfRender();

    opacityModifyRGB_ = true;
    opacity_ = 255;
    color_ = new ccColor3B(ccColor3B.ccWHITE);
    colorUnmodified_ = new ccColor3B(ccColor3B.ccWHITE);

    // update texture (calls updateBlendFunc)
    setTexture(null);

    flipY_ = flipX_ = false;

    // lazy alloc
    animations_ = null;

    // default transform anchor: center
    anchorPoint_.set(0.5f, 0.5f);

    honorParentTransform_ = CC_HONOR_PARENT_TRANSFORM_ALL;
    hasChildren_ = false;

    // Atlas: Color
    colors.put(1.0f).put(1.0f).put(1.0f).put(1.0f);
    colors.put(1.0f).put(1.0f).put(1.0f).put(1.0f);
    colors.put(1.0f).put(1.0f).put(1.0f).put(1.0f);
    colors.put(1.0f).put(1.0f).put(1.0f).put(1.0f);
    colors.position(0);

    // Atlas: Vertex
    // updated in "useSelfRender"
    // Atlas: TexCoords
    setTextureRect(0, 0, 0, 0, rectRotated_);
  }

  /** sets a new display frame to the CCSprite. */
  public void setDisplayFrame(CCSpriteFrame frame) {
    unflippedOffsetPositionFromCenter_.set(frame.offset_);

    CCTexture2D newTexture = frame.getTexture();
    // update texture before updating texture rect
    if (texture_ == null || newTexture.name() != texture_.name()) setTexture(newTexture);

    // update rect
    setTextureRect(frame.rect_, frame.originalSize_, frame.rotated_);
  }

  /** changes the display frame based on an animation and an index. */
  public void setDisplayFrame(String animationName, int frameIndex) {
    if (animations_ == null) initAnimationDictionary();

    CCAnimation anim = animations_.get(animationName);
    CCSpriteFrame frame = (CCSpriteFrame) anim.frames().get(frameIndex);
    setDisplayFrame(frame);
  }

  @Override
  public void setVisible(boolean v) {
    if (v != visible_) {
      super.setVisible(v);
      if (usesSpriteSheet_ && !recursiveDirty_) {
        dirty_ = recursiveDirty_ = true;
        if (children_ != null)
          for (CCNode child : children_) {
            child.setVisible(v);
          }
      }
    }
  }

  /** adds an Animation to the Sprite. */
  public void addAnimation(CCAnimation anim) {
    // lazy alloc
    if (animations_ == null) initAnimationDictionary();

    animations_.put(anim.name(), anim);
  }

  /** returns an Animation given it's name. */
  public CCAnimation animationByName(String animationName) {
    assert animationName != null : "animationName parameter must be non null";
    return animations_.get(animationName);
  }

  private static final ccColor4B tmpColor4B = ccColor4B.ccc4(0, 0, 0, 0);
  private static final ccColor4B[] tmpColors =
      new ccColor4B[] {tmpColor4B, tmpColor4B, tmpColor4B, tmpColor4B};

  public void updateColor() {
    float tmpR = color_.r / 255.f;
    float tmpG = color_.g / 255.f;
    float tmpB = color_.b / 255.f;
    float tmpA = opacity_ / 255.f;

    colors
        .put(tmpR)
        .put(tmpG)
        .put(tmpB)
        .put(tmpA)
        .put(tmpR)
        .put(tmpG)
        .put(tmpB)
        .put(tmpA)
        .put(tmpR)
        .put(tmpG)
        .put(tmpB)
        .put(tmpA)
        .put(tmpR)
        .put(tmpG)
        .put(tmpB)
        .put(tmpA);
    colors.position(0);

    // renders using Sprite Manager
    if (usesSpriteSheet_) {
      if (atlasIndex != CCSpriteIndexNotInitialized) {
        tmpColor4B.r = color_.r;
        tmpColor4B.g = color_.g;
        tmpColor4B.b = color_.b;
        tmpColor4B.a = opacity_;
        textureAtlas_.updateColor(tmpColors, atlasIndex);

      } else {
        // no need to set it recursively
        // update dirty_, don't update recursiveDirty_
        dirty_ = true;
      }
    }
    // self render
    // do nothing
  }

  public void setFlipX(boolean b) {
    if (flipX_ != b) {
      flipX_ = b;
      setTextureRect(rect_);
    }
  }

  public boolean getFlipX() {
    return flipX_;
  }

  public void setFlipY(boolean b) {
    if (flipY_ != b) {
      flipY_ = b;
      setTextureRect(rect_);
    }
  }

  public boolean getFlipY() {
    return flipY_;
  }

  public void setTexture(CCTexture2D texture) {
    assert !usesSpriteSheet_
        : "CCSprite: setTexture doesn't work when the sprite is rendered using a CCSpriteSheet";

    // accept texture==nil as argument
    assert (texture == null || texture instanceof CCTexture2D)
        : "setTexture expects a CCTexture2D. Invalid argument";
    texture_ = texture;
    updateBlendFunc();
  }

  public CCTexture2D getTexture() {
    return texture_;
  }

  /** returns whether or not a CCSpriteFrame is being displayed */
  public boolean isFrameDisplayed(CCSpriteFrame frame) {
    CGRect r = frame.rect_;
    CGPoint p = frame.offset_;
    return (CGRect.equalToRect(r, rect_)
        && frame.getTexture().name() == this.getTexture().name()
        && CGPoint.equalToPoint(p, offsetPosition_));
  }

  /** returns the current displayed frame. */
  public CCSpriteFrame displayedFrame() {
    return CCSpriteFrame.frame(getTexture(), rect_, CGPoint.zero());
  }

  // XXX HACK: optimization
  private void SET_DIRTY_RECURSIVELY() {
    if (usesSpriteSheet_ && !recursiveDirty_) {
      dirty_ = recursiveDirty_ = true;
      if (hasChildren_) setDirtyRecursively(true);
    }
  }

  private void updateBlendFunc() {
    assert !usesSpriteSheet_
        : "CCSprite: updateBlendFunc doesn't work when the sprite is rendered using a CCSpriteSheet";

    // it's possible to have an untextured sprite
    if (texture_ == null || !texture_.hasPremultipliedAlpha()) {
      blendFunc_.src = GL10.GL_SRC_ALPHA;
      blendFunc_.dst = GL10.GL_ONE_MINUS_SRC_ALPHA;
      setOpacityModifyRGB(false);
    } else {
      blendFunc_.src = ccConfig.CC_BLEND_SRC;
      blendFunc_.dst = ccConfig.CC_BLEND_DST;
      setOpacityModifyRGB(true);
    }
  }

  private void initAnimationDictionary() {
    animations_ = new HashMap<String, CCAnimation>();
  }

  private void setTextureRect(CGRect rect, CGSize size, Boolean rotated) {
    setTextureRect(
        rect.origin.x,
        rect.origin.y,
        rect.size.width,
        rect.size.height,
        size.width,
        size.height,
        rotated);
  }

  private void setTextureRect(
      float x, float y, float w, float h, float sw, float sh, boolean rotated) {
    rect_.set(x, y, w, h);
    rectRotated_ = rotated;

    setContentSize(sw, sh);
    updateTextureCoords(rect_);

    float relativeOffsetX = unflippedOffsetPositionFromCenter_.x;
    float relativeOffsetY = unflippedOffsetPositionFromCenter_.y;

    // issue #732
    if (flipX_) relativeOffsetX = -relativeOffsetX;
    if (flipY_) relativeOffsetY = -relativeOffsetY;

    offsetPosition_.x = relativeOffsetX + (contentSize_.width - rect_.size.width) / 2;
    offsetPosition_.y = relativeOffsetY + (contentSize_.height - rect_.size.height) / 2;

    // rendering using SpriteSheet
    if (usesSpriteSheet_) {
      // update dirty_, don't update recursiveDirty_
      dirty_ = true;
    } else { // self rendering
      // Atlas: Vertex
      float x1 = 0 + offsetPosition_.x;
      float y1 = 0 + offsetPosition_.y;
      float x2 = x1 + w;
      float y2 = y1 + h;

      // Don't update Z.
      vertexes.position(0);
      tmpV[0] = x1;
      tmpV[1] = y2;
      tmpV[2] = 0;
      tmpV[3] = x1;
      tmpV[4] = y1;
      tmpV[5] = 0;
      tmpV[6] = x2;
      tmpV[7] = y2;
      tmpV[8] = 0;
      tmpV[9] = x2;
      tmpV[10] = y1;
      tmpV[11] = 0;
      BufferUtils.copyFloats(tmpV, 0, vertexes, 12);
      //            vertexes.put(x1);
      //            vertexes.put(y2);
      //            vertexes.put(0);
      //            vertexes.put(x1);
      //            vertexes.put(y1);
      //            vertexes.put(0);
      //            vertexes.put(x2);
      //            vertexes.put(y2);
      //            vertexes.put(0);
      //            vertexes.put(x2);
      //            vertexes.put(y1);
      //            vertexes.put(0);
      vertexes.position(0);
    }
  }

  // XXX: Optimization: instead of calling 5 times the parent sprite to obtain: position, scale.x,
  // scale.y, anchorpoint and rotation,
  // this fuction return the 5 values in 1 single call
  protected TransformValues getTransformValues() {
    TransformValues tv = new TransformValues();
    tv.pos = position_;
    tv.scale = CGPoint.ccp(scaleX_, scaleY_);
    tv.rotation = rotation_;
    tv.ap = anchorPointInPixels_;

    return tv;
  }

  public boolean doesOpacityModifyRGB() {
    return opacityModifyRGB_;
  }

  public void setDirtyRecursively(boolean b) {
    dirty_ = recursiveDirty_ = b;
    // recursively set dirty
    if (hasChildren_) {
      for (CCNode child : children_) {
        CCSprite sprite = (CCSprite) child;
        sprite.setDirtyRecursively(true);
      }
    }
  }

  public void setPosition(CGPoint pos) {
    super.setPosition(pos);
    SET_DIRTY_RECURSIVELY();
  }

  @Override
  public void setPosition(float x, float y) {
    super.setPosition(x, y);
    SET_DIRTY_RECURSIVELY();
  }

  public void setRotation(float rot) {
    super.setRotation(rot);
    SET_DIRTY_RECURSIVELY();
  }

  public void setScaleX(float sx) {
    super.setScaleX(sx);
    SET_DIRTY_RECURSIVELY();
  }

  public void setScaleY(float sy) {
    super.setScaleY(sy);
    SET_DIRTY_RECURSIVELY();
  }

  public void setScale(float s) {
    super.setScale(s);
    SET_DIRTY_RECURSIVELY();
  }

  public void setVertexZ(float z) {
    super.setVertexZ(z);
    SET_DIRTY_RECURSIVELY();
  }

  public void setAnchorPoint(CGPoint anchor) {
    super.setAnchorPoint(anchor);
    SET_DIRTY_RECURSIVELY();
  }

  public void setRelativeAnchorPoint(boolean relative) {
    assert !usesSpriteSheet_ : "relativeTransformAnchor is invalid in CCSprite";
    super.setRelativeAnchorPoint(relative);
  }

  public void reorderChild(CCNode child, int z) {
    // assert child != null: "Child must be non-nil";
    // assert children_.has(child): "Child doesn't belong to Sprite";

    if (z == child.getZOrder()) return;

    if (usesSpriteSheet_) {
      // XXX: Instead of removing/adding, it is more efficient to reorder manually
      removeChild(child, false);
      addChild(child, z);
    } else {
      super.reorderChild(child, z);
    }
  }

  @Override
  public CCNode addChild(CCNode child, int z, int aTag) {
    super.addChild(child, z, aTag);

    if (child instanceof CCSprite && usesSpriteSheet_) {
      CCSprite sprite = (CCSprite) child;
      int index = spriteSheet_.atlasIndex(sprite, z);
      spriteSheet_.insertChild(sprite, index);
    }

    hasChildren_ = true;

    return this;
  }

  public void removeChild(CCNode node, boolean doCleanup) {
    if (usesSpriteSheet_) {
      CCSprite sprite = (CCSprite) node;
      spriteSheet_.removeSpriteFromAtlas(sprite);
    }

    super.removeChild(node, doCleanup);

    hasChildren_ = (children_.size() > 0);
  }

  public void removeAllChildren(boolean doCleanup) {
    if (usesSpriteSheet_) {
      for (CCNode child : children_) {
        CCSprite sprite = (CCSprite) child;
        spriteSheet_.removeSpriteFromAtlas(sprite);
      }
    }

    super.removeAllChildren(doCleanup);
    hasChildren_ = false;
  }

  public void draw(GL10 gl) {
    assert !usesSpriteSheet_
        : "If CCSprite is being rendered by CCSpriteSheet, CCSprite#draw SHOULD NOT be called";

    // Default GL states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY
    // Needed states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY
    // Unneeded states: -

    boolean newBlend = false;
    if (blendFunc_.src != ccConfig.CC_BLEND_SRC || blendFunc_.dst != ccConfig.CC_BLEND_DST) {
      newBlend = true;
      gl.glBlendFunc(blendFunc_.src, blendFunc_.dst);
    }

    //        ((EGL10) gl).eglWaitNative(EGL10.EGL_NATIVE_RENDERABLE, null);
    //        // bug fix in case texture name = 0
    //        texture_.checkName();
    // #define kQuadSize sizeof(quad_.bl)
    gl.glBindTexture(GL10.GL_TEXTURE_2D, texture_.name());

    // int offset = (int)&quad_;

    // vertex
    // int diff = offsetof( ccV3F_C4B_T2F, vertices);
    gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexes);

    // color
    // diff = offsetof( ccV3F_C4B_T2F, colors);
    gl.glColorPointer(4, GL10.GL_FLOAT, 0, colors);

    // tex coords
    // diff = offsetof( ccV3F_C4B_T2F, texCoords);
    gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, texCoords);

    gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, 4);

    if (newBlend) gl.glBlendFunc(ccConfig.CC_BLEND_SRC, ccConfig.CC_BLEND_DST);

    /*
    if (ccConfig.CC_SPRITE_DEBUG_DRAW) {
        CGSize s = this.contentSize();
        CGPoint vertices[]= new CGPoint [] {
            CGPoint.ccp(0,0),   CGPoint.ccp(s.width,0),
            CGPoint.ccp(s.width,s.height),  CGPoint.ccp(0,s.height)
        };
        ccDrawingPrimitives.ccDrawPoly(vertices, 4, true);
    } // CC_TEXTURENODE_DEBUG_DRAW
    */
  }

  private void updateTextureCoords(CGRect rect) {
    float atlasWidth = 1;
    float atlasHeight = 1;

    if (texture_ != null) {
      atlasWidth = texture_.pixelsWide();
      atlasHeight = texture_.pixelsHigh();
    }

    if (rectRotated_) {
      float left = (2 * rect.origin.x + 1) / (2 * atlasWidth);
      float right = left + (rect.size.height * 2 - 2) / (2 * atlasWidth);
      float top = (2 * rect.origin.y + 1) / (2 * atlasHeight);
      float bottom = top + (rect.size.width * 2 - 2) / (2 * atlasHeight);

      if (flipX_) {
        float tmp = top;
        top = bottom;
        bottom = tmp;
      }

      if (flipY_) {
        float tmp = left;
        left = right;
        right = tmp;
      }

      tmpV[0] = right;
      tmpV[1] = top; // tl v
      tmpV[2] = left; // bl u
      tmpV[3] = top; // bl v
      tmpV[4] = right; // tr u
      tmpV[5] = bottom; // tr v
      tmpV[6] = left; // br u
      tmpV[7] = bottom; // br v

      BufferUtils.copyFloats(tmpV, 0, texCoords, 8);

      //	        texCoords.put(0, right); // tl u
      //	        texCoords.put(1, top); // tl v
      //	        texCoords.put(2, left); // bl u
      //	        texCoords.put(3, top); // bl v
      //	        texCoords.put(4, right); // tr u
      //	        texCoords.put(5, bottom); // tr v
      //	        texCoords.put(6, left); // br u
      //	        texCoords.put(7, bottom); // br v
    } else {
      float left = (2 * rect.origin.x + 1) / (2 * atlasWidth);
      float right = left + (rect.size.width * 2 - 2) / (2 * atlasWidth);
      float top = (2 * rect.origin.y + 1) / (2 * atlasHeight);
      float bottom = top + (rect.size.height * 2 - 2) / (2 * atlasHeight);

      if (flipX_) {
        float tmp = left;
        left = right;
        right = tmp;
      }

      if (flipY_) {
        float tmp = top;
        top = bottom;
        bottom = tmp;
      }

      tmpV[0] = left; // tl u
      tmpV[1] = top; // tl v
      tmpV[2] = left; // bl u
      tmpV[3] = bottom; // bl v
      tmpV[4] = right; // tr u
      tmpV[5] = top; // tr v
      tmpV[6] = right; // br u
      tmpV[7] = bottom; // br v
      BufferUtils.copyFloats(tmpV, 0, texCoords, 8);

      //	        texCoords.put(0, left); // tl u
      //	        texCoords.put(1, top); // tl v
      //	        texCoords.put(2, left); // bl u
      //	        texCoords.put(3, bottom); // bl v
      //	        texCoords.put(4, right); // tr u
      //	        texCoords.put(5, top); // tr v
      //	        texCoords.put(6, right); // br u
      //	        texCoords.put(7, bottom); // br v
    }

    texCoords.position(0);

    if (usesSpriteSheet_) textureAtlas_.putTexCoords(texCoords, atlasIndex);
  }

  private static final CGAffineTransform tmpMatrix = CGAffineTransform.identity();
  private static final CGAffineTransform tmpNewMatrix = CGAffineTransform.identity();
  private static final float tmpV[] =
      new float[] {
        0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0
      };
  /** updates the quad according the the rotation, position, scale values. */
  public void updateTransform() {
    tmpMatrix.setToIdentity();

    // Optimization: if it is not visible, then do nothing
    if (!visible_) {
      Arrays.fill(tmpV, 0);
      textureAtlas_.putVertex(textureAtlas_.getVertexBuffer(), tmpV, atlasIndex);
      dirty_ = recursiveDirty_ = false;
      return;
    }

    // Optimization: If parent is spritesheet, or parent is nil
    // build Affine transform manually
    if (parent_ == null || parent_ == spriteSheet_) {
      float radians = -ccMacros.CC_DEGREES_TO_RADIANS(rotation_);
      float c = (float) Math.cos(radians);
      float s = (float) Math.sin(radians);

      tmpMatrix.set(c * scaleX_, s * scaleX_, -s * scaleY_, c * scaleY_, position_.x, position_.y);

      tmpMatrix.translate(-anchorPointInPixels_.x, -anchorPointInPixels_.y);
    }

    // else do affine transformation according to the HonorParentTransform
    else if (parent_ != spriteSheet_) {

      int prevHonor = CC_HONOR_PARENT_TRANSFORM_ALL;

      for (CCNode p = this; p != null && p != spriteSheet_; p = p.getParent()) {
        CCSprite sprP = (CCSprite) p;

        tmpNewMatrix.setToIdentity();
        // 2nd: Translate, Rotate, Scale
        if ((prevHonor & CC_HONOR_PARENT_TRANSFORM_TRANSLATE) != 0)
          tmpNewMatrix.translate(sprP.position_.x, sprP.position_.y);
        if ((prevHonor & CC_HONOR_PARENT_TRANSFORM_ROTATE) != 0)
          tmpNewMatrix.rotate(-ccMacros.CC_DEGREES_TO_RADIANS(sprP.rotation_));
        if ((prevHonor & CC_HONOR_PARENT_TRANSFORM_SCALE) != 0) {
          tmpNewMatrix.scale(sprP.scaleX_, sprP.scaleY_);
        }

        // 3rd: Translate anchor point
        tmpNewMatrix.translate(-sprP.anchorPointInPixels_.x, -sprP.anchorPointInPixels_.y);
        // 4th: Matrix multiplication
        tmpMatrix.multiply(tmpNewMatrix);
        prevHonor = sprP.honorParentTransform_;
      }
    }

    //
    // calculate the Quad based on the Affine Matrix
    //

    CGSize size = rect_.size;

    float x1 = offsetPosition_.x;
    float y1 = offsetPosition_.y;

    float x2 = x1 + size.width;
    float y2 = y1 + size.height;
    float x = (float) tmpMatrix.m02;
    float y = (float) tmpMatrix.m12;

    float cr = (float) tmpMatrix.m00;
    float sr = (float) tmpMatrix.m10;
    float cr2 = (float) tmpMatrix.m11;
    float sr2 = (float) -tmpMatrix.m01;

    float ax = x1 * cr - y1 * sr2 + x;
    float ay = x1 * sr + y1 * cr2 + y;

    float bx = x2 * cr - y1 * sr2 + x;
    float by = x2 * sr + y1 * cr2 + y;

    float cx = x2 * cr - y2 * sr2 + x;
    float cy = x2 * sr + y2 * cr2 + y;

    float dx = x1 * cr - y2 * sr2 + x;
    float dy = x1 * sr + y2 * cr2 + y;

    tmpV[0] = dx;
    tmpV[1] = dy;
    tmpV[2] = vertexZ_;
    tmpV[3] = ax;
    tmpV[4] = ay;
    tmpV[5] = vertexZ_;
    tmpV[6] = cx;
    tmpV[7] = cy;
    tmpV[8] = vertexZ_;
    tmpV[9] = bx;
    tmpV[10] = by;
    tmpV[11] = vertexZ_;

    textureAtlas_.putVertex(textureAtlas_.getVertexBuffer(), tmpV, atlasIndex);
    dirty_ = recursiveDirty_ = false;
  }

  public ccBlendFunc getBlendFunc() {
    return blendFunc_;
  }

  public void setBlendFunc(ccBlendFunc blendFunc) {
    blendFunc_ = blendFunc;
  }
}
Example #8
0
 /**
  * Initializes an sprite with a texture. The rect used will be the size of the texture. The offset
  * will be (0,0).
  */
 public CCSprite(CCTexture2D texture) {
   CGSize size = texture.getContentSize();
   CGRect rect = CGRect.make(0, 0, size.width, size.height);
   init(texture, rect);
 }
 @Override
 public CGRect enclosedArea() {
   float xMin = center.x - rx, xMax = center.x + rx;
   float yMin = center.y - ry, yMax = center.y + ry;
   return CGRect.make(xMin, yMin, xMax - xMin, yMax - yMin);
 }
Example #10
0
 /**
  * returns a "local" axis aligned bounding box of the node. The returned box is relative only to
  * its parent.
  *
  * @since v0.8.2
  */
 public CGRect getBoundingBox() {
   CGRect rect = CGRect.make(0, 0, contentSize_.width, contentSize_.height);
   return CGRect.applyAffineTransform(rect, nodeToParentTransform());
 }