/* Copyright (C) 1994-2003 Revolution Software Ltd * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * $Header$ */ #include "stdafx.h" #include "driver96.h" #include "d_draw.h" #include "rdwin.h" #include "_mouse.h" #include "render.h" #include "menu.h" #include "../sword2.h" #define MILLISECSPERCYCLE 83 // Scroll variables. scrollx and scrolly hold the current scroll position, // and scrollxTarget and scrollyTarget are the target position for the end // of the game cycle. extern int16 scrollx; extern int16 scrolly; int16 parallaxScrollx; int16 parallaxScrolly; int16 locationWide; int16 locationDeep; static int16 scrollxTarget; static int16 scrollyTarget; static int16 scrollxOld; static int16 scrollyOld; static uint16 layer = 0; #define RENDERAVERAGETOTAL 4 int32 renderCountIndex = 0; int32 renderTimeLog[RENDERAVERAGETOTAL] = { 60, 60, 60, 60 }; int32 initialTime; int32 startTime; int32 totalTime; int32 renderAverageTime = 60; int32 framesPerGameCycle; int32 renderTooSlow; #define BLOCKWIDTH 64 #define BLOCKHEIGHT 64 #define BLOCKWBITS 6 #define BLOCKHBITS 6 #define MAXLAYERS 5 uint8 xblocks[MAXLAYERS]; uint8 yblocks[MAXLAYERS]; // blockSurfaces stores an array of sub-blocks for each of the parallax layers. typedef struct { byte data[BLOCKWIDTH * BLOCKHEIGHT]; bool transparent; } BlockSurface; BlockSurface **blockSurfaces[MAXLAYERS] = { 0, 0, 0, 0, 0 }; void UploadRect(Common::Rect *r) { g_system->copy_rect(lpBackBuffer + r->top * screenWide + r->left, screenWide, r->left, r->top, r->right - r->left, r->bottom - r->top); } void BlitBlockSurface(BlockSurface *s, Common::Rect *r, Common::Rect *clip_rect) { if (r->top > clip_rect->bottom || r->left > clip_rect->right || r->bottom <= clip_rect->top || r->right <= clip_rect->left) return; byte *src = s->data; if (r->top < clip_rect->top) { src -= BLOCKWIDTH * (r->top - clip_rect->top); r->top = clip_rect->top; } if (r->left < clip_rect->left) { src -= (r->left - clip_rect->left); r->left = clip_rect->left; } if (r->bottom > clip_rect->bottom) r->bottom = clip_rect->bottom; if (r->right > clip_rect->right) r->right = clip_rect->right; byte *dst = lpBackBuffer + r->top * screenWide + r->left; int i, j; if (s->transparent) { for (i = 0; i < r->bottom - r->top; i++) { for (j = 0; j < r->right - r->left; j++) { if (src[j]) dst[j] = src[j]; } src += BLOCKWIDTH; dst += screenWide; } } else { for (i = 0; i < r->bottom - r->top; i++) { memcpy(dst, src, r->right - r->left); src += BLOCKWIDTH; dst += screenWide; } } // UploadRect(r); SetNeedRedraw(); } static uint16 xScale[SCALE_MAXWIDTH]; static uint16 yScale[SCALE_MAXHEIGHT]; // I've made the scaling two separate functions because there were cases from // DrawSprite() where it wasn't obvious if the sprite should grow or shrink, // which caused crashes. // // Keeping them separate might be a good idea anyway, for readability. // // The code is based on the original DrawSprite() code, so apart from not // knowing if I got it right, I don't know how good the original really is. // // The backbuf parameter points to the buffer where the image will eventually // be drawn. This is only used at the highest graphics detail setting (and not // always even then) and is used to help anti-alias the image. void SquashImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight, byte *src, uint16 srcPitch, uint16 srcWidth, uint16 srcHeight, byte *backbuf) { int32 ince, incne, d; int16 x, y; // Work out the x-scale ince = 2 * dstWidth; incne = 2 * (dstWidth - srcWidth); d = 2 * dstWidth - srcWidth; x = y = 0; xScale[y] = x; while (x < srcWidth) { if (d <= 0) { d += ince; x++; } else { d += incne; x++; y++; } xScale[y] = x; } // Work out the y-scale ince = 2 * dstHeight; incne = 2 * (dstHeight - srcHeight); d = 2 * dstHeight - srcHeight; x = y = 0; yScale[y] = x; while (x < srcHeight) { if (d <= 0) { d += ince; x++; } else { d += incne; x++; y++; } yScale[y] = x; } // Copy the image (with or without anti-aliasing) if (backbuf) { for (y = 0; y < dstHeight; y++) { for (x = 0; x < dstWidth; x++) { uint8 p; uint8 p1 = 0; int count = 0; int spriteCount = 0; int red = 0; int green = 0; int blue = 0; int i, j; for (j = yScale[y]; j < yScale[y + 1]; j++) { for (i = xScale[x]; i < xScale[x + 1]; i++) { p = src[j * srcPitch + i]; if (p) { red += palCopy[p][0]; green += palCopy[p][1]; blue += palCopy[p][2]; p1 = p; spriteCount++; } else { red += palCopy[backbuf[x]][0]; green += palCopy[backbuf[x]][1]; blue += palCopy[backbuf[x]][2]; } count++; } } if (spriteCount == 0) dst[x] = 0; else if (spriteCount == 1) dst[x] = p1; else dst[x] = QuickMatch((uint8) (red / count), (uint8) (green / count), (uint8) (blue / count)); } dst += dstPitch; backbuf += screenWide; } } else { for (y = 0; y < dstHeight; y++) { for (x = 0; x < dstWidth; x++) { dst[x] = src[yScale[y] * srcPitch + xScale[x]]; } dst += dstPitch; } } } void StretchImage(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight, byte *src, uint16 srcPitch, uint16 srcWidth, uint16 srcHeight, byte *backbuf) { byte *origDst = dst; int32 ince, incne, d; int16 x, y, i, j, k; // Work out the x-scale ince = 2 * srcWidth; incne = 2 * (srcWidth - dstWidth); d = 2 * srcWidth - dstWidth; x = y = 0; xScale[y] = x; while (x < dstWidth) { if (d <= 0) { d += ince; x++; } else { d += incne; x++; y++; xScale[y] = x; } } // Work out the y-scale ince = 2 * srcHeight; incne = 2 * (srcHeight - dstHeight); d = 2 * srcHeight - dstHeight; x = y = 0; yScale[y] = x; while (x < dstHeight) { if (d <= 0) { d += ince; x++; } else { d += incne; x++; y++; yScale[y] = x; } } // Copy the image for (y = 0; y < srcHeight; y++) { for (j = yScale[y]; j < yScale[y + 1]; j++) { k = 0; for (x = 0; x < srcWidth; x++) { for (i = xScale[x]; i < xScale[x + 1]; i++) { dst[k++] = src[y * srcPitch + x]; } } dst += dstPitch; } } // Anti-aliasing if (backbuf) { byte *newDst = (byte *) malloc(dstWidth * dstHeight); if (!newDst) return; memcpy(newDst, origDst, dstWidth); for (y = 1; y < dstHeight - 1; y++) { src = origDst + y * dstPitch; dst = newDst + y * dstWidth; *dst++ = *src++; for (x = 1; x < dstWidth - 1; x++) { byte pt[5]; byte *p = backbuf + y * 640 + x; int count = 0; if (*src) { count++; pt[0] = *src; } else pt[0] = *p; pt[1] = *(src - dstPitch); if (pt[1] == 0) pt[1] = *(p - 640); else count++; pt[2] = *(src - 1); if (pt[2] == 0) pt[2] = *(p - 1); else count++; pt[3] = *(src + 1); if (pt[3] == 0) pt[3] = *(p + 1); else count++; pt[4] = *(src + dstPitch); if (pt[4] == 0) pt[4] = *(p + 640); else count++; if (count) { int red = palCopy[pt[0]][0] << 2; int green = palCopy[pt[0]][1] << 2; int blue = palCopy[pt[0]][2] << 2; for (i = 1; i < 5; i++) { red += palCopy[pt[i]][0]; green += palCopy[pt[i]][1]; blue += palCopy[pt[i]][2]; } *dst++ = QuickMatch((uint8) (red >> 3), (uint8) (green >> 3), (uint8) (blue >> 3)); } else *dst++ = 0; src++; } *dst++ = *src++; } memcpy(dst, src, dstWidth); src = newDst; dst = origDst; for (i = 0; i < dstHeight; i++) { memcpy(dst, src, dstWidth); dst += dstPitch; src += dstWidth; } free(newDst); } } int32 RestoreBackgroundLayer(_parallax *p, int16 l) { int16 oldLayer = layer; debug(2, "RestoreBackgroundLayer %d", l); layer = l; if (blockSurfaces[l]) { for (int i = 0; i < xblocks[l] * yblocks[l]; i++) { if (blockSurfaces[l][i]) free(blockSurfaces[l][i]); } free(blockSurfaces[l]); blockSurfaces[l] = NULL; } InitialiseBackgroundLayer(p); layer = oldLayer; return RD_OK; } /** * Plots a point relative to the top left corner of the screen. This is only * used for debugging. * @param x x-coordinate of the point * @param y y-coordinate of the point * @param colour colour of the point */ int32 PlotPoint(uint16 x, uint16 y, uint8 colour) { warning("stub PlotPoint( %d, %d, %d )", x, y, colour); /* int16 newx, newy; newx = x - scrollx; newy = y - scrolly; if ((newx < 0) || (newx > RENDERWIDE) || (newy < 0) || (newy > RENDERDEEP)) { return(RD_OK); } if (renderCaps & RDBLTFX_ALLHARDWARE) { DDSURFACEDESC ddsd; HRESULT hr; ddsd.dwSize = sizeof(DDSURFACEDESC); hr = IDirectDrawSurface2_Lock(lpBackBuffer, NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL); if (hr != DD_OK) { hr = IDirectDrawSurface2_Lock(lpBackBuffer, NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL); } if (hr == DD_OK) { *((uint8 *) ddsd.lpSurface + (newy + 40) * ddsd.lPitch + newx) = colour; IDirectDrawSurface2_Unlock(lpBackBuffer, ddsd.lpSurface); } } else myScreenBuffer[newy * RENDERWIDE + newx] = colour; */ return(RD_OK); } /** * Draws a line from one point to another. This is only used for debugging. * @param x0 x-coordinate of the start point * @param y0 y-coordinate of the start point * @param x1 x-coordinate of the end point * @param y1 y-coordinate of the end point * @param colour colour of the line */ // Uses Bressnham's incremental algorithm! int32 DrawLine(int16 x0, int16 y0, int16 x1, int16 y1, uint8 colour) { warning("stub DrawLine( %d, %d, %d, %d, %d )", x0, y0, x1, y1, colour); /* int dx, dy; int dxmod, dymod; int ince, incne; int d; int x, y; int addTo; DDSURFACEDESC ddsd; HRESULT hr; x1 -= scrollx; y1 -= scrolly; x0 -= scrollx; y0 -= scrolly; // Lock the surface if we're rendering to the back buffer. if (renderCaps & RDBLTFX_ALLHARDWARE) { ddsd.dwSize = sizeof(DDSURFACEDESC); hr = IDirectDrawSurface2_Lock(lpBackBuffer, NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL); if (hr != DD_OK) { hr = IDirectDrawSurface2_Lock(lpBackBuffer, NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL); } if (hr != DD_OK) return(RD_OK); (uint8 *) ddsd.lpSurface += (40 * ddsd.lPitch); } //Make sure we're going from left to right if (x1 < x0) { x = x1; x1 = x0; x0 = x; y = y1; y1 = y0; y0 = y; } dx = x1 - x0; dy = y1 - y0; if (dx < 0) dxmod = -dx; else dxmod = dx; if (dy < 0) dymod = -dy; else dymod = dy; if (dxmod >= dymod) { if (dy > 0) { d = 2 * dy - dx; ince = 2 * dy; incne = 2 * (dy - dx); x = x0; y = y0; if ((x >= 0) && (x < RENDERWIDE) && (y >= 0) && (y < RENDERDEEP)) if (renderCaps & RDBLTFX_ALLHARDWARE) *((uint8 *) ddsd.lpSurface + y * ddsd.lPitch + x) = colour; else myScreenBuffer[y * RENDERWIDE + x] = colour; while (x < x1) { if (d <= 0) { d += ince; x += 1; } else { d += incne; x += 1; y += 1; } if ((x >= 0) && (x < RENDERWIDE) && (y >= 0) && (y < RENDERDEEP)) if (renderCaps & RDBLTFX_ALLHARDWARE) *((uint8 *) ddsd.lpSurface + y * ddsd.lPitch + x) = colour; else myScreenBuffer[y * RENDERWIDE + x] = colour; } } else { addTo = y0; y0 = 0; y1 -= addTo; y1 = -y1; dy = y1 - y0; d = 2 * dy - dx; ince = 2 * dy; incne = 2 * (dy - dx); x = x0; y = y0; if ((x >= 0) && (x < RENDERWIDE) && (addTo - y >= 0) && (addTo - y < RENDERDEEP)) if (renderCaps & RDBLTFX_ALLHARDWARE) *((uint8 *) ddsd.lpSurface + (addTo - y) * ddsd.lPitch + x) = colour; else myScreenBuffer[(addTo - y) * RENDERWIDE + x] = colour; while (x < x1) { if (d <= 0) { d += ince; x += 1; } else { d += incne; x += 1; y += 1; } if ((x >= 0) && (x < RENDERWIDE) && (addTo - y >= 0) && (addTo - y < RENDERDEEP)) if (renderCaps & RDBLTFX_ALLHARDWARE) *((uint8 *) ddsd.lpSurface + (addTo - y) * ddsd.lPitch + x) = colour; else myScreenBuffer[(addTo - y) * RENDERWIDE + x] = colour; } } } else { //OK, y is now going to be the single increment. // Ensure the line is going top to bottom if (y1 < y0) { x = x1; x1 = x0; x0 = x; y = y1; y1 = y0; y0 = y; } dx = x1 - x0; dy = y1 - y0; if (dx > 0) { d = 2 * dx - dy; ince = 2 * dx; incne = 2 * (dx - dy); x = x0; y = y0; if ((x >= 0) && (x < RENDERWIDE) && (y >= 0) && (y < RENDERDEEP)) if (renderCaps & RDBLTFX_ALLHARDWARE) *((uint8 *) ddsd.lpSurface + y * ddsd.lPitch + x) = colour; else myScreenBuffer[y * RENDERWIDE + x] = colour; while (y < y1) { if (d <= 0) { d += ince; y += 1; } else { d += incne; x += 1; y += 1; } if ((x >= 0) && (x < RENDERWIDE) && (y >= 0) && (y < RENDERDEEP)) if (renderCaps & RDBLTFX_ALLHARDWARE) *((uint8 *) ddsd.lpSurface + y * ddsd.lPitch + x) = colour; else myScreenBuffer[y * RENDERWIDE + x] = colour; } } else { addTo = x0; x0 = 0; x1 -= addTo; x1 = -x1; dx = x1 - x0; d = 2 * dx - dy; ince = 2 * dx; incne = 2 * (dx - dy); x = x0; y = y0; if ((addTo - x >= 0) && (addTo - x < RENDERWIDE) && (y >= 0) && (y < RENDERDEEP)) if (renderCaps & RDBLTFX_ALLHARDWARE) *((uint8 *) ddsd.lpSurface + y * ddsd.lPitch + addTo - x) = colour; else myScreenBuffer[y * RENDERWIDE + addTo - x] = colour; while (y < y1) { if (d <= 0) { d += ince; y += 1; } else { d += incne; x += 1; y += 1; } if ((addTo - x >= 0) && (addTo - x < RENDERWIDE) && (y >= 0) && (y < RENDERDEEP)) if (renderCaps & RDBLTFX_ALLHARDWARE) *((uint8 *) ddsd.lpSurface + y * ddsd.lPitch + addTo - x) = colour; else myScreenBuffer[y * RENDERWIDE + addTo - x] = colour; } } } if (renderCaps & RDBLTFX_ALLHARDWARE) { (uint8 *) ddsd.lpSurface -= (40 * ddsd.lPitch); IDirectDrawSurface2_Unlock(lpBackBuffer, ddsd.lpSurface); } */ return RD_OK; } /** * This function tells the driver the size of the background screen for the * current location. * @param w width of the current location * @param h height of the current location */ int32 SetLocationMetrics(uint16 w, uint16 h) { locationWide = w; locationDeep = h; return RD_OK; } /** * Draws a parallax layer at the current position determined by the scroll. A * parallax can be either foreground, background or the main screen. */ int32 RenderParallax(_parallax *p, int16 l) { int16 x, y; Common::Rect r; if (locationWide == screenWide) x = 0; else x = ((int32) ((p->w - screenWide) * scrollx) / (int32) (locationWide - screenWide)); if (locationDeep == (screenDeep - MENUDEEP * 2)) y = 0; else y = ((int32) ((p->h - (screenDeep - MENUDEEP * 2)) * scrolly) / (int32) (locationDeep - (screenDeep - MENUDEEP * 2))); Common::Rect clip_rect; // Leave enough space for the top and bottom menues clip_rect.left = 0; clip_rect.right = screenWide; clip_rect.top = MENUDEEP; clip_rect.bottom = screenDeep - MENUDEEP; for (int j = 0; j < yblocks[l]; j++) { for (int i = 0; i < xblocks[l]; i++) { if (blockSurfaces[l][i + j * xblocks[l]]) { r.left = i * BLOCKWIDTH - x; r.right = r.left + BLOCKWIDTH; r.top = j * BLOCKHEIGHT - y + 40; r.bottom = r.top + BLOCKHEIGHT; BlitBlockSurface(blockSurfaces[l][i + j * xblocks[l]], &r, &clip_rect); } } } parallaxScrollx = scrollx - x; parallaxScrolly = scrolly - y; return RD_OK; } // Uncomment this when benchmarking the drawing routines. #define LIMIT_FRAME_RATE /** * Initialises the timers before the render loop is entered. */ int32 InitialiseRenderCycle(void) { initialTime = SVM_timeGetTime(); totalTime = initialTime + MILLISECSPERCYCLE; return RD_OK; } /** * This function should be called when the game engine is ready to start the * render cycle. */ int32 StartRenderCycle(void) { scrollxOld = scrollx; scrollyOld = scrolly; startTime = SVM_timeGetTime(); if (startTime + renderAverageTime >= totalTime) { scrollx = scrollxTarget; scrolly = scrollyTarget; renderTooSlow = 1; } else { scrollx = (int16) (scrollxOld + ((scrollxTarget - scrollxOld) * (startTime - initialTime + renderAverageTime)) / (totalTime - initialTime)); scrolly = (int16) (scrollyOld + ((scrollyTarget - scrollyOld) * (startTime - initialTime + renderAverageTime)) / (totalTime - initialTime)); renderTooSlow = 0; } framesPerGameCycle = 0; return RD_OK; } // FIXME: Move this to some better place? void sleepUntil(int32 time) { while ((int32) SVM_timeGetTime() < time) { g_sword2->parseEvents(); // Make sure menu animations and fades don't suffer ProcessMenu(); ServiceWindows(); g_system->delay_msecs(10); } } /** * This function should be called at the end of the render cycle. * @param end the function sets this to true if the render cycle is to be * terminated, or false if it should continue */ int32 EndRenderCycle(bool *end) { int32 time; time = SVM_timeGetTime(); renderTimeLog[renderCountIndex] = time - startTime; startTime = time; renderAverageTime = (renderTimeLog[0] + renderTimeLog[1] + renderTimeLog[2] + renderTimeLog[3]) >> 2; framesPerGameCycle += 1; if (++renderCountIndex == RENDERAVERAGETOTAL) renderCountIndex = 0; if (renderTooSlow) { *end = true; InitialiseRenderCycle(); } else if (startTime + renderAverageTime >= totalTime) { *end = true; totalTime += MILLISECSPERCYCLE; initialTime = time; #ifdef LIMIT_FRAME_RATE } else if (scrollxTarget == scrollx && scrollyTarget == scrolly) { // If we have already reached the scroll target sleep for the // rest of the render cycle. *end = true; sleepUntil(totalTime); initialTime = SVM_timeGetTime(); totalTime += MILLISECSPERCYCLE; #endif } else { *end = false; // This is an attempt to ensure that we always reach the scroll // target. Otherwise the game frequently tries to pump out new // interpolation frames without ever getting anywhere. if (ABS(scrollx - scrollxTarget) <= 1 && ABS(scrolly - scrollyTarget) <= 1) { scrollx = scrollxTarget; scrolly = scrollyTarget; } else { scrollx = (int16) (scrollxOld + ((scrollxTarget - scrollxOld) * (startTime - initialTime + renderAverageTime)) / (totalTime - initialTime)); scrolly = (int16) (scrollyOld + ((scrollyTarget - scrollyOld) * (startTime - initialTime + renderAverageTime)) / (totalTime - initialTime)); } } return RD_OK; } /** * Sets the scroll target position for the end of the game cycle. The driver * will then automatically scroll as many times as it can to reach this * position in the allotted time. */ int32 SetScrollTarget(int16 sx, int16 sy) { scrollxTarget = sx; scrollyTarget = sy; return RD_OK; } /** * This function should be called five times with either the parallax layer * or a NULL pointer in order of background parallax to foreground parallax. */ int32 InitialiseBackgroundLayer(_parallax *p) { uint8 *memchunk; uint8 zeros; uint16 count; uint16 i, j, k; uint16 x; uint8 *data; uint8 *dst; _parallaxLine line; uint8 *pLine; debug(2, "InitialiseBackgroundLayer"); // This function is called to re-initialise the layers if they have // been lost. We know this if the layers have already been assigned. // TODO: Can layers still be lost, or is that a DirectDraw-ism? if (layer == MAXLAYERS) CloseBackgroundLayer(); if (!p) { layer++; return RD_OK; } xblocks[layer] = (p->w + BLOCKWIDTH - 1) >> BLOCKWBITS; yblocks[layer] = (p->h + BLOCKHEIGHT - 1) >> BLOCKHBITS; blockSurfaces[layer] = (BlockSurface **) calloc(xblocks[layer] * yblocks[layer], sizeof(BlockSurface *)); if (!blockSurfaces[layer]) return RDERR_OUTOFMEMORY; // Decode the parallax layer into a large chunk of memory memchunk = (uint8 *) malloc(xblocks[layer] * BLOCKWIDTH * yblocks[layer] * BLOCKHEIGHT); if (!memchunk) return RDERR_OUTOFMEMORY; // We clear not the entire memory chunk, but enough of it to store // the entire parallax layer. memset(memchunk, 0, p->w * p->h); for (i = 0; i < p->h; i++) { if (p->offset[i] == 0) continue; pLine = (uint8 *) p + FROM_LE_32(p->offset[i]); line.packets = READ_LE_UINT16(pLine); line.offset = READ_LE_UINT16(pLine + 2); data = pLine + sizeof(_parallaxLine); x = line.offset; dst = memchunk + i * p->w + x; zeros = 0; if (line.packets == 0) { memcpy(dst, data, p->w); continue; } for (j = 0; j < line.packets; j++) { if (zeros) { dst += *data; x += *data; data++; zeros = 0; } else if (*data == 0) { data++; zeros = 1; } else { count = *data++; memcpy(dst, data, count); data += count; dst += count; x += count; zeros = 1; } } } // Now create the surfaces! for (i = 0; i < xblocks[layer] * yblocks[layer]; i++) { bool block_has_data = false; bool block_is_transparent = false; data = memchunk + (p->w * BLOCKHEIGHT * (i / xblocks[layer])) + BLOCKWIDTH * (i % xblocks[layer]); for (j = 0; j < BLOCKHEIGHT; j++) { for (k = 0; k < BLOCKWIDTH; k++) { if (data[j * p->w + k]) block_has_data = true; else block_is_transparent = true; } } // Only assign a surface to the block if it contains data. if (block_has_data) { blockSurfaces[layer][i] = (BlockSurface *) malloc(sizeof(BlockSurface)); // Copy the data into the surfaces. dst = blockSurfaces[layer][i]->data; for (j = 0; j < BLOCKHEIGHT; j++) { memcpy(dst, data, BLOCKWIDTH); data += p->w; dst += BLOCKWIDTH; } blockSurfaces[layer][i]->transparent = block_is_transparent; } else blockSurfaces[layer][i] = NULL; } free(memchunk); layer++; return RD_OK; } /** * Should be called once after leaving the room to free up memory. */ int32 CloseBackgroundLayer(void) { debug(2, "CloseBackgroundLayer"); for (int j = 0; j < MAXLAYERS; j++) { if (blockSurfaces[j]) { for (int i = 0; i < xblocks[j] * yblocks[j]; i++) if (blockSurfaces[j][i]) free(blockSurfaces[j][i]); free(blockSurfaces[j]); blockSurfaces[j] = NULL; } } layer = 0; return RD_OK; }