migrating 1.5_pre -> 1.5_r1

by skink » Thu, 30 Apr 2009 01:43:52 GMT


Sponsored Links
 hi,

just migrated from 1.5_pre to r1.

should i re-create all AVDs created with 1.5_pre ?
--~--~---------~--~----~------------~-------~--~----~



Other Threads

1. Suhu jakarta pada kumpul

Entah dr jam brapa tuh

Pandu,jakontil,wongompong,dzikki,anto,andre,novindra.....

Gimana proyeknya? Berhasil?

*iphone dual boot* 


"lestarikan alam Indonesia dengan bersepeda"
follow me at twitter @oktorairahadi

-- 
"Indonesian Android Community [id-android]" 

2. Lengthy question(s) on 2D graphics optimization

Hi all,

Like everyone else I'm doing a game to learn a bit about the android
platform. I've now reached a point where I need to optimize my draw
function and I'm trying to figure out the pros and cons of different
paths to take. I'm pretty new to graphics (but not programming) so my
questions might seems stupid, and my native language isn't English but
please bear with me. I'll be trying to explain as well as I can and
hopefully giving a bite more info than needed rather than less.

It's "simple" 2D graphics we're talking about here. Doing frame
animations from a sprite sheet with sequences of movement for
different creatures, so basically I'm painting a portion of the sprite
sheet to the canvas, a little moved each time to make it look it's
walking/driving/running. The "game plan" is larger than the screen so
there's a view port Rectangle I use to draw what's on screen. I'm
doing this threaded pretty much like the lunar lander example. My
current draw function does:

1. Update physics, set boolean to updated if anything happened
2. Draw global BitMap object containing last frame on the canvas if
nothing has happened, otherwise:
 3. Draw the part of the background currently visible, this draws over
everything old
 4. Loop through my objects, if any part of them is inside the view
port draw them and let the canvas sort out what's needed and what's
not
 5. Store draw the update on the "static" background

Something like this:
private Bitmap bg = ... the large background image
private Bitmap sprites = ... the animations
private Bitmap screenBM = .. the "static" image
private Canvas screenC = new Canvas (screenBM);
private boolean noUp = false;
private MyClass creatures = new MyClass[10];

 @Override
        public void run() {
            Canvas c;
            while (_run) {
                c = null;
                try
                {
                   c = mSurfaceHolder.lockCanvas(null);
                    synchronized (mSurfaceHolder) {
                        updatePhysics (SystemClock.uptimeMillis (), c);

                        if (noUp)
                                c.drawBitmap(cp, 0, 0, null); // redraw the old
                        else
                                draw (c);
                    }
                }
                finally
                {
                    if (c != null)
                        mSurfaceHolder.unlockCanvasAndPost(c);
                }
           }

        }

       public void draw (Canvas c)
        {
                screenC.drawBitmap (bgImage, viewPort, mapScreen, null);
                Rect trans = new Rect (); // used to transform to the current 
view port
                for (int i = 0; i < creatures.length; i++)
                {
                        if (creatures[i] != null && !creatures[i].dead)
                        {
                                trans.left = creatures[i].pos.left - 
viewPort.left;
                                trans.right = creatures[i].pos.right - 
viewPort.left;
                                trans.top = creatures[i].pos.top - viewPort.top;
                                trans.bottom = creatures[i].pos.bottom - 
viewPort.top;
                                if ( trans.left < mapScreen.right && 
trans.right > mapScreen.left &&
                                        trans.top < mapScreen.bottom && 
trans.bottom > mapScreen.top)
                                {
                                        screenC.drawBitmap(creatureAnimBitmap, 
frameCoords, trans, null);
                                }
                        }
                }
                co.drawBitmap(screenBM, 0, 0, null);
        }


I'm sure this isn't a very effective method for handling this,
especially not when the game physics is demanding and one wants a nice
frame rate. What would be the more effective way to do this? I've
tried figuring out how  "clipRect  (float left, float top, float
right, float bottom, Region.Op op)" works but I haven't been very
successful at that, not many examples out there explaining what it
does exactly.

My guess would be that I should keep track of all movement of my
objects and have an int/float based array (to avoid the dreaded GC)
with a rectangle covering the previous position and the current and
just redraw that part.

Or am I looking in the wrong direction? Is
Canvas.save/translate/restore the way to go if I want it to be
efficient? Or is it something completely different I should do?

To sum up my rambling:
1. I understand Rects are inefficient and expensive, is that so?
2. What is the best way to handle things that would completely or
partially be drawn outside the view port?
3. Is clipping, translate or just drawing pos based most efficient?

4. And since you've read through all this a little bonus question: Do
people tend to have two threads, one for synchronized drawing and only
doing that and one for physics or is one large thread doing both the
way to go?

Sorry for the bandwidth, the only thing missing is a 5 MB word
document with an animated GIF in it, and thanks in advance

Jon

-- 

3. howe to make a sub activity. ore a new windows with ui.

4. Adding a custom view through XML.

5. help! my phone keeps buying apps by itself!

6. help! my phone keeps buying apps by itself!

7. Eclair's opencore compiling and execution issues