void CheckSurfaceRecreation(LPRDATA rdPtr)
{
fprh rhPtr = rdPtr->rHo.hoAdRunHeader;
LPSURFACE ps = WinGetSurface((int)rhPtr->rhIdEditWin);
LPSURFACE pProto = NULL;
ParallaxFrame current = *rdPtr->currentPframe;
//Recreate surface if nessecary.
if( (rdPtr->direction == HORIZONTAL && rdPtr->rHo.hoImgWidth != rdPtr->oldWidth) ||
(rdPtr->direction == VERTICAL && rdPtr->rHo.hoImgHeight != rdPtr->oldHeight) ||
(rdPtr->finalImage == NULL)
)
{
if( rdPtr->finalImage != NULL )
{
rdPtr->finalImage->Delete();
delete rdPtr->finalImage;
}
rdPtr->finalImage = new cSurface();
if ( GetSurfacePrototype( &pProto, ps->GetDepth(), ST_MEMORY, SD_DIB) )
{
int newWidth = (rdPtr->direction == HORIZONTAL) ? rdPtr->rHo.hoImgWidth : current.parallaxImage->GetWidth();
int newHeight = (rdPtr->direction == HORIZONTAL) ? current.parallaxImage->GetHeight() : rdPtr->rHo.hoImgHeight;
rdPtr->finalImage->Create(newWidth, newHeight, pProto);
if( !rdPtr->finalImage->IsValid() )
{
rdPtr->finalImage->Delete();
delete rdPtr->finalImage;
}
}
}
rdPtr->oldWidth = rdPtr->rHo.hoImgWidth;
rdPtr->oldHeight = rdPtr->rHo.hoImgHeight;
}
void LoadImageFile(LPRDATA rdPtr, LPSTR pFileName)
{
LPRH rhPtr = rdPtr->rHo.hoAdRunHeader;
HANDLE hf = INVALID_HANDLE_VALUE;
do {
if ( pFileName == NULL || *pFileName == 0 )
break;
// Copy filename to temp buffer
char fname[MAX_PATH];
strcpy(fname, pFileName);
// Get surface prototype
LPSURFACE wSurf = WinGetSurface((int)rhPtr->rhIdEditWin);
LPSURFACE proto;
GetSurfacePrototype(&proto, (wSurf != NULL) ? wSurf->GetDepth() : 24, ST_MEMORYWITHDC, SD_DIB);
if ( proto == NULL )
break;
// Ask MMF2 to open the file (opens external file and embedded files, and downloads files in Vitalize mode)
DWORD dwSize;
hf = rhPtr->rh4.rh4Mv->mvOpenHFile(fname, &dwSize, 0);
if ( hf == INVALID_HANDLE_VALUE )
break;
// Create CInpuBufFile object associated with the file handle
DWORD dwOff = File_GetPosition((HFILE)hf);
CInputBufFile bf;
if ( bf.Create((HFILE)hf, dwOff, dwSize) != 0 )
break;
// Create surface
cSurface* psf = NewSurface();
if ( psf == NULL )
break;
psf->Create(4, 4, proto);
psf->Fill(RGB(0,0,0));
if ( psf->GetDepth() == 8 )
psf->SetPalette (*wSurf);
// Load picture
CImageFilterMgr* pImgMgr = rhPtr->rh4.rh4Mv->mvImgFilterMgr;
if ( ImportImageFromInputFile(pImgMgr, &bf, psf, NULL, IMPORT_IMAGE_USESURFACEDEPTH | IMPORT_IMAGE_USESURFACEPALETTE) )
{
// Copy filename if file successfully loaded
strcpy(rdPtr->sFilename, fname);
rdPtr->nWidth = rdPtr->rHo.hoImgWidth = psf->GetWidth();
rdPtr->nHeight = rdPtr->rHo.hoImgHeight = psf->GetHeight();
// Replace picture surface
if ( rdPtr->pSf != NULL )
DeleteSurface(rdPtr->pSf);
rdPtr->pSf = psf;
// Free collision mask
FreeColMask(rdPtr);
// Set transparent color
if ( psf->GetTransparentColor() == RGB(0,0,0) )
{
COLORREF trspColor = rdPtr->dwTranspColor;
if ( (rdPtr->dwOptions & SPICTFLAGS_TRANSP_FIRSTPIXEL) != 0 )
psf->GetPixel(0,0,trspColor);
psf->SetTransparentColor(trspColor);
}
}
else
DeleteSurface(psf);
} while(FALSE);
// Close picture file (opened with mvOpenHFile)
if ( hf != INVALID_HANDLE_VALUE )
rhPtr->rh4.rh4Mv->mvCloseHFile(hf);
}
short WINAPI DLLExport CreateRunObject(LPRDATA rdPtr, LPEDATA edPtr, fpcob cobPtr)
{
// Do some rSDK stuff
#include "rCreateRunObject.h"
#ifdef _DEBUG
AllocConsole();
freopen("conin$", "r", stdin);
freopen("conout$", "w", stdout);
freopen("conout$", "w", stderr);
printf("TILEMAPVIEWPORT DEBUG MODE");
#ifdef HWABETA
printf(" (HWA)");
#endif
printf("\n");
#endif
LPRH rhPtr = rdPtr->rHo.hoAdRunHeader;
rdPtr->isHwa = rhPtr->rh4.rh4Mv->mvCallFunction(NULL, EF_ISHWA, 0, 0, 0) != 0;
rdPtr->isUnicode = rhPtr->rh4.rh4Mv->mvCallFunction(NULL, EF_ISUNICODE, 0, 0, 0) != 0;
rdPtr->rHo.hoImgWidth = edPtr->width;
rdPtr->rHo.hoImgHeight = edPtr->height;
rdPtr->rc.rcChanged = true;
// No parent by default...
rdPtr->p = 0;
// Create surface, get MMF depth..
cSurface * ps = WinGetSurface((int)rdPtr->rHo.hoAdRunHeader->rhIdEditWin);
rdPtr->depth = ps->GetDepth();
rdPtr->surface = 0;
#ifndef HWABETA
/* Non-transparent surfaces are rendered to an opaque viewport surface so
that
the tiles do not have to be redrawn every single frame.
*/
if (!edPtr->transparent) {
cSurface * proto;
GetSurfacePrototype(&proto, rdPtr->depth, ST_MEMORY, SD_DIB);
rdPtr->surface = new cSurface;
rdPtr->surface->Create(rdPtr->rHo.hoImgWidth, rdPtr->rHo.hoImgHeight, proto);
}
#endif
// Animation settings
rdPtr->lastTick = GetTickCount();
rdPtr->animMode = edPtr->animMode;
for (int i = 0; i < 255; ++i) {
memset(&rdPtr->anim[i], 0, sizeof(Animation));
rdPtr->anim[i].width = 1;
rdPtr->anim[i].height = 1;
rdPtr->anim[i].speed = 8.0f;
}
rdPtr->animTime = 0;
// HWA blit flags
rdPtr->blitFlags = edPtr->resample ? STRF_RESAMPLE : 0;
// Background settings
rdPtr->transparent = edPtr->transparent;
rdPtr->background = edPtr->background;
rdPtr->accurateClip = edPtr->accurateClip;
// Layer stuff
rdPtr->minLayer = edPtr->minLayer;
rdPtr->maxLayer = edPtr->maxLayer;
// Misc
rdPtr->outsideColl = edPtr->outsideColl;
rdPtr->fineColl = edPtr->fineColl;
rdPtr->zoomColl = !edPtr->unscaledColl;
memset(&rdPtr->collMargin, 0, sizeof(RECT));
// Camera/drawing
rdPtr->zoom = 1.0f;
rdPtr->zoomPointX = 0.0f;
rdPtr->zoomPointY = 0.0f;
rdPtr->cameraX = 0;
rdPtr->cameraY = 0;
rdPtr->autoScroll = edPtr->autoScroll;
// Initialize callbacks
rdPtr->tileCallback.use = false;
rdPtr->tileCallback.settings = 0;
rdPtr->tileCallback.tile = 0;
rdPtr->layerCallback.use = false;
rdPtr->layerCallback.settings = 0;
// Overlap stuff
rdPtr->ovlpFilterCount = 0;
return 0;
}
short WINAPI DLLExport CreateRunObject(LPRDATA rdPtr, LPEDATA edPtr, fpcob cobPtr)
{
// Do some rSDK stuff
#include "rCreateRunObject.h"
#ifdef _DEBUG
AllocConsole();
freopen("conin$","r",stdin);
freopen("conout$","w",stdout);
freopen("conout$","w",stderr);
#ifdef UNICODE
printf("Surface Unicode version\n");
#endif
#endif
srand(time(NULL));
LPRH rhPtr = rdPtr->rHo.hoAdRunHeader;
mv* mV = rdPtr->rHo.hoAdRunHeader->rh4.rh4Mv;
rdPtr->rHo.hoImgWidth = edPtr->width_def;
rdPtr->rHo.hoImgHeight = edPtr->height_def;
rdPtr->useAbs = edPtr->useAbs;
rdPtr->keepPoints = edPtr->keepPoints;
rdPtr->dispTarget = edPtr->dispTarget;
rdPtr->selectLast = edPtr->selectLast;
rdPtr->threadedIO = edPtr->threadedIO;
rdPtr->ioFile = 0;
//Font
rdPtr->hFont = 0;
memcpy(&rdPtr->textFont,&edPtr->textFont,sizeof(LOGFONT));
rdPtr->hFlags = edPtr->textFlags;
//Depth
rdPtr->depth = 24;
//Internal blending
rdPtr->b.mode = BMODE_TRANSP;
rdPtr->b.operation = BOP_COPY;
rdPtr->b.param = 0;
rdPtr->b.param = 0xffffffff;
rdPtr->b.flags = 0;
rdPtr->b.destX = 0;
rdPtr->b.destY = 0;
rdPtr->b.destW = 0;
rdPtr->b.destH = 0;
rdPtr->b.StretchMode = 0;
rdPtr->b.srcX = 0;
rdPtr->b.srcY = 0;
rdPtr->b.srcW = 0;
rdPtr->b.srcH = 0;
rdPtr->b.srcUse = false;
rdPtr->b.callback[0] = 0;
rdPtr->b.procOp[0] = 0;
rdPtr->b.procOpSrc = 1;
rdPtr->b.composeAlpha = false;
rdPtr->b.angle = 0;
rdPtr->b.angleResample = false;
rdPtr->b.hotX = 0;
rdPtr->b.hotY = 0;
rdPtr->b.hotspotMode = 1; // no longer possible to disable
rdPtr->blitStackCursor = -1;
//Current & target surfaces
rdPtr->targetId = -1;
rdPtr->target = 0;
rdPtr->currentId = -1;
rdPtr->current = 0;
rdPtr->lastId = -1;
rdPtr->targetValid = false;
//Default settings
rdPtr->transCol = BLACK;
//Collision mask and fill data
rdPtr->collision = 0;
rdPtr->fill = new FillDB;
//Polygon's points
rdPtr->points = new PolyPoints;
//Buffer
rdPtr->buffer = 0;
rdPtr->buffPitch = 0;
rdPtr->buffSurf = 0;
//Overlay
rdPtr->ovl = 0;
//Callback
rdPtr->colSrc = 0;
rdPtr->colDest = 0;
rdPtr->colNew = 0;
rdPtr->colAlphaSrc = 0;
rdPtr->colAlphaDest = 0;
rdPtr->colAlphaNew = 0;
rdPtr->callback = 0;
rdPtr->callX = 0;
rdPtr->callY = 0;
rdPtr->colAlphaRet = 0;
rdPtr->colRet = 0;
//Flood fill region
rdPtr->floodL = 0;
rdPtr->floodT = 0;
rdPtr->floodR = 0;
rdPtr->floodB = 0;
//I/O
rdPtr->ioHandle = 0;
//Quick store
rdPtr->stored = 0;
// Random color function
rdPtr->randomSeed = 0;
//Functions for extension integration
rdPtr->imageAt = GetImgAt;
rdPtr->imageCount = GetImgCount;
//Running HWA?
LPSURFACE wSurf = WinGetSurface((int)rhPtr->rhIdEditWin);
int nDrv = wSurf->GetDriver();
rdPtr->isHWA = nDrv >= SD_3DFX;
//Display surface not necessary by default
rdPtr->display = 0;
rdPtr->rc.rcAngle = 0;
rdPtr->rc.rcScaleX = 1.0f;
rdPtr->rc.rcScaleY = 1.0f;
//Images
rdPtr->surf = new ImageBank;
//Hotspot info
Img imgInfo;
//Prototype for new surfaces
cSurface *proto = 0;
if(edPtr->multiImg)
{
//First image empty
if(!edPtr->images[0]&&edPtr->loadFirst)
{
cSurface *tmp = new cSurface;
rdPtr->surf->push_back(new SImage(tmp));
//Empty image with size
if(edPtr->loadFirst)
{
GetSurfacePrototype(&proto,rdPtr->depth,ST_MEMORYWITHDC,SD_DIB);
tmp->Create(edPtr->width,edPtr->height,proto);
tmp->Fill(BLACK);
}
rdPtr->targetId = rdPtr->currentId = rdPtr->lastId = 0;
TargetImg = CurrentImg = tmp;
rdPtr->targetValid = true;
}
for(int i=0;i<edPtr->imageCount;i++)
{
//Get surface prototype on first loop
if(!i)
GetSurfacePrototype(&proto,rdPtr->depth,ST_MEMORYWITHDC,SD_DIB);
//Valid image? Load
if(edPtr->images[i])
{
cSurface is, *tmp = new cSurface;
GetImageInfos(rhPtr->rhIdAppli,edPtr->images[i],&imgInfo);
rdPtr->surf->push_back(new SImage(tmp,true,imgInfo.imgXSpot,imgInfo.imgYSpot));
LockImageSurface(rhPtr->rhIdAppli,edPtr->images[i],is);
if(is.GetWidth())
{
if(!i)
{
rdPtr->targetId = 0;
TargetImg = tmp;
rdPtr->lastId = rdPtr->targetId;
rdPtr->targetValid = true;
if(edPtr->loadFirst)
{
rdPtr->currentId = rdPtr->targetId;
CurrentImg = TargetImg;
}
}
tmp->Create(is.GetWidth(),is.GetHeight(),proto);
tmp->SetTransparentColor(is.GetTransparentColor());
is.Blit(*tmp,0,0,BMODE_OPAQUE,BOP_COPY,0,BLTF_COPYALPHA);
}
else if(!i&&edPtr->loadFirst)
{
rdPtr->targetId = rdPtr->currentId = 0;
TargetImg = CurrentImg = 0;
rdPtr->lastId = rdPtr->targetId;
}
UnlockImageSurface(is);
}
//Add prototype if there's more than one empty image
else if(i&&edPtr->imageCount>1)
{
rdPtr->surf->push_back(new SImage(new cSurface));
}
}
}
//Single image
else
{
//First image is set
if(edPtr->images[0])
{
cSurface is, *tmp = new cSurface;
GetImageInfos(rhPtr->rhIdAppli,edPtr->images[0],&imgInfo);
rdPtr->surf->push_back(new SImage(tmp,true,imgInfo.imgXSpot,imgInfo.imgYSpot));
LockImageSurface(rhPtr->rhIdAppli,edPtr->images[0],is);
if(is.GetWidth())
{
GetSurfacePrototype(&proto,rdPtr->depth,ST_MEMORYWITHDC,SD_DIB);
rdPtr->targetId = rdPtr->currentId = rdPtr->lastId = 0;
TargetImg = CurrentImg = tmp;
tmp->Create(is.GetWidth(),is.GetHeight(),proto);
tmp->SetTransparentColor(is.GetTransparentColor());
is.Blit(*tmp);
}
UnlockImageSurface(is);
rdPtr->targetValid = true;
}
//Create empty image if wanted
else
{
cSurface *tmp = new cSurface;
rdPtr->surf->push_back(new SImage(tmp));
//Empty image with size
if(edPtr->loadFirst)
{
GetSurfacePrototype(&proto,rdPtr->depth,ST_MEMORYWITHDC,SD_DIB);
tmp->Create(edPtr->width,edPtr->height,proto);
tmp->Fill(BLACK);
}
rdPtr->targetId = rdPtr->currentId = rdPtr->lastId = 0;
TargetImg = CurrentImg = tmp;
rdPtr->targetValid = TargetImg->IsValid();
}
}
//Initialize information
if(rdPtr->current)
{
rdPtr->rHo.hoImgWidth = rdPtr->current->GetWidth();
rdPtr->rHo.hoImgHeight = rdPtr->current->GetHeight();
rdPtr->rHo.hoImgXSpot = ImageS(rdPtr->currentId)->hotX;
rdPtr->rHo.hoImgYSpot = ImageS(rdPtr->currentId)->hotY;
}
// No errors
return 0;
}
