hi Guys,

I've got some code which uses three bitmaps and scrolls them past the screen from bottom to top.

A maximum of two of these bitmaps have parts which get drawn to the screen at any one time. The third one hangs in waiting. A time comes when one of bitmaps needs to be remade (by a function that uses random numbers to make all the bitmaps). When a bitmap has scrolled all the way past the screen - it gets remade. The thing is, when the bitmap is being remade the scrolling jerks becaise it takes time to make.

I thought perhaps I could use an ALLEGRO_THREAD to start making the bitmap at the earliest moment so it's ready when it's needed.

Is this possible ? Am I thinking along the right lines ?

I've no idea how to do it. I've looked at the example on the wiki but don't understand it.

Any help for this would be greatly appreciated.

It sounds like you could use a thread. Something like this should get you started:

If your "make_bitmap" needs more than one parameter, then you could create a struct and pass that instead:

typedef struct MAKE_BMP_ARGS {
  ALLEGRO_BITMAP *bmp;
  int param1;
} MAKE_BMP_ARGS;

MAKE_BMP_ARGS args;
args.bmp = bmp;
args.param1 = foo;

ALLEGRO_THREAD *t = al_create_thread(make_bitmap, args);

Thanks Matthew.

If I use a class method for the function pointer can I use class member variables or should do what you said and use a struct ?

You won't be able to use a class method directly, unless it's static. You could do something like this instead:

void *make_bitmap(ALLEGRO_THREAD *me, void *data)
{
  MyClass *obj  = (MyClass *) data;
  obj->doSomething();
  return NULL;
}

MyClass *obj = new MyClass();
obj->bmp = bmp;
ALLEGRO_THREAD *t = al_create_thread(make_bitmap, obj);

You could turn make_bitmap into a static method of the class, but it would still need to work like the above example.

See my response about using a class method over in this thread.

Thanks. I can't quite see how to do it yet (unless I go the struct way).

Here's the method :-

What I need to happen in the thread is one of the three lines like this :-

b1 = dinkle_get_connecting_blot(backdrop_width, backdrop_height, &ratios, b3_tiles, b1_tiles, bg_colors[0], bg_colors[1]);

b1 is a member of Backdrop as are all the arguments to dinkle_get_connecting_blot().

What calls Backdrop::Update_Position? Is that the single function that is slowing everything down?

If so, then take my example and call ->Update_Position() on the void * argument that the thread function gets.

Thanks again guys. I've gone for Matthews way as I understand it.

I've made some progress - here's what I've got. Something's going wrong though I think because the Update function is taking less time now - I'm not sure the thread finishes before another one starts.

EDIT : I put an al_join_thread in there but the problem's still there so it's something else.

Think about when you need to have the thread finished by, and call al_join_thread then. Don't forget to use al_destroy_thread or you're leaking memory (Make the thread a class member).

I cannot tell from your code exactly how things are working. For it to be effective, you must let the thread do its thing while you continue on with the other stuff.

For example this does nothing useful, as you are not doing anything in between the start and join:

t = al_create_thread(make_bitmap, this);
al_start_thread(t);
al_join_thread(t, NULL);