Parallax X & Y Scrolling class

  ... the case you feel the need for a new feature or want to submit one.

Parallax X & Y Scrolling class

Postby oldskool73 » Sun Oct 17, 2010 6:48 pm

Hi all,

Looks like everyone's doing one at the moment, so thought I'd post my own 2d parallax class. :)

Should be quite flexible, you can tile in just x (as the current parallax background, for side scrollers etc), just y (to make a top down shooter etc), or x & y (repeating starfields for free shooters etc).You can also place individual non repeating items in the background parallax, e.g a distant planet, the castle off in the hills etc.

Be interested to hear your thoughts...
Syntax: [ Download ] [ Hide ]
Using java Syntax Highlighting
  1. package com.dustypixels.andengine.entity.scene.background;
  2.  
  3. import java.util.ArrayList;
  4.  
  5. import javax.microedition.khronos.opengles.GL10;
  6.  
  7. import org.anddev.andengine.engine.camera.Camera;
  8. import org.anddev.andengine.entity.scene.background.ColorBackground;
  9. import org.anddev.andengine.entity.shape.Shape;
  10.  
  11. /**
  12.  * @author Oldskool73
  13.  *
  14.  * Parallax background that scrolls in both X and/or Y directions.
  15.  *
  16.  * Usage:
  17.  *
  18.  * ...x & y free scrolling tiled background...
  19.  * mParallaxBackground.addParallaxEntity(new ParallaxBackground2d.ParallaxBackground2dEntity(-0.2f,-0.2f, new Sprite(0, 0, this.mParallaxLayerStars)));
  20.  *
  21.  * ...side scroller repeating strip...
  22.  * mParallaxBackground.addParallaxEntity(new ParallaxBackground2d.ParallaxBackground2dEntity(-0.4f, 0.0f, new Sprite(0, 100, this.mParallaxLayerHills),true,false));
  23.  *
  24.  * ...vertical scroller repeating strip...
  25.  * mParallaxBackground.addParallaxEntity(new ParallaxBackground2d.ParallaxBackground2dEntity(-0.0f,-0.4f, new Sprite(100, 0, this.mParallaxLayerHills),false,true));
  26.  *
  27.  * ...non repeating positioned item...
  28.  * mParallaxBackground.addParallaxEntity(new ParallaxBackground2d.ParallaxBackground2dEntity(-0.4f,-0.4f, new Sprite(100, 100, this.mParallaxLayerSun),false,false,true));
  29.  *
  30.  *
  31.  */
  32. public class ParallaxBackground2d extends ColorBackground {
  33.         // ===========================================================
  34.         // Constants
  35.         // ===========================================================
  36.  
  37.         // ===========================================================
  38.         // Fields
  39.         // ===========================================================
  40.  
  41.         private final ArrayList<ParallaxBackground2dEntity> mParallaxEntities = new ArrayList<ParallaxBackground2dEntity>();
  42.         private int mParallaxEntityCount;
  43.  
  44.         protected float mParallaxValueX;
  45.         protected float mParallaxValueY;
  46.  
  47.         // ===========================================================
  48.         // Constructors
  49.         // ===========================================================
  50.  
  51.         public ParallaxBackground2d(float pRed, float pGreen, float pBlue) {
  52.                 super(pRed, pGreen, pBlue);
  53.         }
  54.  
  55.         // ===========================================================
  56.         // Getter & Setter
  57.         // ===========================================================
  58.  
  59.         public void setParallaxValue(final float pParallaxValueX, final float pParallaxValueY) {
  60.                 this.mParallaxValueX = pParallaxValueX;
  61.                 this.mParallaxValueY = pParallaxValueY;
  62.         }
  63.        
  64.         public void offsetParallaxValue(final float pParallaxValueX, final float pParallaxValueY) {
  65.                 this.mParallaxValueX += pParallaxValueX;
  66.                 this.mParallaxValueY += pParallaxValueY;
  67.         }
  68.  
  69.         // ===========================================================
  70.         // Methods for/from SuperClass/Interfaces
  71.         // ===========================================================
  72.  
  73.         @Override
  74.         public void onDraw(final GL10 pGL, final Camera pCamera) {
  75.                 super.onDraw(pGL, pCamera);
  76.  
  77.                 final float parallaxValueX = this.mParallaxValueX;
  78.                 final float parallaxValueY = this.mParallaxValueY;
  79.                 final ArrayList<ParallaxBackground2dEntity> parallaxEntities = this.mParallaxEntities;
  80.  
  81.                 for(int i = 0; i < this.mParallaxEntityCount; i++) {
  82.                         parallaxEntities.get(i).onDraw(pGL, parallaxValueX, parallaxValueY, pCamera);
  83.                 }
  84.         }
  85.        
  86.         // ===========================================================
  87.         // Methods
  88.         // ===========================================================
  89.  
  90.         public void addParallaxEntity(final ParallaxBackground2dEntity pParallaxEntity) {
  91.                 this.mParallaxEntities.add(pParallaxEntity);
  92.                 this.mParallaxEntityCount++;
  93.         }
  94.  
  95.         public boolean removeParallaxEntity(final ParallaxBackground2dEntity pParallaxEntity) {
  96.                 final boolean success = this.mParallaxEntities.remove(pParallaxEntity);
  97.                 if (success == true) {
  98.                         this.mParallaxEntityCount--;
  99.                 }
  100.                 return success;
  101.         }
  102.        
  103.         // ===========================================================
  104.         // Inner and Anonymous Classes
  105.         // ===========================================================
  106.  
  107.         public static class ParallaxBackground2dEntity {
  108.                 // ===========================================================
  109.                 // Constants
  110.                 // ===========================================================
  111.  
  112.                 // ===========================================================
  113.                 // Fields
  114.                 // ===========================================================
  115.  
  116.                 final float mParallaxFactorX;
  117.                 final float mParallaxFactorY;
  118.                 final Boolean mRepeatX;
  119.                 final Boolean mRepeatY;        
  120.                 final Shape mShape;
  121.                 final Boolean mShouldCull;
  122.  
  123.                 // ===========================================================
  124.                 // Constructors
  125.                 // ===========================================================
  126.  
  127.                 // add a repeating x & y texture fill
  128.                 public ParallaxBackground2dEntity(final float pParallaxFactorX, final float pParallaxFactorY, final Shape pShape) {
  129.                         this.mParallaxFactorX = pParallaxFactorX;
  130.                         this.mParallaxFactorY = pParallaxFactorY;
  131.                         this.mRepeatX = true;
  132.                         this.mRepeatY = true;
  133.                         this.mShouldCull = false;
  134.                         this.mShape = pShape;
  135.                 }
  136.  
  137.                 // add an x or y only repeating strip
  138.                 public ParallaxBackground2dEntity(final float pParallaxFactorX, final float pParallaxFactorY, final Shape pShape, final Boolean pRepeatX, final Boolean pRepeatY) {
  139.                         this.mParallaxFactorX = pParallaxFactorX;
  140.                         this.mParallaxFactorY = pParallaxFactorY;
  141.                         this.mRepeatX = pRepeatX;
  142.                         this.mRepeatY = pRepeatY;
  143.                         this.mShouldCull = false;
  144.                         this.mShape = pShape;
  145.                 }                      
  146.                
  147.                 // add an x or y only repeating strip or non repeating feature that may be culled when off screen
  148.                 public ParallaxBackground2dEntity(final float pParallaxFactorX, final float pParallaxFactorY, final Shape pShape, final Boolean pRepeatX, final Boolean pRepeatY, final Boolean pShouldCull) {
  149.                         this.mParallaxFactorX = pParallaxFactorX;
  150.                         this.mParallaxFactorY = pParallaxFactorY;
  151.                         this.mRepeatX = pRepeatX;
  152.                         this.mRepeatY = pRepeatY;
  153.                         this.mShouldCull = (pRepeatX && pRepeatY)? false : pShouldCull;
  154.                         this.mShape = pShape;
  155.                 }
  156.  
  157.                
  158.                 // ===========================================================
  159.                 // Getter & Setter
  160.                 // ===========================================================
  161.  
  162.                 // ===========================================================
  163.                 // Methods for/from SuperClass/Interfaces
  164.                 // ===========================================================
  165.  
  166.                 // ===========================================================
  167.                 // Methods
  168.                 // ===========================================================
  169.  
  170.                 public void onDraw(final GL10 pGL, final float pParallaxValueX, final float pParallaxValueY, final Camera pCamera) {
  171.                         pGL.glPushMatrix();
  172.                         {
  173.                                 final float cameraWidth = pCamera.getWidth();
  174.                                 final float cameraHeight = pCamera.getHeight();
  175.                                 final float shapeWidthScaled = this.mShape.getWidthScaled();
  176.                                 final float shapeHeightScaled = this.mShape.getHeightScaled();
  177.  
  178.                                 //reposition
  179.                                 float baseOffsetX = (pParallaxValueX * this.mParallaxFactorX);
  180.                                 if (this.mRepeatX) {
  181.                                         baseOffsetX = baseOffsetX % shapeWidthScaled;
  182.                                         while(baseOffsetX > 0) {
  183.                                                 baseOffsetX -= shapeWidthScaled;
  184.                                         }
  185.                                 }                      
  186.                                 float baseOffsetY = (pParallaxValueY * this.mParallaxFactorY);
  187.                                 if (this.mRepeatY) {
  188.                                         baseOffsetY = baseOffsetY % shapeHeightScaled;
  189.                                         while(baseOffsetY > 0) {
  190.                                                 baseOffsetY -= shapeHeightScaled;
  191.                                         }                              
  192.                                 }
  193.                                
  194.                                 //optionally screen cull non repeating items
  195.                                 Boolean culled = false;
  196.                                 if (mShouldCull) {
  197.                                         if (!this.mRepeatX) {
  198.                                                 if ((baseOffsetY + (shapeHeightScaled*2) < 0) || (baseOffsetY > cameraHeight)) {
  199.                                                         culled = true;
  200.                                                 }
  201.                                         }      
  202.                                         if (!this.mRepeatY) {
  203.                                                 if ((baseOffsetX + (shapeWidthScaled*2) < 0) || (baseOffsetX > cameraWidth)) {
  204.                                                         culled = true;
  205.                                                 }
  206.                                         }
  207.                                 }
  208.                                
  209.                                 if (!culled) {
  210.                                         //draw
  211.                                         pGL.glTranslatef(baseOffsetX, baseOffsetY, 0);
  212.                                         float currentMaxX = baseOffsetX;
  213.                                         float currentMaxY = baseOffsetY;
  214.                                         do {                                                                                                            //rows
  215.                                                 this.mShape.onDraw(pGL, pCamera);
  216.                                                 if (this.mRepeatY) {
  217.                                                         currentMaxY = baseOffsetY;                                                     
  218.                                                         do {                                                                                            //columns
  219.                                                                 pGL.glTranslatef(0, shapeHeightScaled, 0);
  220.                                                                 currentMaxY += shapeHeightScaled;                                              
  221.                                                                 this.mShape.onDraw(pGL, pCamera);
  222.                                                         } while(currentMaxY < cameraHeight);                            //end columns
  223.                                                         pGL.glTranslatef(0, -currentMaxY + baseOffsetY, 0);                                    
  224.                                                 }
  225.                                                 pGL.glTranslatef(shapeWidthScaled, 0, 0);
  226.                                                 currentMaxX += shapeWidthScaled;
  227.                                         } while (this.mRepeatX && currentMaxX < cameraWidth);           //end rows
  228.                                 }
  229.                         }
  230.                         pGL.glPopMatrix();
  231.                 }
  232.  
  233.                 // ===========================================================
  234.                 // Inner and Anonymous Classes
  235.                 // ===========================================================
  236.         }
  237. }
  238.  
  239.  
  240.  
Parsed in 0.021 seconds, using GeSHi 1.0.8.4
Last edited by oldskool73 on Sun Oct 17, 2010 7:11 pm, edited 1 time in total.
oldskool73
 
Posts: 128
Joined: Tue Oct 12, 2010 4:04 pm

Re: Parallax X & Y Scrolling class

Postby oldskool73 » Sun Oct 17, 2010 6:50 pm

...and corresponding Auto classes...
Syntax: [ Download ] [ Hide ]
Using java Syntax Highlighting
  1. /**
  2.  *
  3.  */
  4. package com.dustypixels.andengine.entity.scene.background;
  5.  
  6. /**
  7.  * @author oldskool73
  8.  *
  9.  */
  10. public class AutoHorizontalParallaxBackground extends ParallaxBackground2d {
  11.         // ===========================================================
  12.         // Constants
  13.         // ===========================================================
  14.  
  15.         // ===========================================================
  16.         // Fields
  17.         // ===========================================================
  18.  
  19.         private final float mParallaxChangePerSecond;
  20.  
  21.         // ===========================================================
  22.         // Constructors
  23.         // ===========================================================
  24.  
  25.         public AutoHorizontalParallaxBackground (final float pRed, final float pGreen, final float pBlue, final float pParallaxChangePerSecond) {
  26.                 super(pRed, pGreen, pBlue);
  27.                 this.mParallaxChangePerSecond = pParallaxChangePerSecond;
  28.         }
  29.  
  30.         // ===========================================================
  31.         // Getter & Setter
  32.         // ===========================================================
  33.  
  34.         // ===========================================================
  35.         // Methods for/from SuperClass/Interfaces
  36.         // ===========================================================
  37.  
  38.         @Override
  39.         public void onUpdate(final float pSecondsElapsed) {
  40.                 super.onUpdate(pSecondsElapsed);
  41.  
  42.                 this.mParallaxValueX += this.mParallaxChangePerSecond * pSecondsElapsed;
  43.         }
  44.  
  45.         // ===========================================================
  46.         // Methods
  47.         // ===========================================================
  48.  
  49.         // ===========================================================
  50.         // Inner and Anonymous Classes
  51.         // ===========================================================
  52. }
  53.  
Parsed in 0.012 seconds, using GeSHi 1.0.8.4


Syntax: [ Download ] [ Hide ]
Using java Syntax Highlighting
  1. /**
  2.  *
  3.  */
  4. package com.dustypixels.andengine.entity.scene.background;
  5.  
  6. /**
  7.  * @author oldskool73
  8.  *
  9.  */
  10. public class AutoVerticalParallaxBackground extends ParallaxBackground2d {
  11.         // ===========================================================
  12.         // Constants
  13.         // ===========================================================
  14.  
  15.         // ===========================================================
  16.         // Fields
  17.         // ===========================================================
  18.  
  19.         private final float mParallaxChangePerSecond;
  20.  
  21.         // ===========================================================
  22.         // Constructors
  23.         // ===========================================================
  24.  
  25.         public AutoVerticalParallaxBackground (final float pRed, final float pGreen, final float pBlue, final float pParallaxChangePerSecond) {
  26.                 super(pRed, pGreen, pBlue);
  27.                 this.mParallaxChangePerSecond = pParallaxChangePerSecond;
  28.         }
  29.  
  30.         // ===========================================================
  31.         // Getter & Setter
  32.         // ===========================================================
  33.  
  34.         // ===========================================================
  35.         // Methods for/from SuperClass/Interfaces
  36.         // ===========================================================
  37.  
  38.         @Override
  39.         public void onUpdate(final float pSecondsElapsed) {
  40.                 super.onUpdate(pSecondsElapsed);
  41.  
  42.                 this.mParallaxValueY += this.mParallaxChangePerSecond * pSecondsElapsed;
  43.         }
  44.  
  45.         // ===========================================================
  46.         // Methods
  47.         // ===========================================================
  48.  
  49.         // ===========================================================
  50.         // Inner and Anonymous Classes
  51.         // ===========================================================
  52. }
  53.  
  54.  
Parsed in 0.012 seconds, using GeSHi 1.0.8.4
oldskool73
 
Posts: 128
Joined: Tue Oct 12, 2010 4:04 pm

Re: Parallax X & Y Scrolling class

Postby Nicolas Gramlich » Mon Oct 18, 2010 1:44 pm

Cool thanks, I'll add it when I got the time to :)

Best Regards,
Nicolas
Nicolas Gramlich
Site Admin
 
Posts: 1734
Joined: Mon Jun 07, 2010 6:20 pm
Location: Schriesheim, Germany

Re: Parallax X & Y Scrolling class

Postby adobo76 » Mon Oct 18, 2010 3:50 pm

Mine is a bit more simple. Doesn't allow adding objects but allows for scrolling in the X, Y, or XY. Not sure why a new thread was needed to post this since I just started a thread on this topic a few minutes ago but I'll go ahead and continue on this one. Here is the code I made. It only modifies the original ParallaxBackground.java file.
-----------------------------------------------

Syntax: [ Download ] [ Hide ]
Using java Syntax Highlighting
  1. package org.anddev.andengine.entity.scene.background;
  2.  
  3. import java.util.ArrayList;
  4. import javax.microedition.khronos.opengles.GL10;
  5. import org.anddev.andengine.engine.camera.Camera;
  6. import org.anddev.andengine.entity.shape.Shape;
  7.  
  8. /**
  9.  * @author Nicolas Gramlich
  10.  * @since 15:36:26 - 19.07.2010
  11.  * @updated Aaron Stone
  12.  * @since 12.10.2010
  13.  */
  14. public class ParallaxBackground extends ColorBackground {
  15.         // ===========================================================
  16.         // Constants
  17.         // ===========================================================
  18.  
  19.         // ===========================================================
  20.         // Fields
  21.         // ===========================================================
  22.  
  23.         private final ArrayList<ParallaxEntity> mParallaxEntities = new ArrayList<ParallaxEntity>();
  24.         private int mParallaxEntityCount;
  25.  
  26.         protected float mParallaxValue;
  27.  
  28.         // ===========================================================
  29.         // Constructors
  30.         // ===========================================================
  31.  
  32.         public ParallaxBackground(final float pRed, final float pGreen, final float pBlue) {
  33.                 super(pRed, pGreen, pBlue);
  34.         }
  35.  
  36.         // ===========================================================
  37.         // Getter & Setter
  38.         // ===========================================================
  39.  
  40.         public void setParallaxValue(final float pParallaxValue) {
  41.                 this.mParallaxValue = pParallaxValue;
  42.         }
  43.  
  44.         // ===========================================================
  45.         // Methods for/from SuperClass/Interfaces
  46.         // ===========================================================
  47.  
  48.         @Override
  49.         public void onDraw(final GL10 pGL, final Camera pCamera) {
  50.                 super.onDraw(pGL, pCamera);
  51.  
  52.                 final float parallaxValue = this.mParallaxValue;
  53.                 final ArrayList<ParallaxEntity> parallaxEntities = this.mParallaxEntities;
  54.  
  55.                 for(int i = 0; i < this.mParallaxEntityCount; i++) {
  56.                         parallaxEntities.get(i).onDraw(pGL, parallaxValue, pCamera);
  57.                 }
  58.         }
  59.  
  60.         // ===========================================================
  61.         // Methods
  62.         // ===========================================================
  63.  
  64.         public void addParallaxEntity(final ParallaxEntity pParallaxEntity) {
  65.                 this.mParallaxEntities.add(pParallaxEntity);
  66.                 this.mParallaxEntityCount++;
  67.         }
  68.  
  69.         public boolean removeParallaxEntity(final ParallaxEntity pParallaxEntity) {
  70.                 this.mParallaxEntityCount--;
  71.                 final boolean success = this.mParallaxEntities.remove(pParallaxEntity);
  72.                 if(success == false) {
  73.                         this.mParallaxEntityCount++;
  74.                 }
  75.                 return success;
  76.         }
  77.  
  78.         // ===========================================================
  79.         // Inner and Anonymous Classes
  80.         // ===========================================================
  81.  
  82.         public static class ParallaxEntity {
  83.                 // ===========================================================
  84.                 // Constants
  85.                 // ===========================================================
  86.  
  87.                 // ===========================================================
  88.                 // Fields
  89.                 // ===========================================================
  90.  
  91.                 final float mParallaxXFactor;
  92.                 final float mParallaxYFactor;
  93.                 Boolean mParallaxXRepeat;
  94.                 Boolean mParallaxYRepeat;
  95.                 final Shape mShape;
  96.  
  97.                 // ===========================================================
  98.                 // Constructors
  99.                 // ===========================================================
  100.  
  101.                 public ParallaxEntity(final float pParallaxXFactor, final float pParallaxYFactor,
  102.                                               Boolean pParallaxXRepeat, Boolean pParallaxYRepeat, final Shape pShape)
  103.                 {
  104.                         this.mParallaxXFactor = pParallaxXFactor;
  105.                         this.mParallaxYFactor = pParallaxYFactor;
  106.                         this.mParallaxXRepeat = pParallaxXRepeat;
  107.                         this.mParallaxYRepeat = pParallaxYRepeat;
  108.                         this.mShape = pShape;
  109.                 }
  110.  
  111.                 // ===========================================================
  112.                 // Getter & Setter
  113.                 // ===========================================================
  114.  
  115.                 // ===========================================================
  116.                 // Methods for/from SuperClass/Interfaces
  117.                 // ===========================================================
  118.  
  119.                 // ===========================================================
  120.                 // Methods
  121.                 // ===========================================================
  122.  
  123.                 public void onDraw(final GL10 pGL, final float pParallaxValue, final Camera pCamera) {
  124.                         pGL.glPushMatrix();
  125.                         {
  126.                                 final float cameraWidth = pCamera.getWidth();
  127.                                 final float cameraHeight = pCamera.getHeight();
  128.                                 final float shapeWidthScaled = this.mShape.getWidthScaled();
  129.                                 final float shapeHeightScaled = this.mShape.getHeightScaled();
  130.                                 float baseXOffset = (pParallaxValue * this.mParallaxXFactor) % shapeWidthScaled;
  131.                                 float baseYOffset = (pParallaxValue * this.mParallaxYFactor) % shapeHeightScaled;
  132.                                
  133.                                 while(baseXOffset > 0) {
  134.                                         baseXOffset -= shapeWidthScaled;
  135.                                 }
  136.                                 while(baseYOffset > 0) {
  137.                                         baseYOffset -= shapeHeightScaled;
  138.                                 }
  139.                                
  140.                                 pGL.glTranslatef(baseXOffset, baseYOffset, 0);
  141.  
  142.                                 float currentMaxX = baseXOffset;
  143.                                 float currentMaxY = baseYOffset;
  144.  
  145.                                 if (mParallaxXRepeat && mParallaxYRepeat)
  146.                                 {
  147.                                         do
  148.                                         {
  149.                                                 do
  150.                                                 {
  151.                                                         this.mShape.onDraw(pGL, pCamera);
  152.                                                         pGL.glTranslatef(0, shapeHeightScaled, 0);
  153.                                                         currentMaxY += shapeHeightScaled;
  154.                                                 } while(currentMaxY < cameraHeight);
  155.                                                 pGL.glTranslatef(0, -(currentMaxY-baseYOffset), 0);
  156.                                                 currentMaxY = baseYOffset;
  157.                                        
  158.                                                 pGL.glTranslatef(shapeWidthScaled, 0, 0);
  159.                                                 currentMaxX += shapeWidthScaled;
  160.                                         } while(currentMaxX < cameraWidth);
  161.                                 }
  162.                                 else if (mParallaxXRepeat)
  163.                                 {
  164.                                         do {
  165.                                                 this.mShape.onDraw(pGL, pCamera);
  166.                                                 pGL.glTranslatef(shapeWidthScaled, 0, 0);
  167.                                                 currentMaxX += shapeWidthScaled;
  168.                                         } while(currentMaxX < cameraWidth);                                    
  169.                                 }
  170.                                 else if (mParallaxYRepeat)
  171.                                 {
  172.                                         do {
  173.                                                 this.mShape.onDraw(pGL, pCamera);
  174.                                                 pGL.glTranslatef(0, shapeHeightScaled, 0);
  175.                                                 currentMaxY += shapeHeightScaled;                                      
  176.                                         } while(currentMaxY < cameraHeight);                           
  177.                                 }
  178.                         }
  179.                         pGL.glPopMatrix();
  180.                 }
  181.  
  182.                 // ===========================================================
  183.                 // Inner and Anonymous Classes
  184.                 // ===========================================================
  185.         }
  186. }
Parsed in 0.018 seconds, using GeSHi 1.0.8.4
adobo76
 
Posts: 84
Joined: Sun Oct 17, 2010 4:14 pm

Re: Parallax X & Y Scrolling class

Postby nullvalue » Fri Dec 03, 2010 6:45 am

I realize this was posted a few months ago but I'm just getting started and was hoping someone could post an example of how to use this new class?

I'm trying to make a game which can scroll horizontally, similar to a platformer like Mario or Mega Man. I've seen others have posted asking for help on this same concept without much response.. can anyone lend a hand?
nullvalue
 
Posts: 6
Joined: Fri Dec 03, 2010 6:27 am

Re: Parallax X & Y Scrolling class

Postby oldskool73 » Fri Dec 03, 2010 8:11 am

if you just want to scroll horizontally you can use the existing parallax background in the library.
there's an example of the auto parallax background here:
http://code.google.com/p/andengineexamp ... ample.java

...the auto one scrolls automatically, but if you want to control the scroll it's very similar, you just need to use a normal ParallaxBackground instead and set the scroll offset value yourself in your update function using the setParallaxValue function.

If you want to go horizontal and vertical you'll need to use one of the classes here. My one works in pretty much the same way as the normal one, but the setParallaxValue function takes 2 parameters for x & y offset.

It's a bit late here (or early, depends on how you look at it ;), I need to go bed, but I'll try to find the demo I made when writing it or knock up a new one tomorrow.
oldskool73
 
Posts: 128
Joined: Tue Oct 12, 2010 4:04 pm

Re: Parallax X & Y Scrolling class

Postby nullvalue » Fri Dec 03, 2010 9:31 am

Yeah i just need to scroll horizontally for now. Thanks for the tips, ill take another look at parallax background.
nullvalue
 
Posts: 6
Joined: Fri Dec 03, 2010 6:27 am

Re: Parallax X & Y Scrolling class

Postby nullvalue » Sun Dec 05, 2010 12:39 am

Thanks for pointing me in the right direction - ParallaxBackground is working great...
nullvalue
 
Posts: 6
Joined: Fri Dec 03, 2010 6:27 am

Re: Parallax X & Y Scrolling class

Postby chozabu » Sun Dec 05, 2010 3:56 am

Sweet! I think I'll jam one of these in my game :D
chozabu
 
Posts: 107
Joined: Sat Oct 30, 2010 10:57 pm

Re: Parallax X & Y Scrolling class

Postby Barina » Fri Feb 25, 2011 1:22 pm

Awesome! im using for vertical scrolling background :D
thanks

edit:
before that i used the build-in autoParallax and now i replaced it with your code to have a vertical movement
and it seems FPS dropped to 20-30.. :\ (on a G1 device)
Barina
 
Posts: 60
Joined: Sun Jan 23, 2011 5:53 am

Next

Return to Features

Who is online

Users browsing this forum: Google [Bot] and 5 guests