1dot13/source
1
0
Fork 0
mirror of https://github.com/1dot13/source.git synced 2026-07-22 13:40:22 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
8b1c4effa0b958ec48915c88a9285c687d946ea0
source/Standard Gaming Platform/vobject.cpp
T
Marco Antonio Jaguaribe CostaandAsdow 8b1c4effa0 nuke all the #if 0's 
scripted commit:

find . -not -path '*/.*' -and -not -path '*/ext*' -type d -exec coan source -R -E {} ';'

https://coan2.sourceforge.net/coan_man_1.html
2023-01-19 00:13:08 +02:00

1849 lines
52 KiB
C++
Raw Blame History

#include "DirectDraw Calls.h"
#include <stdio.h>
#include "debug.h"
#include "video.h"
#include "himage.h"
#include "vobject.h"
#include "wcheck.h"
#include "vobject_blitters.h"
#include "sgp.h"
#include <unordered_map>
// ******************************************************************************
//
// Video Object SGP Module
//
// Video Objects are used to contain any imagery which requires blitting. The data
// is contained within a Direct Draw surface. Palette information is in both
// a Direct Draw Palette and a 16BPP palette structure for 8->16 BPP Blits.
// Blitting is done via Direct Draw as well as custum blitters. Regions are
// used to define local coordinates within the surface
//
// Second Revision: Dec 10, 1996, Andrew Emmons
//
// *******************************************************************************
// *******************************************************************************
// Defines
// *******************************************************************************
// This define is sent to CreateList SGP function. It dynamically re-sizes if
// the list gets larger
#define DEFAULT_VIDEO_OBJECT_LIST_SIZE 10
#define COMPRESS_TRANSPARENT 0x80
#define COMPRESS_RUN_MASK 0x7F
// *******************************************************************************
// External Functions and variables
// *******************************************************************************
// *******************************************************************************
// LOCAL functions
// *******************************************************************************
// *******************************************************************************
// LOCAL global variables
// *******************************************************************************
HLIST ghVideoObjects = NULL;
BOOLEAN gfVideoObjectsInit=FALSE;
#ifndef SGP_VIDEO_DEBUGGING
#define USE_HASHMAP_FOR_VOBJECTS
#endif
#ifdef USE_HASHMAP_FOR_VOBJECTS
typedef struct VOBJECT_NODE
{
HVOBJECT hVObject;
UINT32 uiIndex;
#ifdef SGP_VIDEO_DEBUGGING
STR8 pName;
STR8 pCode;
#endif
} VOBJECT_NODE, *VOBJECT_NODE_PTR;
typedef std::unordered_map<UINT32, VOBJECT_NODE_PTR> VOBJECT_MAP;
static VOBJECT_MAP gpVObjectMap;
#else
typedef struct VOBJECT_NODE
{
HVOBJECT hVObject;
UINT32 uiIndex;
struct VOBJECT_NODE *next, *prev;
#ifdef SGP_VIDEO_DEBUGGING
STR8 pName;
STR8 pCode;
#endif
}VOBJECT_NODE;
VOBJECT_NODE *gpVObjectHead = NULL;
VOBJECT_NODE *gpVObjectTail = NULL;
#endif
UINT32 guiVObjectIndex = 1;
UINT32 guiVObjectSize = 0;
UINT32 guiVObjectTotalAdded = 0;
#ifdef _DEBUG
enum
{
DEBUGSTR_NONE,
DEBUGSTR_SETVIDEOOBJECTTRANSPARENCY,
DEBUGSTR_BLTVIDEOOBJECTFROMINDEX,
DEBUGSTR_SETOBJECTHANDLESHADE,
DEBUGSTR_GETVIDEOOBJECTETRLESUBREGIONPROPERTIES,
DEBUGSTR_GETVIDEOOBJECTETRLEPROPERTIESFROMINDEX,
DEBUGSTR_SETVIDEOOBJECTPALETTE8BPP,
DEBUGSTR_GETVIDEOOBJECTPALETTE16BPP,
DEBUGSTR_COPYVIDEOOBJECTPALETTE16BPP,
DEBUGSTR_BLTVIDEOOBJECTOUTLINEFROMINDEX,
DEBUGSTR_BLTVIDEOOBJECTOUTLINESHADOWFROMINDEX,
DEBUGSTR_DELETEVIDEOOBJECTFROMINDEX
};
UINT8 gubVODebugCode = 0;
void CheckValidVObjectIndex( UINT32 uiIndex );
#endif
// **************************************************************
//
// Video Object Manager functions
//
// **************************************************************
int filter(unsigned int code, struct _EXCEPTION_POINTERS *ep)
{
puts("in filter.");
if (code == EXCEPTION_ACCESS_VIOLATION) {
puts("caught AV as expected.");
return EXCEPTION_EXECUTE_HANDLER;
}
else
{
puts("didn't catch AV, unexpected.");
return EXCEPTION_CONTINUE_SEARCH;
};
}
BOOLEAN InitializeVideoObjectManager( )
{
//Shouldn't be calling this if the video object manager already exists.
//Call shutdown first...
#ifdef USE_HASHMAP_FOR_VOBJECTS
Assert( gpVObjectMap.empty() );
RegisterDebugTopic(TOPIC_VIDEOOBJECT, "Video Object Manager");
#else
Assert( !gpVObjectHead );
Assert( !gpVObjectTail );
RegisterDebugTopic(TOPIC_VIDEOOBJECT, "Video Object Manager");
gpVObjectHead = gpVObjectTail = NULL;
#endif
gfVideoObjectsInit=TRUE;
return TRUE ;
}
BOOLEAN ShutdownVideoObjectManager( )
{
VOBJECT_NODE *curr;
#ifdef USE_HASHMAP_FOR_VOBJECTS
for(VOBJECT_MAP::iterator itr=gpVObjectMap.begin(); itr != gpVObjectMap.end(); ++itr )
{
curr = (*itr).second;
DeleteVideoObject( curr->hVObject );
#ifdef SGP_VIDEO_DEBUGGING
if( curr->pName )
MemFree( curr->pName );
if( curr->pCode )
MemFree( curr->pCode );
#endif
MemFree( curr );
}
gpVObjectMap.clear();
#else
while( gpVObjectHead )
{
curr = gpVObjectHead;
gpVObjectHead = gpVObjectHead->next;
DeleteVideoObject( curr->hVObject );
#ifdef SGP_VIDEO_DEBUGGING
if( curr->pName )
MemFree( curr->pName );
if( curr->pCode )
MemFree( curr->pCode );
#endif
MemFree( curr );
}
gpVObjectHead = NULL;
gpVObjectTail = NULL;
#endif
guiVObjectIndex = 1;
guiVObjectSize = 0;
guiVObjectTotalAdded = 0;
UnRegisterDebugTopic(TOPIC_VIDEOOBJECT, "Video Objects");
gfVideoObjectsInit=FALSE;
return TRUE;
}
UINT32 CountVideoObjectNodes()
{
#ifdef USE_HASHMAP_FOR_VOBJECTS
return gpVObjectMap.size();
#else
VOBJECT_NODE *curr;
UINT32 i = 0;
curr = gpVObjectHead;
while( curr )
{
i++;
curr = curr->next;
}
return i;
#endif
}
BOOLEAN AddStandardVideoObject( VOBJECT_DESC *pVObjectDesc, UINT32 *puiIndex )
{
HVOBJECT hVObject;
// Assertions
Assert( puiIndex );
Assert( pVObjectDesc );
// Create video object
hVObject = CreateVideoObject( pVObjectDesc );
if( !hVObject )
{
// Video Object will set error condition.
return FALSE ;
}
// Set transparency to default
SetVideoObjectTransparencyColor( hVObject, FROMRGB( 0, 0, 0 ) );
#ifdef USE_HASHMAP_FOR_VOBJECTS
{
VOBJECT_NODE_PTR curr = (VOBJECT_NODE*)MemAlloc( sizeof( VOBJECT_NODE ) );
memset(curr, 0, sizeof(VOBJECT_NODE));
curr->hVObject = hVObject;
curr->uiIndex = guiVObjectIndex++;
*puiIndex = curr->uiIndex;
gpVObjectMap[curr->uiIndex] = curr;
}
#else
// Set into video object list
if( gpVObjectHead )
{ //Add node after tail
gpVObjectTail->next = (VOBJECT_NODE*)MemAlloc( sizeof( VOBJECT_NODE ) );
Assert( gpVObjectTail->next ); //out of memory?
gpVObjectTail->next->prev = gpVObjectTail;
gpVObjectTail->next->next = NULL;
gpVObjectTail = gpVObjectTail->next;
}
else
{ //new list
gpVObjectHead = (VOBJECT_NODE*)MemAlloc( sizeof( VOBJECT_NODE ) );
Assert( gpVObjectHead ); //out of memory?
gpVObjectHead->prev = gpVObjectHead->next = NULL;
gpVObjectTail = gpVObjectHead;
}
#ifdef SGP_VIDEO_DEBUGGING
gpVObjectTail->pName = NULL;
gpVObjectTail->pCode = NULL;
#endif
//Set the hVObject into the node.
gpVObjectTail->hVObject = hVObject;
gpVObjectTail->uiIndex = guiVObjectIndex+=2;
*puiIndex = gpVObjectTail->uiIndex;
#endif
Assert( guiVObjectIndex < 0xfffffff0 ); //unlikely that we will ever use 2 billion vobjects!
//We would have to create about 70 vobjects per second for 1 year straight to achieve this...
guiVObjectSize++;
guiVObjectTotalAdded++;
#ifdef JA2TESTVERSION
if( CountVideoObjectNodes() != guiVObjectSize )
{
guiVObjectSize = guiVObjectSize;
}
#endif
return TRUE ;
}
BOOLEAN SetVideoObjectTransparency( UINT32 uiIndex, COLORVAL TransColor )
{
HVOBJECT hVObject;
// Get video object
#ifdef _DEBUG
gubVODebugCode = DEBUGSTR_SETVIDEOOBJECTTRANSPARENCY;
#endif
CHECKF( GetVideoObject( &hVObject, uiIndex ) );
// Set transparency
SetVideoObjectTransparencyColor( hVObject, TransColor );
return( TRUE );
}
BOOLEAN GetVideoObject( HVOBJECT *hVObject, UINT32 uiIndex )
{
#ifdef _DEBUG
CheckValidVObjectIndex( uiIndex );
#endif
#ifdef USE_HASHMAP_FOR_VOBJECTS
VOBJECT_MAP::iterator itr = gpVObjectMap.find(uiIndex);
if (itr != gpVObjectMap.end())
{
*hVObject = (*itr).second->hVObject;
return TRUE;
}
#else
VOBJECT_NODE *curr;
curr = gpVObjectHead;
while( curr )
{
if( curr->uiIndex == uiIndex )
{
*hVObject = curr->hVObject;
return TRUE;
}
curr = curr->next;
}
#endif
*hVObject = NULL;
return FALSE;
}
BOOLEAN BltVideoObjectFromIndex(UINT32 uiDestVSurface, UINT32 uiSrcVObject, UINT16 usRegionIndex, INT32 iDestX, INT32 iDestY, UINT32 fBltFlags, blt_fx *pBltFx )
{
UINT16 *pBuffer;
UINT32 uiPitch;
HVOBJECT hSrcVObject;
// Lock video surface
pBuffer = (UINT16*)LockVideoSurface( uiDestVSurface, &uiPitch );
if ( pBuffer == NULL )
{
return( FALSE );
}
// Get video object
#ifdef _DEBUG
gubVODebugCode = DEBUGSTR_BLTVIDEOOBJECTFROMINDEX;
#endif
if( !GetVideoObject( &hSrcVObject, uiSrcVObject ) )
{
UnLockVideoSurface( uiDestVSurface );
return FALSE;
}
// Now we have the video object and surface, call the VO blitter function
if ( !BltVideoObjectToBuffer( pBuffer, uiPitch, hSrcVObject, usRegionIndex, iDestX, iDestY, fBltFlags, pBltFx ) )
{
UnLockVideoSurface( uiDestVSurface );
// VO Blitter will set debug messages for error conditions
return FALSE;
}
UnLockVideoSurface( uiDestVSurface );
return( TRUE );
}
BOOLEAN DeleteVideoObjectFromIndex( UINT32 uiVObject )
{
VOBJECT_NODE *curr;
#ifdef _DEBUG
gubVODebugCode = DEBUGSTR_DELETEVIDEOOBJECTFROMINDEX;
CheckValidVObjectIndex( uiVObject );
#endif
#ifdef USE_HASHMAP_FOR_VOBJECTS
VOBJECT_MAP::iterator itr = gpVObjectMap.find(uiVObject);
if (itr != gpVObjectMap.end())
{
curr = (*itr).second;
DeleteVideoObject( curr->hVObject );
//The node is now detached. Now deallocate it.
#ifdef SGP_VIDEO_DEBUGGING
if( curr->pName )
MemFree( curr->pName );
if( curr->pCode )
MemFree( curr->pCode );
#endif
MemFree( curr );
curr = NULL;
guiVObjectSize--;
gpVObjectMap.erase(itr);
#ifdef JA2TESTVERSION
if( CountVideoObjectNodes() != guiVObjectSize )
{
guiVObjectSize = guiVObjectSize;
DebugBreakpoint();
}
#endif
return TRUE;
}
#else
curr = gpVObjectHead;
while( curr )
{
if( curr->uiIndex == uiVObject )
{ //Found the node, so detach it and delete it.
//Deallocate the memory for the video object
DeleteVideoObject( curr->hVObject );
if( curr == gpVObjectHead )
{ //Advance the head, because we are going to remove the head node.
gpVObjectHead = gpVObjectHead->next;
}
if( curr == gpVObjectTail )
{ //Back up the tail, because we are going to remove the tail node.
gpVObjectTail = gpVObjectTail->prev;
}
//Detach the node from the vobject list
if( curr->next )
{ //Make the prev node point to the next
curr->next->prev = curr->prev;
}
if( curr->prev )
{ //Make the next node point to the prev
curr->prev->next = curr->next;
}
//The node is now detached. Now deallocate it.
#ifdef SGP_VIDEO_DEBUGGING
if( curr->pName )
MemFree( curr->pName );
if( curr->pCode )
MemFree( curr->pCode );
#endif
MemFree( curr );
curr = NULL;
guiVObjectSize--;
#ifdef JA2TESTVERSION
if( CountVideoObjectNodes() != guiVObjectSize )
{
guiVObjectSize = guiVObjectSize;
}
#endif
return TRUE;
}
curr = curr->next;
}
#endif
return FALSE;
}
// Given an index to the dest and src vobject contained in ghVideoObjects
// Based on flags, blit accordingly
// There are two types, a BltFast and a Blt. BltFast is 10% faster, uses no
// clipping lists
BOOLEAN BltVideoObject( UINT32 uiDestVSurface,
HVOBJECT hSrcVObject,
UINT16 usRegionIndex,
INT32 iDestX,
INT32 iDestY,
UINT32 fBltFlags,
blt_fx *pBltFx )
{
UINT16 *pBuffer;
UINT32 uiPitch;
// Lock video surface
pBuffer = (UINT16*)LockVideoSurface( uiDestVSurface, &uiPitch );
if ( pBuffer == NULL )
{
return( FALSE );
}
// Now we have the video object and surface, call the VO blitter function
if ( !BltVideoObjectToBuffer( pBuffer, uiPitch, hSrcVObject, usRegionIndex, iDestX, iDestY, fBltFlags, pBltFx ) )
{
UnLockVideoSurface( uiDestVSurface );
// VO Blitter will set debug messages for error conditions
return( FALSE );
}
UnLockVideoSurface( uiDestVSurface );
return( TRUE );
}
BOOLEAN BltVideoObject(UINT32 uiDestVSurface, HVOBJECT hSrcVObject, UINT16 usRegionIndex, SGPRectangle Region, UINT32 fBltFlags, blt_fx* pBltFx)
{
return BltVideoObject(uiDestVSurface, hSrcVObject, usRegionIndex, Region.x, Region.y, fBltFlags, pBltFx);
}
// *******************************************************************************
// Video Object Manipulation Functions
// *******************************************************************************
HVOBJECT CreateVideoObject( VOBJECT_DESC *VObjectDesc )
{
HVOBJECT hVObject;
HIMAGE hImage;
ETRLEData TempETRLEData;
// UINT32 count;
// Allocate memory for video object data and initialize
hVObject = (HVOBJECT) MemAlloc( sizeof( SGPVObject ) );
CHECKF( hVObject != NULL );
memset( hVObject, 0, sizeof( SGPVObject ) );
// default of all members of the vobject is 0
// Check creation options
// do
// {
if ( VObjectDesc->fCreateFlags & VOBJECT_CREATE_FROMFILE || VObjectDesc->fCreateFlags & VOBJECT_CREATE_FROMHIMAGE )
{
if ( VObjectDesc->fCreateFlags & VOBJECT_CREATE_FROMFILE )
{
ImageFileType::TestOrder order = ImageFileType::JPC_FALLBACK;
if(VObjectDesc->fCreateFlags & VOBJECT_CREATE_FROMJPC) {
order = ImageFileType::JPC;
} else if(VObjectDesc->fCreateFlags & VOBJECT_CREATE_FROMJPC_FALLBACK) {
order = ImageFileType::JPC_FALLBACK;
} else if(VObjectDesc->fCreateFlags & VOBJECT_CREATE_FROMPNG) {
order = ImageFileType::PNG_FALLBACK;
} else if(VObjectDesc->fCreateFlags & VOBJECT_CREATE_FROMPNG_FALLBACK) {
order = ImageFileType::PNG_FALLBACK;
}
// Create himage object from file
hImage = CreateImage( VObjectDesc->ImageFile, IMAGE_ALLIMAGEDATA, order );
if ( hImage == NULL )
{
MemFree( hVObject );
DbgMessage( TOPIC_VIDEOOBJECT, DBG_LEVEL_2, "Invalid Image Filename given" );
return( NULL );
}
}
else
{ // create video object from provided hImage
hImage = VObjectDesc->hImage;
if ( hImage == NULL )
{
MemFree( hVObject );
DbgMessage( TOPIC_VIDEOOBJECT, DBG_LEVEL_2, "Invalid hImage pointer given" );
return( NULL );
}
}
if(hImage->ubBitDepth == 32)
{
SGP_THROW_IFFALSE(hImage->usNumberOfObjects > 0, L"bad himage");
// create one 16bpp object (that contains 32bpp data)
hVObject->p16BPPObject = (SixteenBPPObjectInfo*)MemAlloc(sizeof(SixteenBPPObjectInfo));
if(!hVObject->p16BPPObject)
{
SGP_THROW(L"bad alloc");
}
memset(hVObject->p16BPPObject, 0, sizeof(SixteenBPPObjectInfo));
int SIZE = hImage->pETRLEObject[0].usHeight * hImage->pETRLEObject[0].usWidth * sizeof(UINT32);
hVObject->p16BPPObject->p16BPPData = (UINT16*)MemAlloc(SIZE); // UINT32*
if(!hVObject->p16BPPObject->p16BPPData)
{
MemFree(hVObject->p16BPPObject);
SGP_THROW(L"bad alloc");
}
memcpy(hVObject->p16BPPObject->p16BPPData, hImage->p32BPPData, SIZE);
hVObject->p16BPPObject->sOffsetX = hImage->pETRLEObject[0].sOffsetX;
hVObject->p16BPPObject->sOffsetY = hImage->pETRLEObject[0].sOffsetY;
hVObject->p16BPPObject->ubShadeLevel = 0;
hVObject->p16BPPObject->usHeight = hImage->pETRLEObject[0].usHeight;
hVObject->p16BPPObject->usWidth = hImage->pETRLEObject[0].usWidth;
hVObject->p16BPPObject->usRegionIndex = 0;
hVObject->usNumberOf16BPPObjects = 1;
hVObject->ubBitDepth = hImage->ubBitDepth;
if ( VObjectDesc->fCreateFlags & VOBJECT_CREATE_FROMFILE )
{
DestroyImage( hImage );
}
return hVObject;
}
else if(hImage->ubBitDepth == 16)
{
SGP_THROW_IFFALSE(hImage->usNumberOfObjects > 0, L"bad himage");
// create one 16bpp object (that contains 32bpp data)
hVObject->p16BPPObject = (SixteenBPPObjectInfo*)MemAlloc(sizeof(SixteenBPPObjectInfo));
if(!hVObject->p16BPPObject)
{
SGP_THROW(L"bad alloc");
}
memset(hVObject->p16BPPObject, 0, sizeof(SixteenBPPObjectInfo));
int SIZE = hImage->pETRLEObject[0].usHeight * hImage->pETRLEObject[0].usWidth * sizeof(UINT16);
hVObject->p16BPPObject->p16BPPData = (UINT16*)MemAlloc(SIZE);
if(!hVObject->p16BPPObject->p16BPPData)
{
MemFree(hVObject->p16BPPObject);
SGP_THROW(L"bad alloc");
}
memcpy(hVObject->p16BPPObject->p16BPPData, hImage->p16BPPData, SIZE);
hVObject->p16BPPObject->sOffsetX = hImage->pETRLEObject[0].sOffsetX;
hVObject->p16BPPObject->sOffsetY = hImage->pETRLEObject[0].sOffsetY;
hVObject->p16BPPObject->ubShadeLevel = 0;
hVObject->p16BPPObject->usHeight = hImage->pETRLEObject[0].usHeight;
hVObject->p16BPPObject->usWidth = hImage->pETRLEObject[0].usWidth;
hVObject->p16BPPObject->usRegionIndex = 0;
hVObject->usNumberOf16BPPObjects = 1;
hVObject->ubBitDepth = hImage->ubBitDepth;
if ( VObjectDesc->fCreateFlags & VOBJECT_CREATE_FROMFILE )
{
DestroyImage( hImage );
}
return hVObject;
}
// Check if returned himage is TRLE compressed - return error if not
if ( ! (hImage->fFlags & IMAGE_TRLECOMPRESSED ) )
{
MemFree( hVObject );
DbgMessage( TOPIC_VIDEOOBJECT, DBG_LEVEL_2, "Invalid Image format given." );
DestroyImage( hImage );
return( NULL );
}
// Set values from himage
hVObject->ubBitDepth = hImage->ubBitDepth;
// Get TRLE data
CHECKF( GetETRLEImageData( hImage, &TempETRLEData ) );
// Set values
hVObject->usNumberOfObjects = TempETRLEData.usNumberOfObjects;
hVObject->pETRLEObject = TempETRLEData.pETRLEObject;
hVObject->pPixData = TempETRLEData.pPixData;
hVObject->uiSizePixData = TempETRLEData.uiSizePixData;
// Set palette from himage
if ( hImage->ubBitDepth == 8 )
{
hVObject->pShade8=ubColorTables[DEFAULT_SHADE_LEVEL];
hVObject->pGlow8=ubColorTables[0];
SetVideoObjectPalette( hVObject, hImage->pPalette );
}
if ( VObjectDesc->fCreateFlags & VOBJECT_CREATE_FROMFILE )
{
// Delete himage object
DestroyImage( hImage );
}
// break;
}
else
{
MemFree( hVObject );
DbgMessage( TOPIC_VIDEOOBJECT, DBG_LEVEL_2, "Invalid VObject creation flags given." );
return( NULL );
}
// If here, no special options given, use structure given in paraneters
// TO DO:
// }
// while( FALSE );
// All is well
// DbgMessage( TOPIC_VIDEOOBJECT, DBG_LEVEL_3, String("Success in Creating Video Object" ) );
return( hVObject );
}
// Palette setting is expensive, need to set both DDPalette and create 16BPP palette
BOOLEAN SetVideoObjectPalette( HVOBJECT hVObject, SGPPaletteEntry *pSrcPalette )
{
Assert( hVObject != NULL );
Assert( pSrcPalette != NULL );
// Create palette object if not already done so
if ( hVObject->pPaletteEntry == NULL )
{
// Create palette
hVObject->pPaletteEntry = (SGPPaletteEntry *) MemAlloc( sizeof( SGPPaletteEntry ) * 256 );
CHECKF( hVObject->pPaletteEntry != NULL );
// Copy src into palette
memcpy( hVObject->pPaletteEntry, pSrcPalette, sizeof( SGPPaletteEntry ) * 256 );
}
else
{
// Just Change entries
memcpy( hVObject->pPaletteEntry, pSrcPalette, sizeof( SGPPaletteEntry ) * 256 );
}
// Delete 16BPP Palette if one exists
if ( hVObject->p16BPPPalette != NULL )
{
MemFree( hVObject->p16BPPPalette );
hVObject->p16BPPPalette = NULL;
}
// Create 16BPP Palette
hVObject->p16BPPPalette = Create16BPPPalette( pSrcPalette );
hVObject->pShadeCurrent = hVObject->p16BPPPalette;
// DbgMessage(TOPIC_VIDEOOBJECT, DBG_LEVEL_3, String("Video Object Palette change successfull" ));
return( TRUE );
}
// Transparency needs to take RGB value and find best fit and place it into DD Surface
// colorkey value.
BOOLEAN SetVideoObjectTransparencyColor( HVOBJECT hVObject, COLORVAL TransColor )
{
// Assertions
Assert( hVObject != NULL );
//Set trans color into video object
hVObject->TransparentColor = TransColor;
return( TRUE );
}
// Deletes all palettes, surfaces and region data
BOOLEAN DeleteVideoObject( HVOBJECT hVObject )
{
UINT16 usLoop;
// Assertions
CHECKF( hVObject != NULL );
DestroyObjectPaletteTables(hVObject);
// Release palette
if ( hVObject->pPaletteEntry != NULL )
{
MemFree( hVObject->pPaletteEntry );
// hVObject->pPaletteEntry = NULL;
}
if ( hVObject->pPixData != NULL )
{
MemFree( hVObject->pPixData );
// hVObject->pPixData = NULL;
}
if ( hVObject->pETRLEObject != NULL )
{
MemFree( hVObject->pETRLEObject );
// hVObject->pETRLEObject = NULL;
}
if ( hVObject->ppZStripInfo != NULL )
{
for (usLoop = 0; usLoop < hVObject->usNumberOfObjects; usLoop++)
{
if (hVObject->ppZStripInfo[usLoop] != NULL)
{
MemFree( hVObject->ppZStripInfo[usLoop]->pbZChange );
MemFree( hVObject->ppZStripInfo[usLoop] );
}
}
MemFree( hVObject->ppZStripInfo );
// hVObject->ppZStripInfo = NULL;
}
if ( hVObject->usNumberOf16BPPObjects > 0)
{
for( usLoop = 0; usLoop < hVObject->usNumberOf16BPPObjects; usLoop++)
{
MemFree( hVObject->p16BPPObject[usLoop].p16BPPData );
}
MemFree( hVObject->p16BPPObject );
}
// Release object
MemFree( hVObject );
return( TRUE );
}
/**********************************************************************************************
CreateObjectPaletteTables
Creates the shading tables for 8-bit brushes. One highlight table is created, based on
the object-type, 3 brightening tables, 1 normal, and 11 darkening tables. The entries are
created iteratively, rather than in a loop to allow hand-tweaking of the values. If you
change the HVOBJECT_SHADE_TABLES symbol, remember to add/delete entries here, it won't
adjust automagically.
**********************************************************************************************/
UINT16 CreateObjectPaletteTables(HVOBJECT pObj, UINT32 uiType)
{
UINT32 count;
// this creates the highlight table. Specify the glow-type when creating the tables
// through uiType, symbols are from VOBJECT.H
for( count = 0; count < 16; count++ )
{
if ( (count == 4) && (pObj->p16BPPPalette == pObj->pShades[ count ]) )
pObj->pShades[ count ] = NULL;
else if ( pObj->pShades[ count ] != NULL )
{
MemFree( pObj->pShades[ count ] );
pObj->pShades[ count ] = NULL;
}
}
switch(uiType)
{
case HVOBJECT_GLOW_GREEN: // green glow
pObj->pShades[0]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 0, 255, 0, TRUE);
break;
case HVOBJECT_GLOW_BLUE: // blue glow
pObj->pShades[0]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 0, 0, 255, TRUE);
break;
case HVOBJECT_GLOW_YELLOW: // yellow glow
pObj->pShades[0]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 255, 255, 0, TRUE);
break;
case HVOBJECT_GLOW_RED: // red glow
pObj->pShades[0]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 255, 0, 0, TRUE);
break;
}
// these are the brightening tables, 115%-150% brighter than original
pObj->pShades[1]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 293, 293, 293, FALSE);
pObj->pShades[2]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 281, 281, 281, FALSE);
pObj->pShades[3]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 268, 268, 268, FALSE);
// palette 4 is the non-modified palette.
// if the standard one has already been made, we'll use it
if(pObj->p16BPPPalette!=NULL)
pObj->pShades[4]=pObj->p16BPPPalette;
else
{
// or create our own, and assign it to the standard one
pObj->pShades[4]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 255, 255, 255, FALSE);
pObj->p16BPPPalette=pObj->pShades[4];
}
// the rest are darkening tables, right down to all-black.
pObj->pShades[5]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 195, 195, 195, FALSE);
pObj->pShades[6]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 165, 165, 165, FALSE);
pObj->pShades[7]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 135, 135, 135, FALSE);
pObj->pShades[8]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 105, 105, 105, FALSE);
pObj->pShades[9]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 75, 75, 75, FALSE);
pObj->pShades[10]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 45, 45, 45, FALSE);
pObj->pShades[11]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 36, 36, 36, FALSE);
pObj->pShades[12]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 27, 27, 27, FALSE);
pObj->pShades[13]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 18, 18, 18, FALSE);
pObj->pShades[14]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 9, 9, 9, FALSE);
pObj->pShades[15]=Create16BPPPaletteShaded( pObj->pPaletteEntry, 0, 0, 0, FALSE);
// Set current shade table to neutral color
pObj->pShadeCurrent=pObj->pShades[4];
// check to make sure every table got a palette
for(count=0; (count < HVOBJECT_SHADE_TABLES) && (pObj->pShades[count]!=NULL); count++);
// return the result of the check
return(count==HVOBJECT_SHADE_TABLES);
}
// *******************************************************************
//
// Blitting Functions
//
// *******************************************************************
// High level blit function encapsolates ALL effects and BPP
BOOLEAN BltVideoObjectToBuffer( UINT16 *pBuffer, UINT32 uiDestPitchBYTES, HVOBJECT hSrcVObject, UINT16 usIndex, INT32 iDestX, INT32 iDestY, INT32 fBltFlags, blt_fx *pBltFx )
{
// Sometimes an exception is thrown in that method.
//BF __try
{
// Assertions
//Assert( pBuffer != NULL );
SGP_THROW_IFFALSE( pBuffer != NULL, L"No Destination Buffer" );
if ( hSrcVObject == NULL )
{
//int breakpoint=0;
}
//Assert( hSrcVObject != NULL );
SGP_THROW_IFFALSE( hSrcVObject != NULL, L"No Source Object" )
SixteenBPPObjectInfo *image = NULL;
// Check For Flags and bit depths
switch( hSrcVObject->ubBitDepth )
{
case 32:
SGP_THROW_IFFALSE(usIndex < hSrcVObject->usNumberOf16BPPObjects, L"index larger that number images");
image = &hSrcVObject->p16BPPObject[usIndex];
Blt32BPPTo16BPPTrans( pBuffer, uiDestPitchBYTES,
(UINT32*)image->p16BPPData, image->usWidth * sizeof(UINT32),
iDestX, iDestY,
0, 0, image->usWidth, image->usHeight);
break;
case 16:
SGP_THROW_IFFALSE(usIndex < hSrcVObject->usNumberOf16BPPObjects, L"index larger that number images");
image = &hSrcVObject->p16BPPObject[usIndex];
if ( fBltFlags & VO_BLT_SRCTRANSPARENCY )
{
Blt16BPPTo16BPPTrans( pBuffer, uiDestPitchBYTES,
image->p16BPPData, image->usWidth * sizeof(UINT16),
iDestX, iDestY,
0, 0, image->usWidth, image->usHeight, 0x1F ); // 0x1f = 5 bits of blue
}
else
{
Blt16BPPTo16BPP( pBuffer, uiDestPitchBYTES,
image->p16BPPData, image->usWidth * sizeof(UINT16),
iDestX, iDestY,
0, 0, image->usWidth, image->usHeight );
}
break;
case 8:
SGP_THROW_IFFALSE( hSrcVObject->usNumberOfObjects > usIndex, L"Video object index is larger than the number of subimages");
// Switch based on flags given
do
{
if(gbPixelDepth==16)
{
if ( fBltFlags & VO_BLT_SRCTRANSPARENCY )
{
if(BltIsClipped(hSrcVObject, iDestX, iDestY, usIndex, &ClippingRect))
Blt8BPPDataTo16BPPBufferTransparentClip( pBuffer, uiDestPitchBYTES, hSrcVObject, iDestX, iDestY, usIndex, &ClippingRect);
else
Blt8BPPDataTo16BPPBufferTransparent( pBuffer, uiDestPitchBYTES, hSrcVObject, iDestX, iDestY, usIndex );
break;
}
else if ( fBltFlags & VO_BLT_SHADOW )
{
if(BltIsClipped(hSrcVObject, iDestX, iDestY, usIndex, &ClippingRect))
Blt8BPPDataTo16BPPBufferShadowClip( pBuffer, uiDestPitchBYTES, hSrcVObject, iDestX, iDestY, usIndex, &ClippingRect);
else
Blt8BPPDataTo16BPPBufferShadow( pBuffer, uiDestPitchBYTES, hSrcVObject, iDestX, iDestY, usIndex );
break;
}
}
else if(gbPixelDepth==8)
{
if ( fBltFlags & VO_BLT_SRCTRANSPARENCY )
{
if(BltIsClipped(hSrcVObject, iDestX, iDestY, usIndex, &ClippingRect))
Blt8BPPDataTo8BPPBufferTransparentClip( pBuffer, uiDestPitchBYTES, hSrcVObject, iDestX, iDestY, usIndex, &ClippingRect);
else
Blt8BPPDataTo8BPPBufferTransparent( pBuffer, uiDestPitchBYTES, hSrcVObject, iDestX, iDestY, usIndex );
break;
}
else if ( fBltFlags & VO_BLT_SHADOW )
{
if(BltIsClipped(hSrcVObject, iDestX, iDestY, usIndex, &ClippingRect))
Blt8BPPDataTo8BPPBufferShadowClip( pBuffer, uiDestPitchBYTES, hSrcVObject, iDestX, iDestY, usIndex, &ClippingRect);
else
Blt8BPPDataTo8BPPBufferShadow( pBuffer, uiDestPitchBYTES, hSrcVObject, iDestX, iDestY, usIndex );
break;
}
}
// Use default blitter here
//Blt8BPPDataTo16BPPBuffer( hDestVObject, hSrcVObject, (UINT16)iDestX, (UINT16)iDestY, (SGPRect*)&SrcRect );
} while( FALSE );
break;
}
return( TRUE );
}
//BF
//__except(filter(GetExceptionCode(), GetExceptionInformation()))
//{
// return ( TRUE );
//}
}
BOOLEAN PixelateVideoObjectRect( UINT32 uiDestVSurface, INT32 X1, INT32 Y1, INT32 X2, INT32 Y2)
{
UINT16 *pBuffer;
UINT32 uiPitch;
SGPRect area;
UINT8 uiPattern[8][8]={ {0,1,0,1,0,1,0,1},
{1,0,1,0,1,0,1,0},
{0,1,0,1,0,1,0,1},
{1,0,1,0,1,0,1,0},
{0,1,0,1,0,1,0,1},
{1,0,1,0,1,0,1,0},
{0,1,0,1,0,1,0,1},
{1,0,1,0,1,0,1,0}};
// Lock video surface
pBuffer = (UINT16*)LockVideoSurface( uiDestVSurface, &uiPitch );
if ( pBuffer == NULL )
{
return( FALSE );
}
area.iTop=Y1;
area.iBottom=Y2;
area.iLeft=X1;
area.iRight=X2;
// Now we have the video object and surface, call the shadow function
if(!Blt16BPPBufferPixelateRect(pBuffer, uiPitch, &area, uiPattern))
{
UnLockVideoSurface( uiDestVSurface );
// Blit has failed if false returned
return( FALSE );
}
// Mark as dirty if it's the backbuffer
//if ( uiDestVSurface == BACKBUFFER )
//{
// InvalidateBackbuffer( );
//}
UnLockVideoSurface( uiDestVSurface );
return( TRUE );
}
/**********************************************************************************************
DestroyObjectPaletteTables
Destroys the palette tables of a video object. All memory is deallocated, and
the pointers set to NULL. Be careful not to try and blit this object until new
tables are calculated, or things WILL go boom.
**********************************************************************************************/
BOOLEAN DestroyObjectPaletteTables(HVOBJECT hVObject)
{
UINT32 x;
BOOLEAN f16BitPal;
for ( x = 0; x < HVOBJECT_SHADE_TABLES; x++ )
{
if ( !( hVObject->fFlags & VOBJECT_FLAG_SHADETABLE_SHARED ) )
{
if ( hVObject->pShades[x] != NULL )
{
if ( hVObject->pShades[x] == hVObject->p16BPPPalette )
f16BitPal = TRUE;
else
f16BitPal = FALSE;
MemFree( hVObject->pShades[x] );
hVObject->pShades[x] = NULL;
if ( f16BitPal )
hVObject->p16BPPPalette = NULL;
}
}
}
if ( hVObject->p16BPPPalette != NULL )
{
MemFree( hVObject->p16BPPPalette );
hVObject->p16BPPPalette = NULL;
}
hVObject->pShadeCurrent=NULL;
hVObject->pGlow=NULL;
return(TRUE);
}
UINT16 SetObjectShade(HVOBJECT pObj, UINT32 uiShade)
{
Assert(pObj!=NULL);
Assert(uiShade >= 0);
Assert(uiShade < HVOBJECT_SHADE_TABLES);
if(pObj->pShades[uiShade]==NULL)
{
DbgMessage(TOPIC_VIDEOOBJECT, DBG_LEVEL_2, String("Attempt to set shade level to NULL table"));
return(FALSE);
}
pObj->pShadeCurrent=pObj->pShades[uiShade];
return(TRUE);
}
UINT16 SetObjectHandleShade(UINT32 uiHandle, UINT32 uiShade)
{
HVOBJECT hObj;
#ifdef _DEBUG
gubVODebugCode = DEBUGSTR_SETOBJECTHANDLESHADE;
#endif
if(!GetVideoObject(&hObj, uiHandle))
{
DbgMessage(TOPIC_VIDEOOBJECT, DBG_LEVEL_2, String("Invalid object handle for setting shade level"));
return(FALSE);
}
return(SetObjectShade(hObj, uiShade));
}
/*
UINT16 FillObjectRect(UINT32 iObj, INT32 x1, INT32 y1, INT32 x2, INT32 y2, COLORVAL color32)
{
UINT16 *pBuffer;
UINT32 uiPitch;
//HVSURFACE pSurface;
// Lock video surface
pBuffer = (UINT16*)LockVideoSurface(iObj, &uiPitch );
//UnLockVideoSurface(iObj);
if (pBuffer == NULL)
return( FALSE );
FillRect16BPP(pBuffer, uiPitch, x1, y1, x2, y2, Get16BPPColor(color32));
// Mark as dirty if it's the backbuffer
if(iObj == BACKBUFFER)
InvalidateBackbuffer();
UnLockVideoSurface(iObj);
}
*/
/********************************************************************************************
GetETRLEPixelValue
Given a VOBJECT and ETRLE image index, retrieves the value of the pixel located at the
given image coordinates. The value returned is an 8-bit palette index
********************************************************************************************/
BOOLEAN GetETRLEPixelValue( UINT8 * pDest, HVOBJECT hVObject, UINT16 usETRLEIndex, UINT16 usX, UINT16 usY )
{
UINT8 * pCurrent;
UINT16 usLoopX = 0;
UINT16 usLoopY = 0;
UINT16 ubRunLength;
ETRLEObject * pETRLEObject;
// Do a bunch of checks
CHECKF( hVObject != NULL );
CHECKF( usETRLEIndex < hVObject->usNumberOfObjects );
pETRLEObject = &(hVObject->pETRLEObject[usETRLEIndex]);
CHECKF( usX < pETRLEObject->usWidth );
CHECKF( usY < pETRLEObject->usHeight );
// Assuming everything's okay, go ahead and look...
pCurrent = &((UINT8 *)hVObject->pPixData)[pETRLEObject->uiDataOffset];
// Skip past all uninteresting scanlines
while( usLoopY < usY )
{
while( *pCurrent != 0 )
{
if (*pCurrent & COMPRESS_TRANSPARENT)
{
pCurrent++;
}
else
{
pCurrent += *pCurrent & COMPRESS_RUN_MASK;
}
}
usLoopY++;
}
// Now look in this scanline for the appropriate byte
do
{
ubRunLength = *pCurrent & COMPRESS_RUN_MASK;
if (*pCurrent & COMPRESS_TRANSPARENT)
{
if (usLoopX + ubRunLength >= usX)
{
*pDest = 0;
return( TRUE );
}
else
{
pCurrent++;
}
}
else
{
if (usLoopX + ubRunLength >= usX)
{
// skip to the correct byte; skip at least 1 to get past the byte defining the run
pCurrent += (usX - usLoopX) + 1;
*pDest = *pCurrent;
return( TRUE );
}
else
{
pCurrent += ubRunLength + 1;
}
}
usLoopX += ubRunLength;
}
while( usLoopX < usX );
// huh???
return( FALSE );
}
BOOLEAN GetVideoObjectETRLEProperties( HVOBJECT hVObject, ETRLEObject *pETRLEObject, UINT16 usIndex )
{
CHECKF( usIndex >= 0 );
CHECKF( usIndex < hVObject->usNumberOfObjects );
memcpy( pETRLEObject, &( hVObject->pETRLEObject[ usIndex ] ), sizeof( ETRLEObject ) );
return( TRUE );
}
BOOLEAN GetVideoObjectETRLESubregionProperties( UINT32 uiVideoObject, UINT16 usIndex, UINT16 *pusWidth, UINT16 *pusHeight )
{
HVOBJECT hVObject;
ETRLEObject ETRLEObject;
// Get video object
#ifdef _DEBUG
gubVODebugCode = DEBUGSTR_GETVIDEOOBJECTETRLESUBREGIONPROPERTIES;
#endif
CHECKF( GetVideoObject( &hVObject, uiVideoObject ) );
CHECKF( GetVideoObjectETRLEProperties( hVObject, &ETRLEObject, usIndex ) );
*pusWidth = ETRLEObject.usWidth;
*pusHeight = ETRLEObject.usHeight;
return( TRUE );
}
BOOLEAN GetVideoObjectETRLEPropertiesFromIndex( UINT32 uiVideoObject, ETRLEObject *pETRLEObject, UINT16 usIndex )
{
HVOBJECT hVObject;
// Get video object
#ifdef _DEBUG
gubVODebugCode = DEBUGSTR_GETVIDEOOBJECTETRLEPROPERTIESFROMINDEX;
#endif
CHECKF( GetVideoObject( &hVObject, uiVideoObject ) );
CHECKF( GetVideoObjectETRLEProperties( hVObject, pETRLEObject, usIndex ) );
return( TRUE );
}
BOOLEAN SetVideoObjectPalette8BPP(INT32 uiVideoObject, SGPPaletteEntry *pPal8)
{
HVOBJECT hVObject;
// Get video object
#ifdef _DEBUG
gubVODebugCode = DEBUGSTR_SETVIDEOOBJECTPALETTE8BPP;
#endif
CHECKF( GetVideoObject( &hVObject, uiVideoObject ) );
return( SetVideoObjectPalette( hVObject, pPal8 ) );
}
BOOLEAN GetVideoObjectPalette16BPP(INT32 uiVideoObject, UINT16 **ppPal16)
{
HVOBJECT hVObject;
// Get video object
#ifdef _DEBUG
gubVODebugCode = DEBUGSTR_GETVIDEOOBJECTPALETTE16BPP;
#endif
CHECKF( GetVideoObject( &hVObject, uiVideoObject ) );
*ppPal16 = hVObject->p16BPPPalette;
return( TRUE );
}
BOOLEAN CopyVideoObjectPalette16BPP(INT32 uiVideoObject, UINT16 *ppPal16)
{
HVOBJECT hVObject;
// Get video object
#ifdef _DEBUG
gubVODebugCode = DEBUGSTR_COPYVIDEOOBJECTPALETTE16BPP;
#endif
CHECKF( GetVideoObject( &hVObject, uiVideoObject ) );
memcpy(ppPal16, hVObject->p16BPPPalette, 256*2);
return( TRUE );
}
BOOLEAN CheckFor16BPPRegion( HVOBJECT hVObject, UINT16 usRegionIndex, UINT8 ubShadeLevel, UINT16 * pusIndex )
{
UINT16 usLoop;
SixteenBPPObjectInfo * p16BPPObject;
if (hVObject->usNumberOf16BPPObjects > 0)
{
for (usLoop = 0; usLoop < hVObject->usNumberOf16BPPObjects; usLoop++)
{
p16BPPObject = &(hVObject->p16BPPObject[usLoop]);
if (p16BPPObject->usRegionIndex == usRegionIndex && p16BPPObject->ubShadeLevel == ubShadeLevel)
{
if (pusIndex != NULL)
{
*pusIndex = usLoop;
}
return( TRUE );
}
}
}
return( FALSE );
}
BOOLEAN ConvertVObjectRegionTo16BPP( HVOBJECT hVObject, UINT16 usRegionIndex, UINT8 ubShadeLevel )
{
SixteenBPPObjectInfo * p16BPPObject;
UINT8 * pInput;
UINT8 * pOutput;
UINT16 * p16BPPPalette;
UINT32 uiDataLoop;
UINT32 uiDataLength;
UINT8 ubRunLoop;
//UINT8 ubRunLength;
INT8 bData;
UINT32 uiLen;
// check for existing 16BPP region and then allocate memory
if (usRegionIndex >= hVObject->usNumberOfObjects || ubShadeLevel >= HVOBJECT_SHADE_TABLES)
{
return( FALSE );
}
if (CheckFor16BPPRegion( hVObject, usRegionIndex, ubShadeLevel, NULL) == TRUE)
{
// it already exists; no need to do anything!
return( TRUE );
}
if (hVObject->usNumberOf16BPPObjects > 0)
{
// have to reallocate memory
hVObject->p16BPPObject = (SixteenBPPObjectInfo *) MemRealloc( hVObject->p16BPPObject, sizeof( SixteenBPPObjectInfo ) * (hVObject->usNumberOf16BPPObjects + 1) );
}
else
{
// allocate memory for the first 16BPPObject
hVObject->p16BPPObject = (SixteenBPPObjectInfo *) MemAlloc( sizeof( SixteenBPPObjectInfo ) );
}
if (hVObject->p16BPPObject == NULL)
{
hVObject->usNumberOf16BPPObjects = 0;
return( FALSE );
}
// the new object is the last one in the array
p16BPPObject = &(hVObject->p16BPPObject[hVObject->usNumberOf16BPPObjects]);
// need twice as much memory because of going from 8 to 16 bits
p16BPPObject->p16BPPData = (UINT16 *) MemAlloc( hVObject->pETRLEObject[usRegionIndex].uiDataLength * 2 );
if (p16BPPObject->p16BPPData == NULL)
{
return( FALSE );
}
p16BPPObject->usRegionIndex = usRegionIndex;
p16BPPObject->ubShadeLevel = ubShadeLevel;
p16BPPObject->usHeight = hVObject->pETRLEObject[ usRegionIndex ].usHeight;
p16BPPObject->usWidth = hVObject->pETRLEObject[ usRegionIndex ].usWidth;
p16BPPObject->sOffsetX=hVObject->pETRLEObject[ usRegionIndex ].sOffsetX;
p16BPPObject->sOffsetY=hVObject->pETRLEObject[ usRegionIndex ].sOffsetY;
// get the palette
p16BPPPalette = hVObject->pShades[ubShadeLevel];
pInput = (UINT8 *) hVObject->pPixData + hVObject->pETRLEObject[ usRegionIndex ].uiDataOffset;
uiDataLength=hVObject->pETRLEObject[usRegionIndex].uiDataLength;
// now actually do the conversion
uiLen=0;
pOutput = (UINT8 *)p16BPPObject->p16BPPData;
for (uiDataLoop = 0; uiDataLoop < uiDataLength; uiDataLoop++)
{
bData= *pInput;
if(bData&0x80)
{
// transparent
*pOutput = *pInput;
pOutput++;
pInput++;
//uiDataLoop++;
uiLen+=(UINT32)(bData&0x7f);
}
else if(bData > 0)
{
// nontransparent
*pOutput = *pInput;
pOutput++;
pInput++;
//uiDataLoop++;
for(ubRunLoop=0; ubRunLoop < bData; ubRunLoop++)
{
*((UINT16 *)pOutput) = p16BPPPalette[*pInput];
pOutput++;
pOutput++;
pInput++;
uiDataLoop++;
}
uiLen+=(UINT32)bData;
}
else
{
// eol
*pOutput = *pInput;
pOutput++;
pInput++;
//uiDataLoop++;
if(uiLen!=p16BPPObject->usWidth)
DbgMessage(TOPIC_VIDEOOBJECT, DBG_LEVEL_1, String( "Actual pixel width different from header width" ));
uiLen=0;
}
// copy the run-length byte
/* *pOutput = *pInput;
pOutput++;
if (((*pInput) & COMPRESS_TRANSPARENT) == 0 && *pInput > 0)
{
// non-transparent run; deal with the pixel data
ubRunLoop = 0;
ubRunLength = ((*pInput) & COMPRESS_RUN_LIMIT);
// skip to the next input byte
pInput++;
for (ubRunLoop = 0; ubRunLoop < ubRunLength; ubRunLoop++)
{
*((UINT16 *)pOutput) = p16BPPPalette[*pInput];
// advance two bytes in output, one in input
pOutput++;
pOutput++;
pInput++;
uiDataLoop++;
}
}
else
{
// transparent run or end of scanline; skip to the next input byte
pInput++;
} */
}
hVObject->usNumberOf16BPPObjects++;
return( TRUE );
}
BOOLEAN BltVideoObjectOutlineFromIndex(UINT32 uiDestVSurface, UINT32 uiSrcVObject, UINT16 usIndex, INT32 iDestX, INT32 iDestY, INT16 s16BPPColor, BOOLEAN fDoOutline )
{
UINT16 *pBuffer;
UINT32 uiPitch;
HVOBJECT hSrcVObject;
// Lock video surface
pBuffer = (UINT16*)LockVideoSurface( uiDestVSurface, &uiPitch );
if ( pBuffer == NULL )
{
return( FALSE );
}
// Get video object
#ifdef _DEBUG
gubVODebugCode = DEBUGSTR_BLTVIDEOOBJECTOUTLINEFROMINDEX;
#endif
CHECKF( GetVideoObject( &hSrcVObject, uiSrcVObject ) );
if( BltIsClipped( hSrcVObject, iDestX, iDestY, usIndex, &ClippingRect) )
{
Blt8BPPDataTo16BPPBufferOutlineClip((UINT16*)pBuffer, uiPitch, hSrcVObject, iDestX, iDestY, usIndex, s16BPPColor, fDoOutline, &ClippingRect );
}
else
{
Blt8BPPDataTo16BPPBufferOutline((UINT16*)pBuffer, uiPitch, hSrcVObject, iDestX, iDestY, usIndex, s16BPPColor, fDoOutline );
}
// Now we have the video object and surface, call the VO blitter function
UnLockVideoSurface( uiDestVSurface );
return( TRUE );
}
BOOLEAN BltVideoObjectOutline(UINT32 uiDestVSurface, HVOBJECT hSrcVObject, UINT16 usIndex, INT32 iDestX, INT32 iDestY, INT16 s16BPPColor, BOOLEAN fDoOutline )
{
UINT16 *pBuffer;
UINT32 uiPitch;
// Lock video surface
pBuffer = (UINT16*)LockVideoSurface( uiDestVSurface, &uiPitch );
if ( pBuffer == NULL )
{
return( FALSE );
}
if( BltIsClipped( hSrcVObject, iDestX, iDestY, usIndex, &ClippingRect) )
{
Blt8BPPDataTo16BPPBufferOutlineClip((UINT16*)pBuffer, uiPitch, hSrcVObject, iDestX, iDestY, usIndex, s16BPPColor, fDoOutline, &ClippingRect );
}
else
{
Blt8BPPDataTo16BPPBufferOutline((UINT16*)pBuffer, uiPitch, hSrcVObject, iDestX, iDestY, usIndex, s16BPPColor, fDoOutline );
}
// Now we have the video object and surface, call the VO blitter function
UnLockVideoSurface( uiDestVSurface );
return( TRUE );
}
BOOLEAN BltVideoObjectOutlineShadowFromIndex(UINT32 uiDestVSurface, UINT32 uiSrcVObject, UINT16 usIndex, INT32 iDestX, INT32 iDestY )
{
UINT16 *pBuffer;
UINT32 uiPitch;
HVOBJECT hSrcVObject;
// Lock video surface
pBuffer = (UINT16*)LockVideoSurface( uiDestVSurface, &uiPitch );
if ( pBuffer == NULL )
{
return( FALSE );
}
// Get video object
#ifdef _DEBUG
gubVODebugCode = DEBUGSTR_BLTVIDEOOBJECTOUTLINESHADOWFROMINDEX;
#endif
CHECKF( GetVideoObject( &hSrcVObject, uiSrcVObject ) );
if(hSrcVObject->ubBitDepth == 8)
{
if( BltIsClipped( hSrcVObject, iDestX, iDestY, usIndex, &ClippingRect) )
{
Blt8BPPDataTo16BPPBufferOutlineShadowClip((UINT16*)pBuffer, uiPitch, hSrcVObject, iDestX, iDestY, usIndex, &ClippingRect );
}
else
{
Blt8BPPDataTo16BPPBufferOutlineShadow((UINT16*)pBuffer, uiPitch, hSrcVObject, iDestX, iDestY, usIndex );
}
}
else if(hSrcVObject->ubBitDepth == 16)
{
SGP_THROW_IFFALSE(usIndex < hSrcVObject->usNumberOf16BPPObjects, L"index larger that number images");
SixteenBPPObjectInfo &image = hSrcVObject->p16BPPObject[0];
Blt16BPPTo16BPPTransShadow(pBuffer, uiPitch, image.p16BPPData, image.usWidth * sizeof(UINT16),
iDestX, iDestY, 0, 0, image.usWidth, image.usHeight, 0x1F);
}
else if(hSrcVObject->ubBitDepth == 32)
{
SGP_THROW_IFFALSE(usIndex < hSrcVObject->usNumberOf16BPPObjects, L"index larger that number images");
SixteenBPPObjectInfo &image = hSrcVObject->p16BPPObject[0];
Blt32BPPTo16BPPTransShadow(pBuffer, uiPitch, (UINT32*)image.p16BPPData, image.usWidth * sizeof(UINT32),
iDestX, iDestY, 0, 0, image.usWidth, image.usHeight);
}
// Now we have the video object and surface, call the VO blitter function
UnLockVideoSurface( uiDestVSurface );
return( TRUE );
}
BOOLEAN BltVideoObjectOutlineShadow(UINT32 uiDestVSurface, HVOBJECT hSrcVObject, UINT16 usIndex, INT32 iDestX, INT32 iDestY )
{
UINT16 *pBuffer;
UINT32 uiPitch;
// Lock video surface
pBuffer = (UINT16*)LockVideoSurface( uiDestVSurface, &uiPitch );
if ( pBuffer == NULL )
{
return( FALSE );
}
if( BltIsClipped( hSrcVObject, iDestX, iDestY, usIndex, &ClippingRect) )
{
Blt8BPPDataTo16BPPBufferOutlineShadowClip((UINT16*)pBuffer, uiPitch, hSrcVObject, iDestX, iDestY, usIndex, &ClippingRect );
}
else
{
Blt8BPPDataTo16BPPBufferOutlineShadow((UINT16*)pBuffer, uiPitch, hSrcVObject, iDestX, iDestY, usIndex );
}
// Now we have the video object and surface, call the VO blitter function
UnLockVideoSurface( uiDestVSurface );
return( TRUE );
}
#ifdef _DEBUG
void CheckValidVObjectIndex( UINT32 uiIndex )
{
BOOLEAN fAssertError = FALSE;
if( uiIndex == 0xffffffff )
{ //-1 index -- deleted
fAssertError = TRUE;
}
if( !(uiIndex % 2) && uiIndex < 0xfffffff0 || uiIndex >= 0xfffffff0 )
{ //even numbers are reserved for vsurfaces as well as the 0xfffffff0+ values
fAssertError = TRUE;
}
if( fAssertError )
{
CHAR8 str[60];
switch( gubVODebugCode )
{
case DEBUGSTR_SETVIDEOOBJECTTRANSPARENCY:
sprintf( str, "SetVideoObjectTransparency" );
break;
case DEBUGSTR_BLTVIDEOOBJECTFROMINDEX:
sprintf( str, "BltVideoObjectFromIndex" );
break;
case DEBUGSTR_SETOBJECTHANDLESHADE:
sprintf( str, "SetObjectHandleShade" );
break;
case DEBUGSTR_GETVIDEOOBJECTETRLESUBREGIONPROPERTIES:
sprintf( str, "GetVideoObjectETRLESubRegionProperties" );
break;
case DEBUGSTR_GETVIDEOOBJECTETRLEPROPERTIESFROMINDEX:
sprintf( str, "GetVideoObjectETRLEPropertiesFromIndex" );
break;
case DEBUGSTR_SETVIDEOOBJECTPALETTE8BPP:
sprintf( str, "SetVideoObjectPalette8BPP" );
break;
case DEBUGSTR_GETVIDEOOBJECTPALETTE16BPP:
sprintf( str, "GetVideoObjectPalette16BPP" );
break;
case DEBUGSTR_COPYVIDEOOBJECTPALETTE16BPP:
sprintf( str, "CopyVideoObjectPalette16BPP" );
break;
case DEBUGSTR_BLTVIDEOOBJECTOUTLINEFROMINDEX:
sprintf( str, "BltVideoObjectOutlineFromIndex" );
break;
case DEBUGSTR_BLTVIDEOOBJECTOUTLINESHADOWFROMINDEX:
sprintf( str, "BltVideoObjectOutlineShadowFromIndex" );
break;
case DEBUGSTR_DELETEVIDEOOBJECTFROMINDEX:
sprintf( str, "DeleteVideoObjectFromIndex" );
break;
case DEBUGSTR_NONE:
default:
sprintf( str, "GetVideoObject" );
break;
}
}
}
#endif
#ifdef SGP_VIDEO_DEBUGGING
typedef struct DUMPFILENAME
{
CHAR8 str[256];
}DUMPFILENAME;
void DumpVObjectInfoIntoFile( const STR8 filename, BOOLEAN fAppend )
{
VOBJECT_NODE *curr;
FILE *fp;
DUMPFILENAME *pName, *pCode;
UINT32 *puiCounter;
CHAR8 tempName[ 256 ];
CHAR8 tempCode[ 256 ];
UINT32 i, uiUniqueID;
BOOLEAN fFound;
if( !guiVObjectSize )
{
return;
}
if( fAppend )
{
fp = fopen( filename, "a" );
}
else
{
fp = fopen( filename, "w" );
}
Assert( fp );
//Allocate enough strings and counters for each node.
pName = (DUMPFILENAME*)MemAlloc( sizeof( DUMPFILENAME ) * guiVObjectSize );
pCode = (DUMPFILENAME*)MemAlloc( sizeof( DUMPFILENAME ) * guiVObjectSize );
memset( pName, 0, sizeof( DUMPFILENAME ) * guiVObjectSize );
memset( pCode, 0, sizeof( DUMPFILENAME ) * guiVObjectSize );
puiCounter = (UINT32*)MemAlloc( 4 * guiVObjectSize );
memset( puiCounter, 0, 4 * guiVObjectSize );
//Loop through the list and record every unique filename and count them
uiUniqueID = 0;
curr = gpVObjectHead;
while( curr )
{
strcpy( tempName, curr->pName );
strcpy( tempCode, curr->pCode );
fFound = FALSE;
for( i = 0; i < uiUniqueID; i++ )
{
if( !_stricmp( tempName, pName[i].str ) && !_stricmp( tempCode, pCode[i].str ) )
{ //same string
fFound = TRUE;
(puiCounter[ i ])++;
break;
}
}
if( !fFound )
{
strcpy( pName[i].str, tempName );
strcpy( pCode[i].str, tempCode );
(puiCounter[ i ])++;
uiUniqueID++;
}
curr = curr->next;
}
//Now dump the info.
fprintf( fp, "-----------------------------------------------\n" );
fprintf( fp, "%d unique vObject names exist in %d VObjects\n", uiUniqueID, guiVObjectSize );
fprintf( fp, "-----------------------------------------------\n\n" );
for( i = 0; i < uiUniqueID; i++ )
{
fprintf( fp, "%d occurrences of %s\n", puiCounter[i], pName[i].str );
fprintf( fp, "%s\n\n", pCode[i].str );
}
fprintf( fp, "\n-----------------------------------------------\n\n" );
//Free all memory associated with this operation.
MemFree( pName );
MemFree( pCode );
MemFree( puiCounter );
fclose( fp );
}
//Debug wrapper for adding vObjects
BOOLEAN _AddAndRecordVObject( VOBJECT_DESC *VObjectDesc, UINT32 *uiIndex, UINT32 uiLineNum, const STR8 pSourceFile )
{
UINT16 usLength;
CHAR8 str[256];
if( !AddStandardVideoObject( VObjectDesc, uiIndex ) )
{
return FALSE;
}
//record the filename of the vObject (some are created via memory though)
usLength = strlen( VObjectDesc->ImageFile ) + 1;
gpVObjectTail->pName = (STR8)MemAlloc( usLength );
memset( gpVObjectTail->pName, 0, usLength );
strcpy( gpVObjectTail->pName, VObjectDesc->ImageFile );
//record the code location of the calling creating function.
sprintf( str, "%s -- line(%d)", pSourceFile, uiLineNum );
usLength = strlen( str ) + 1;
gpVObjectTail->pCode = (STR8)MemAlloc( usLength );
memset( gpVObjectTail->pCode, 0, usLength );
strcpy( gpVObjectTail->pCode, str );
return TRUE;
}
void PerformVideoInfoDumpIntoFile( const STR8 filename, BOOLEAN fAppend )
{
DumpVObjectInfoIntoFile( filename, fAppend );
DumpVSurfaceInfoIntoFile( filename, TRUE );
}
#endif
// Flugente: retrieve width and height of video object
void GetVideoObjectDimensions( HVOBJECT hSrcVObject, UINT16 usIndex, UINT16& rusWidth, UINT16& rusHeight )
{
rusWidth = 0;
rusHeight = 0;
if ( hSrcVObject == NULL )
return;
switch ( hSrcVObject->ubBitDepth )
{
case 32:
case 16:
if ( usIndex < hSrcVObject->usNumberOf16BPPObjects )
{
rusWidth = hSrcVObject->p16BPPObject[usIndex].usWidth;
rusHeight = hSrcVObject->p16BPPObject[usIndex].usHeight;
}
break;
case 8:
if ( usIndex < hSrcVObject->usNumberOfObjects )
{
rusWidth = hSrcVObject->pETRLEObject[usIndex].usWidth;
rusHeight = hSrcVObject->pETRLEObject[usIndex].usHeight;
}
break;
}
}
Reference in New Issue View Git Blame Copy Permalink