old school offscreen graphics

Hello, I've been here some months ago with my questions about System-6
compatible C programming, on various topics.

I'm currently very close to having a very useful function which sets a
BitMap memory space and draws graphics in it, off the screen, so that
it can later be used with copybits. Think of it as a sprite object in
memory, which seems to be what game programming libraries are doing.

Now, I thought it would be extremely straightfoward to:

1) load a PICT resource from a file
2) read the Rect size from the picHandle and deduce the rowBytes for
the receiving bitmap
3) allocate space for the bitmap
4) change the portbits to that very bitmap
5) use drawpicture to draw unto it
6) close the picHandle and the port and return to the regular screen
port, and whatnot
7) use the offscreen bitmap with the fast copybits function.

But somewhere along the step, I'm drawing garbage on that memory
space. Will someone graciously look at my custom function? (I'm trying
to write my own .h file)


NOTE: I've pretty much narrowed it down to something that's happening
in LoadPicResIntoBitMap. I've been able to use offscreen bitmaps
(therefore, CreateOffscreenBitMap is A-OK) that are screen sized
without any problem. I'm only having problem with these custom sized
bitmaps that I'm trying to set up exactly as big at the PICT
resources.

----

Boolean LoadPicResIntoBitMap(BitMap *loadBM,int picID,
ConstStr255Param fileName);
Boolean CreateOffscreenBitMap(GrafPtr *newOffscreen, Rect *inBounds);
void DestroyOffscreenBitMap(GrafPtr oldOffscreen);

Boolean LoadPicResIntoBitMap(BitMap *loadBM,int picID,
ConstStr255Param fileName)
{
PicHandle myPicH;
int resID;
GrafPtr oldG, newG;

if(!(loadBM) || !(picID) || !(fileName)) return FALSE;
GetPort(&oldG); /* saves port before function call, will restore
at end */

myPicH=(PicHandle)NewHandle(sizeof(Picture));
if(myPicH==NULL) ExitToShell();
resID=OpenResFile(fileName);
if(!resID) ExitToShell();
myPicH=GetPicture(picID); /* 5 previous lines handle the PICT
retrieval */

HLock((Handle)myPicH);
loadBM->bounds=(*myPicH)->picFrame;


/* Next line creates a new port with the correct sized Rect read from
the PICT */

if (!CreateOffscreenBitMap(&newG, &(loadBM->bounds))) {
SysBeep(1);
ExitToShell();
}
SetPort(newG);
SetPortBits(loadBM);
EraseRect(&(loadBM->bounds));

/* Once the offscreen BitMap object is set as the port, draw onto it
from the picHandle*/
DrawPicture(myPicH,&(loadBM->bounds));
HUnlock((Handle)myPicH);
DisposeHandle((Handle)myPicH);

/* Last lines take care of the cleanup, hopefully the BitMap is still
usable */
SetPort(oldG);

DestroyOffscreenBitMap(newG);
return TRUE;
}

Boolean CreateOffscreenBitMap(GrafPtr *newOffscreen, Rect *inBounds)
{
GrafPtr savePort;
GrafPtr newPort;

GetPort(&savePort); /* need this to restore thePort after
OpenPort */

newPort = (GrafPtr) NewPtr(sizeof(GrafPort)); /* allocate
the grafPort */
if (MemError() != noErr)
return FALSE; /* failed to allocate the
off-screen port */
/*
the call to OpenPort does the following . . .
allocates space for visRgn (set to screenBits.bounds)
and
clipRgn (set wide open)
sets portBits to screenBits
sets portRect to screenBits.bounds
(See Inside Mac: Imaging with QuickDraw,
pages 2-38 to 2-39)
side effect: does a SetPort(&offScreen)
*/
OpenPort(newPort);
/* make bitmap the size of the bounds that caller supplied
*/
newPort->portRect = *inBounds;
newPort->portBits.bounds = *inBounds;
RectRgn(newPort->clipRgn, inBounds); /* avoid wide-open
clipRgn, be safe */
RectRgn(newPort->visRgn, inBounds); /* in case newBounds
is screen bounds */

/* rowBytes is size of row, it must be rounded up to an even
number of bytes */
newPort->portBits.rowBytes = ((inBounds->right -
inBounds->left +
15) >> 4) << 1;

/* number of bytes in BitMap is rowBytes * number of rows */
/* see notes at end of Technote about using _NewHandle
rather than _NewPtr*/
newPort->portBits.baseAddr =
NewPtr(newPort->portBits.rowBytes * (long)
(inBounds->bottom
- inBounds->top));
if (newPort->portBits.baseAddr == nil) { /* check to see if
we had
enough room for the bits */
SetPort(savePort);
ClosePort(newPort); /* dump the visRgn and clipRgn
*/
DisposPtr((Ptr)newPort); /* dump the GrafPort */
return false; /* tell caller we failed */
}
/* since the bits are just memory, let's clear them before
we start*/
EraseRect(inBounds); /* OpenPort did a SetPort(newPort)
so we are ok */
*newOffscreen = newPort;
SetPort(savePort);
return TRUE; /* tell caller we succeeded! */
}

void DestroyOffscreenBitMap(GrafPtr oldOffscreen)
{
ClosePort(oldOffscreen); /* dump the visRgn and
clipRgn */
DisposPtr(oldOffscreen->portBits.baseAddr); /* dump the
bits */
DisposPtr((Ptr)oldOffscreen); /* dump the port */
}

This code has lots of problems.

In article <b1c9e2ae.0408272129.257b3e1c.RemoveThis@posting.google.com>,
micjuneau.RemoveThis@gmail.com (Micjuneau) wrote:

 > myPicH=(PicHandle)NewHandle(sizeof(Picture));

a picture is a variable size struct, not related to sizeof(Picture)

 > if(myPicH==NULL) ExitToShell();
 > resID=OpenResFile(fileName);
 > if(!resID) ExitToShell();
 > myPicH=GetPicture(picID); /* 5 previous lines handle the PICT

You've just leaked the NewHandle you created in line 1. You're call to
NewHandle was incorrect. It should have been:

myPicH = NULL;

since GetPicture will read it from the resource file. The Resource Map
still owns the return value of GetPicture(). You are incorrect when you
say:
 > DisposeHandle((Handle)myPicH);


 > SetPortBits(loadBM);

this stores loadBM into newG, even though you've carefully allocated an
appropriate bitMap into newG. You just leaked newPort's original bitMap.

 > DestroyOffscreenBitMap(newG);

since newG still references loadBM, you've just disposed the bitmap
you've been drawing on.

Do you know the concept of "ownership"? if A owns B, then only A has the
right to destroy B, and A has the responsibility of destroying B when
the time comes.

You need to go through your code and think about who owns what when.<!-- ~MESSAGE_AFTER~ -->