D:/WorkAround/prequengine/trunk/src/redraw.c

Go to the documentation of this file.

#include "redraw.h"
#include "sdlengine.h"
#include "lbaengine.h"
#include "interface.h"
#include "images.h"
#include "grid.h"
#include "scene.h"
#include "actor.h"
#include "hqrdepack.h"
#include "resources.h"
#include "menu.h"

#ifdef GAMEMOD
#include "debug.scene.h"
#endif


typedef struct RedrawStruct
{
  unsigned short int left;
  unsigned short int top;
  unsigned short int right;
  unsigned short int bottom;
} RedrawStruct;

RedrawStruct currentRedrawList[300];
RedrawStruct nextRedrawList[300];

typedef struct DrawListStruct
{
  short int posValue;
  unsigned short int index; // field_2
  unsigned short int X;
  unsigned short int Y;
  unsigned short int Z;
  unsigned short int field_A;
  unsigned short int field_C;
  unsigned short int field_E;
  unsigned short int field_10;
} DrawListStruct;

DrawListStruct drawList[150];

int currNumOfRedrawBox; // fullRedrawVar8
int numOfRedrawBox;

void add_redraw_current_area(int left, int top, int right, int bottom)
{
        int area;
        int i = 0;
        int leftValue;
        int rightValue;
        int topValue;
        int bottomValue;

        area = (right - left) * (bottom - top);

        while (i < numOfRedrawBox)
        {
                if (currentRedrawList[i].left >= left)
                        leftValue = left;
                else
                        leftValue = currentRedrawList[i].left;

                if (currentRedrawList[i].right <= right)
                        rightValue = right;
                else
                        rightValue = currentRedrawList[i].right;

                if (currentRedrawList[i].top >= top)
                        topValue = top;
                else
                        topValue = currentRedrawList[i].top;

                if (currentRedrawList[i].bottom <= bottom)
                        bottomValue = bottom;
                else
                        bottomValue = currentRedrawList[i].bottom;

                if ((rightValue - leftValue) * (bottomValue - topValue) < ((currentRedrawList[i].bottom - currentRedrawList[i].top) * (currentRedrawList[i].right - currentRedrawList[i].left) + area))
                {
                        currentRedrawList[i].left = leftValue;
                        currentRedrawList[i].top = topValue;
                        currentRedrawList[i].right = rightValue;
                        currentRedrawList[i].bottom = bottomValue;

                        if(currentRedrawList[i].bottom >= SCREEN_WIDTH)
                                currentRedrawList[i].bottom = SCREEN_TEXTLIMIT_BOTTOM;
                        return;
                }

                i++;
        };

        currentRedrawList[i].left = left;
        currentRedrawList[i].top = top;
        currentRedrawList[i].right = right;
        currentRedrawList[i].bottom = bottom;

        if(currentRedrawList[i].bottom >= SCREEN_WIDTH)
                currentRedrawList[i].bottom = SCREEN_TEXTLIMIT_BOTTOM;

        numOfRedrawBox++;
}

void add_redraw_area(int left, int top, int right, int bottom)
{
        if (left < 0)
                left = 0;
        if (top < 0)
                top = 0;
        if (right >= SCREEN_WIDTH)
                right = SCREEN_TEXTLIMIT_RIGHT;
        if (bottom >= SCREEN_HEIGHT)
                bottom = SCREEN_TEXTLIMIT_BOTTOM;

        if (left > right || top > bottom)
                return;

        nextRedrawList[currNumOfRedrawBox].left = left;
        nextRedrawList[currNumOfRedrawBox].top = top;
        nextRedrawList[currNumOfRedrawBox].right = right;
        nextRedrawList[currNumOfRedrawBox].bottom = bottom;

        currNumOfRedrawBox++;

        add_redraw_current_area(left, top, right, bottom);
}

void move_next_areas()
{
        int i;

        numOfRedrawBox = 0;

        for (i = 0; i < currNumOfRedrawBox; i++)
        {
                add_redraw_current_area(nextRedrawList[i].left, nextRedrawList[i].top, nextRedrawList[i].right, nextRedrawList[i].bottom);
        }
}

void flip_redraw_areas()
{
        int i;

        for (i = 0; i < numOfRedrawBox; i++) // redraw areas on screen
        {
                copy_block_phys(currentRedrawList[i].left, currentRedrawList[i].top, currentRedrawList[i].right, currentRedrawList[i].bottom);
        }

        numOfRedrawBox = 0;

        for (i = 0; i < currNumOfRedrawBox; i++) //setup the redraw areas for next display
        {
                add_redraw_current_area(nextRedrawList[i].left, nextRedrawList[i].top, nextRedrawList[i].right, nextRedrawList[i].bottom);
        }
}

void blit_background_areas()
{
        int i;
        RedrawStruct* currentArea;
        currentArea = currentRedrawList;

        for (i = 0; i < numOfRedrawBox; i++)
        {
                blit_box(currentArea->left, currentArea->top, currentArea->right, currentArea->bottom, (char *) workVideoBuffer, currentArea->left, currentArea->top, (char *) frontVideoBuffer);
                currentArea++;
        }
}

void sort_drawing_list(DrawListStruct *list, int listSize)
{
        int i;
        int j;

        DrawListStruct tempStruct;

        for(i=0;i<listSize-1;i++)
        {
                for(j=0;j<listSize-1-i;j++)
                {
                        if(list[j+1].posValue<list[j].posValue)
                        {
                                memcpy(&tempStruct,&list[j+1],sizeof(DrawListStruct));
                                memcpy(&list[j+1],&list[j],sizeof(DrawListStruct));
                                memcpy(&list[j],&tempStruct,sizeof(DrawListStruct));
                        }
                }
        }
}

int process_actors_drawlist(int bgRedraw)
{
        int tmpVal;
        int modelActorPos;  // arg_1A
        int spriteActorPos; // top6
        int shadowActorPos; // top2
        int drawListPos;    // a12
        ActorStruct *localActor;

        modelActorPos = 0;
        drawListPos = 0;
        spriteActorPos = modelActorPos + 0x1000;
        shadowActorPos = modelActorPos + 0x0C00;

        // Process actors drawing list
        for(modelActorPos=0; modelActorPos < sceneNumActors; modelActorPos++, spriteActorPos++, shadowActorPos++)
        {
                localActor = &sceneActors[modelActorPos];               
                localActor->dinamicFlags.bIsVisible = 0; // reset visible state

                if((useCellingGrid==-1) || localActor->Y <= (*(short int*)(cellingGridIdx*24 + (char *)sceneZones+8)))
                {
                        // no redraw required
                        if(localActor->staticFlags.bIsBackgrounded && bgRedraw==0)
                        {
                                // get actor position on screen
                                project_position_on_screen(localActor->X - cameraX, localActor->Y - cameraY, localActor->Z - cameraZ);
                                
                                // check if actor is visible on screen, otherwise don't display it
                                if(projPosX > -50 && projPosX < 680 && projPosY > -30 && projPosY < 580)
                                {
                                        localActor->dinamicFlags.bIsVisible = 1;
                                }
                        }
                        else
                        {
                                // if the actor isn't set as hidden
                                if(localActor->entity != -1 && !(localActor->staticFlags.bIsHidden))
                                {
                                        // get actor position on screen
                                        project_position_on_screen(localActor->X - cameraX, localActor->Y - cameraY, localActor->Z - cameraZ);
                                        
                                        if (((localActor->staticFlags.bUsesClipping) && projPosX > -112 && projPosX < 752 && projPosY > -50 && projPosY < 651) || 
                                                ((!(localActor->staticFlags.bUsesClipping)) && projPosX > -50 && projPosX < 680 && projPosY > -30 && projPosY < 580))
                                        {
                                                tmpVal = localActor->Z + localActor->X - cameraX - cameraZ;

                                                // if actor is above another actor
                                                if(localActor->standOn != -1)
                                                {
                                                        tmpVal = sceneActors[localActor->standOn].X - cameraX + sceneActors[localActor->standOn].Z - cameraZ + 2;
                                                }
                                        

                                                if(localActor->staticFlags.bIsSpriteActor)
                                                {
                                                        drawList[drawListPos].index = spriteActorPos; // > 0x1000
                                                        if(localActor->staticFlags.bUsesClipping)
                                                        {
                                                                tmpVal = localActor->lastX - cameraX + localActor->lastZ - cameraZ;
                                                        }
                                                }
                                                else
                                                {
                                                        drawList[drawListPos].index = modelActorPos;
                                                }

                                                drawList[drawListPos].posValue = tmpVal;

                                                drawListPos++;

                                                // if use shadows
                                                if(cfgfile.ShadowMode!=0 && !(localActor->staticFlags.bDoesntCastShadow))
                                                {
                                                        if(localActor->standOn != -1)
                                                        {
                                                                shadowX = localActor->X;
                                                                shadowY = localActor->Y-1;
                                                                shadowZ = localActor->Z;
                                                        }
                                                        else
                                                        {
                                                                //get_shadow_position(localActor->X, localActor->Y, localActor->Z);
                                                        }
                                                        
                                                        tmpVal--;
                                                        drawList[drawListPos].posValue = tmpVal; // save the shadow entry in the drawList
                                                        drawList[drawListPos].index = 0xC00;    // shadowActorPos
                                                        drawList[drawListPos].X = shadowX;
                                                        drawList[drawListPos].Y = shadowY;
                                                        drawList[drawListPos].Z = shadowZ;
                                                        drawList[drawListPos].field_A = 2;
                                                        drawListPos++;
                                                }
                                        }
                                }
                        }
                }
        }
        return drawListPos;
}

void process_drawing(int numDrawingList)
{
        int drawListPos = 0;

        // if has something to draw
        if(numDrawingList > 0)
        {
                unsigned int flags;
                int actorIdx;
                ActorStruct *localActor;

                do
                {
                        actorIdx = drawList[drawListPos].index & 0x3FF;
                        localActor = &sceneActors[actorIdx];
                        flags = ((unsigned int) drawList[drawListPos].index) & 0xFC00;

                        // Drawing actors
                        if (flags < 0xC00)
                        {
                                
                        }
                        // Drawing shadows
                        else if(flags == 0xC00)
                        {

                        }
                        // Drawing unknown
                        else if(flags < 0x1000)
                        {

                        }
                        // Drawing sprite actors
                        else if(flags == 0x1000)
                        {
                                int spriteWidth, spriteHeight;
                                //int spriteSize = spriteSizeTable[localActor->entity];
                                unsigned char *spritePtr = spriteTable[localActor->entity];

                                // get actor position on screen
                                project_position_on_screen(localActor->X - cameraX, localActor->Y - cameraY, localActor->Z - cameraZ);

                                get_sprite_size(0, &spriteWidth, &spriteHeight, spritePtr);

                                // calculate sprite position on screen
                                renderLeft = projPosX + *(short int *) (spriteBoundingBoxPtr + localActor->entity * 16);
                                renderTop = projPosY + *(short int *) (spriteBoundingBoxPtr + localActor->entity * 16 + 2);
                                renderRight = renderLeft + spriteWidth;
                                renderBottom = renderTop + spriteHeight;

                                if(localActor->staticFlags.bUsesClipping)
                                {
                                        set_clip(projPosXScreen + localActor->info0, projPosYScreen + localActor->info1, projPosXScreen + localActor->info2, projPosYScreen + localActor->info3);
                                }
                                else
                                {
                                        set_clip(renderLeft, renderTop, renderRight, renderBottom);
                                }

                                if (textWindowLeft <= textWindowRight && textWindowTop <= textWindowBottom)
                                {
                                        draw_sprite(0, renderLeft, renderTop, spritePtr);

                                        localActor->dinamicFlags.bIsVisible = 1;
                                        
                                        if(localActor->staticFlags.bUsesClipping)
                                        {
                                                draw_over_sprite_actor((localActor->lastX+0x100)>> 9,localActor->lastY >> 8,(localActor->lastZ+0x100) >> 9);
                                        }
                                        else
                                        {
                                                int tempX, tempZ, tempY;

                                                tempX = (localActor->X + localActor->boudingBox.X.topRight +0x100) >> 9;
                                                tempZ = localActor->Y >> 8;
                                                if (localActor->field_3 & 0x7F)
                                                  tempZ++;
                                                tempY = (localActor->Z + localActor->boudingBox.Z.topRight +0x100) >> 9;

                                                draw_over_sprite_actor(tempX, tempZ, tempY);
                                        }
                                        
                                        add_redraw_area(textWindowLeft, textWindowTop,textWindowRight, textWindowBottom);

                                        // show clipping area
                                        //draw_button_box(renderLeft, renderTop, renderRight, renderBottom);
                                }
                        }
                        // Drawing extras
                        else if(flags == 0x1800)
                        {

                        }

                        reset_clip();
                        drawListPos++;
                }while(drawListPos < numDrawingList);
        }
}

void redraw_engine_actions(int bgRedraw) // fullRedraw
{
        short int tmpProjPosX;
        short int tmpProjPosY;
        int numDrawingList;

        tmpProjPosX = projPosXScreen;
        tmpProjPosY = projPosYScreen;

        reset_clip();

        if(bgRedraw)
        {
                freeze_time();
                if(needChangeScene!=-1 && needChangeScene!=-2)
                        fade_out(paletteRGBA);
                clear_screen();
                redraw_grid();
                // TODO: Update overlay sprites positions
                copy_screen(frontVideoBuffer,workVideoBuffer);
                if(needChangeScene!=-1 && needChangeScene!=-2)
                        fade_in(paletteRGBA);
        }
        else
        {
                blit_background_areas();
        }

        // first loop
        numDrawingList = process_actors_drawlist(bgRedraw);

        sort_drawing_list(drawList,numDrawingList);

        currNumOfRedrawBox = 0;
        process_drawing(numDrawingList);

        #ifdef GAMEMOD
                display_zones(skipIntro);
        #endif

        // make celling grid fade
        // need to be here to fade after drawing all actors in scene
        if(needChangeScene==-2)
                cross_fade(frontVideoBuffer, paletteRGBA);

        if(bgRedraw)
        {
                flip();
                move_next_areas();
        }
        else
        {
                flip_redraw_areas();
        }
}

---