StatusType NextValue_runtime(thread_queue_t * global_q, int port_id, void * dst)
{
StatusType status = E_OK;
struct port_queue_t *port_q = (struct port_queue_t*) global_q->port_queues[port_id];
status = GetResource(*(global_q->rez));
if (status != E_OK)
return status;
if(port_q->first_idx == port_q->last_idx)
{
if(port_q->blocking)
{
global_q->waiting=global_q->waiting+1;
ReleaseResource(*(global_q->rez));
status = WaitEvent(*(global_q->event));
GetResource(*(global_q->rez));
global_q->waiting=global_q->waiting-1;
}
else
{
ReleaseResource(*(global_q->rez));
return E_OS_LIMIT;
}
}
if(port_q->first_idx < port_q->last_idx)
port_q->first_idx=(port_q->first_idx+1)%port_q->queue_size;
memcpy(dst, &port_q->offset[(port_q->first_idx)*(port_q->msg_size/sizeof(char))], port_q->msg_size);
global_q->msg_nb--;
ReleaseResource(*(global_q->rez));
return status;
}
//主进程
void main(void)
{
//创建Opengl渲染环境及窗口
char *device = "opengl";
HCoreResizeFunc( ResizeWindow );
HCoreCreateWindow(100, 100, 800, 600, device);
if ( !HCoreInitGraphicsDevice(device) )
{
printf("初始化失败 \n", device);
exit(0);
}
//注册输入函数
HCoreInputInit();
HCoreRegisterKeyDown(HCoreKEY_0, KeyDown_0);
HCoreRegisterKeyDown(HCoreKEY_1, KeyDown_1);
HCoreRegisterKeyDown(HCoreKEY_2, KeyDown_2);
HCoreRegisterKeyDown(HCoreKEY_3, KeyDown_3);
HCoreRegisterKeyDown(HCoreKEY_4, KeyDown_4);
HCoreRegisterKeyDown(HCoreKEY_5, KeyDown_5);
HCoreRegisterKeyDown(HCoreKEY_6, KeyDown_6);
HCoreRegisterKeyDown(HCoreKEY_7, KeyDown_7);
HCoreRegisterKeyDown(HCoreKEY_8, KeyDown_8);
HCoreRegisterKeyDown(HCoreKEY_9, KeyDown_9);
//设置相机
g_Control.SetCamera(Vector4(0.0f, 0.0f, 1.0f), Vector4(0.0f, 1.0f, 1.0f), Vector4(0.0f, 0.0f, 1.0f) );
//读取模型
//地形
g_Model.Load_ASCII("..\\models\\terrain.gma");
//棋盘
g_SSAOModel.Load_ASCII("..\\models\\chess.gma");
// 载入shader
if ( !InitResource() )
{
ReleaseResource();
exit(0);
}
// 主循环
while( HCoreProcessMessage() )
{
GetUserInput();
RenderFrame();
}
// 释放shader
ReleaseResource();
// 关闭OpenGL绘图设备
HCoreReleaseGraphicsDevice();
}
void ReleaseAnimatedCursors( void )
{
short i;
if ( gCursorList )
{
for ( i = 0; i< (*gCursorList)->numberOfFrames; i++ )
ReleaseResource( (Handle) (*gCursorList)->frame[i] );
ReleaseResource( (Handle) gCursorList );
}
}
void
ShowLogo(Boolean bEraseRect)
{
short reserr;
Rect derefd, logoRect;
PicHandle logoPicH;
Handle logoRectH;
/* draw the image well */
ControlHandle imgWellH = GetNewControl(rLogoImgWell, gWPtr);
if (!imgWellH)
{
ErrorHandler(eMem, nil);
return;
}
/* initialize Netscape logo */
logoPicH = GetPicture(rNSLogo);
reserr = ResError();
if (reserr == noErr)
{
/* draw Netscape logo */
if (logoPicH != nil)
{
logoRectH = GetResource('RECT', rNSLogoBox);
reserr = ResError();
if (reserr == noErr && logoRectH)
{
HLock(logoRectH);
derefd = (Rect) **((Rect**)logoRectH);
SetRect(&logoRect, derefd.left, derefd.top, derefd.right, derefd.bottom);
HUnlock(logoRectH);
reserr = ResError();
if (reserr == noErr)
{
if (bEraseRect)
{
EraseRect(&logoRect);
InvalRect(&logoRect);
}
DrawPicture(logoPicH, &logoRect);
ReleaseResource((Handle)logoPicH);
}
ReleaseResource((Handle)logoRectH);
}
}
}
if (reserr != noErr)
ErrorHandler(reserr, nil);
}
BOOLEAN
NameCacheFree(PKLG_NAME_CACHE pNameCache, ULONG key)
{
PNAMECACHE Entry;
PNAMECACHE Prev;
ULONG i;
if (pNameCache == NULL)
return FALSE;
Prev = NULL;
i = HASH_FUNC(key);
AcquireResource(&pNameCache->m_CacheResource, TRUE);
Entry=pNameCache->m_NameCache[i];
while(Entry && Entry->Key!=key)
{
Prev=Entry;
Entry=Entry->Next;
}
if(!Entry)
{
DbPrint(DC_NAMEC,DL_SPAM, ("CacheFree-%x %x not found. NCLen=%d\n",pNameCache,key,pNameCache->m_NCLen));
ReleaseResource(&pNameCache->m_CacheResource);
return FALSE;
}
Entry->RefCount--;
if(Entry->RefCount)
{
DbPrint(DC_NAMEC,DL_INFO, ("CacheFree-%x. Owner=%x Ref decr for key %x ("_STRING_DEF") NCLen=%d\n",
pNameCache, Entry->Owner, Entry->Key, Entry->Name, pNameCache->m_NCLen));
ReleaseResource(&pNameCache->m_CacheResource);
return TRUE;
}
if(Prev)
Prev->Next = Entry->Next;
else
pNameCache->m_NameCache[i]=Entry->Next;
#ifdef __DBG__
pNameCache->m_NCLen--;
pNameCache->m_NameCacheLen[i]--;
DbPrint(DC_NAMEC,DL_INFO, ("CacheFree-%x. Owner=%x Freed key %x ("_STRING_DEF") NCLen=%d\n", pNameCache,
Entry->Owner, Entry->Key, Entry->Name, pNameCache->m_NCLen));
#endif
ReleaseResource(&pNameCache->m_CacheResource);
ExFreePool(Entry);
return TRUE;
}
wxCursor::wxCursor(const wxString& cursor_file, long flags, int hotSpotX, int hotSpotY)
{
m_refData = new wxCursorRefData;
if ( flags == wxBITMAP_TYPE_MACCURSOR_RESOURCE )
{
Str255 theName ;
wxMacStringToPascal( cursor_file , theName ) ;
wxStAppResource resload ;
Handle resHandle = ::GetNamedResource( 'crsr' , theName ) ;
if ( resHandle )
{
short theId = -1 ;
OSType theType ;
GetResInfo( resHandle , &theId , &theType , theName ) ;
ReleaseResource( resHandle ) ;
M_CURSORDATA->m_hCursor = GetCCursor( theId ) ;
if ( M_CURSORDATA->m_hCursor )
M_CURSORDATA->m_isColorCursor = true ;
}
else
{
Handle resHandle = ::GetNamedResource( 'CURS' , theName ) ;
if ( resHandle )
{
short theId = -1 ;
OSType theType ;
GetResInfo( resHandle , &theId , &theType , theName ) ;
ReleaseResource( resHandle ) ;
M_CURSORDATA->m_hCursor = GetCursor( theId ) ;
if ( M_CURSORDATA->m_hCursor )
M_CURSORDATA->m_releaseHandle = true ;
}
}
}
else
{
wxImage image ;
image.LoadFile( cursor_file , flags ) ;
if( image.Ok() )
{
image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X,hotSpotX ) ;
image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y,hotSpotY ) ;
delete m_refData ;
CreateFromImage(image) ;
}
}
}
// Pass resFile as -1 to use the current resource file
// true = exists
Boolean IndResourceExists(short resFile,ResType resType,short inIndex)
{
short oldRes=::CurResFile();
Handle theRes=0L;
if (resFile!=-1)
{
UseResFile(resFile);
if (ResError())
return false;
}
SetResLoad(false);
theRes=Get1IndResource(resType,inIndex);
SetResLoad(true);
UseResFile(oldRes);
if (theRes)
{
ReleaseResource(theRes);
return true;
}
else
return false;
}
VOID
NameCacheGetReplaceBinary(PKLG_NAME_CACHE pNameCache, ULONG key, PVOID Value, DWORD ValueLen)
{
PVOID pRet = NULL;
BOOLEAN bOverBuf = FALSE;
if (pNameCache == NULL)
{
DbPrint(DC_NAMEC,DL_SPAM, ("NameCacheReplaceBinary: wrong internal status - NULL\n"));
return;
}
AcquireResource(&pNameCache->m_CacheResource, FALSE);
pRet = NameCacheGetBase(pNameCache, key, NULL, ValueLen, &bOverBuf, FALSE, NULL);
if (bOverBuf == TRUE)
{
DbPrint(DC_NAMEC, DL_WARNING, ("NameCacheReplaceBunary: size mismatch\n"));
DbgBreakPoint();
}
else
{
if (pRet != NULL)
memcpy(pRet, Value, ValueLen);
}
ReleaseResource(&pNameCache->m_CacheResource);
}
VOID
NameCacheClean(PKLG_NAME_CACHE pNameCache)
{
ULONG i;
PNAMECACHE Tmp,Entry;
if (pNameCache == NULL)
{
DbPrint(DC_NAMEC,DL_INFO, ("NameCacheClean: wrong internal status - NULL\n"));
return;
}
AcquireResource(&pNameCache->m_CacheResource, TRUE);
for(i =0; i < HASH_SIZE; i++)
{
Entry=pNameCache->m_NameCache[i];
while(Entry)
{
Tmp=Entry->Next;
ExFreePool(Entry);
Entry = Tmp;
#ifdef __DBG__
pNameCache->m_NCLen--;
pNameCache->m_NameCacheLen[i]--;
#endif
}
pNameCache->m_NameCache[i] = NULL;
}
DbPrint(DC_NAMEC,DL_NOTIFY, ("CacheCleanup-%x. NCLen=%d\n",pNameCache,pNameCache->m_NCLen));
ReleaseResource(&pNameCache->m_CacheResource);
}
OSErr GetConfig(Ptr config)
{
OSErr error = noErr;
FSSpec where;
short ref;
Handle theString;
Ptr temp = nil;
long len;
config[0] = '\0'; // Start without a name
error = FindPrefs(&where);
ref = FSpOpenResFile(&where, fsRdWrPerm);
if (ref != -1) {
theString = Get1Resource('STR ',kConfigRes); // Should look in most recent file first
if (theString != nil) {
len = SizeResource(theString);
SetPtrSize(config, len); // Set the size
error = MemError(); // And make sure it worked
if (error == noErr) {
HLock(theString);
temp = (Ptr)*theString;
memcpy(config, temp, len);
HUnlock(theString);
ReleaseResource(theString);
}
} else {
error = -4;
}
CloseResFile(ref);
} else {
error = ResError();
}
return error;
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t1_instance2(void)
{
ApplicationType result_app_1;
StatusType result_inst_1, result_inst_2, result_inst_3, result_inst_4;
ScheduleTableStatusType ScheduleTableStatusType_inst_1;
TickType TickType_inst_1;
SCHEDULING_CHECK_INIT(10);
result_app_1 = GetApplicationID();
SCHEDULING_CHECK_AND_EQUAL_INT(10, app1, result_app_1);
SCHEDULING_CHECK_INIT(11);
result_inst_1 = GetAlarm(Alarm1, &TickType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(11, E_OS_NOFUNC, result_inst_1);
SCHEDULING_CHECK_INIT(12);
result_inst_2 = GetScheduleTableStatus(sched1, &ScheduleTableStatusType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT_FIRST(12 , SCHEDULETABLE_STOPPED , ScheduleTableStatusType_inst_1);
SCHEDULING_CHECK_AND_EQUAL_INT(12, E_OK, result_inst_2);
SCHEDULING_CHECK_INIT(13);
result_inst_3 = ReleaseResource(Resource1);
SCHEDULING_CHECK_AND_EQUAL_INT(13, E_OS_NOFUNC, result_inst_3);
SCHEDULING_CHECK_INIT(14);
result_inst_4 = TerminateApplication(app1, NO_RESTART);
SCHEDULING_CHECK_AND_EQUAL_INT(140, E_OK, result_inst_4);
}
HRESULT
D3DResourceManager::GetLockableRTSurface(UINT width, UINT height,
D3DFORMAT format,
D3DResource **ppSurfaceResource)
{
HRESULT res = S_OK;
J2dTraceLn(J2D_TRACE_INFO, "D3DRM::GetLockableRTSurface");
RETURN_STATUS_IF_NULL(pCtx, E_FAIL);
RETURN_STATUS_IF_NULL(ppSurfaceResource, E_FAIL);
if (pLockableRTSurface != NULL) {
D3DSURFACE_DESC *pDesc = pLockableRTSurface->GetDesc();
if (width <= pDesc->Width && height <= pDesc->Height &&
format == pDesc->Format)
{
*ppSurfaceResource = pLockableRTSurface;
return res;
}
// current surface doesn't fit, release and allocate a new one
ReleaseResource(pLockableRTSurface);
pLockableRTSurface = NULL;
}
if (width < D3DC_BLIT_TILE_SIZE) width = D3DC_BLIT_TILE_SIZE;
if (height < D3DC_BLIT_TILE_SIZE) height = D3DC_BLIT_TILE_SIZE;
res = CreateRTSurface(width,height,
(format != D3DFMT_A8R8G8B8), TRUE /*lockable*/,
&format, &pLockableRTSurface);
*ppSurfaceResource = pLockableRTSurface;
return res;
}
void createOffscreen(int pictItem)
{
PicHandle pict;
Rect rect;
CGrafPtr currentPort;
GDHandle currentDevice;
if (gGWorld != nil)
DisposeGWorld( gGWorld );
pict = (PicHandle)GetResource( 'PICT', pictItem + 127 );
rect = (**pict).picFrame;
GetGWorld( ¤tPort, ¤tDevice );
NewGWorld( &gGWorld, 32, &rect, nil, nil, 0 );
LockPixels( GetPortPixMap(gGWorld));
SetGWorld( gGWorld, nil );
DrawPicture( pict, &rect );
SetGWorld( currentPort, currentDevice );
ReleaseResource( (Handle)pict );
}
extern int8_t ciaaModbus_gatewayAddMaster(
int32_t hModbusGW,
int32_t hModbusMaster)
{
uint32_t loopi;
int8_t ret = -1;
if ( (0 <= hModbusGW) && (0 <= hModbusMaster))
{
/* enter critical section */
GetResource(MODBUSR);
for (loopi = 0 ; (loopi < CIAA_MODBUS_GATEWAY_TOTAL_CLIENTS) && (ret != 0) ; loopi++)
{
if (ciaaModbus_gatewayObj[hModbusGW].client[loopi].inUse == false)
{
ciaaModbus_gatewayObj[hModbusGW].client[loopi].inUse = true;
ciaaModbus_gatewayObj[hModbusGW].client[loopi].handler = hModbusMaster;
ciaaModbus_gatewayObj[hModbusGW].client[loopi].recvMsg = ciaaModbus_masterRecvMsg;
ciaaModbus_gatewayObj[hModbusGW].client[loopi].sendMsg = ciaaModbus_masterSendMsg;
ciaaModbus_gatewayObj[hModbusGW].client[loopi].task = ciaaModbus_masterTask;
ciaaModbus_gatewayObj[hModbusGW].client[loopi].getRespTimeout = ciaaModbus_masterGetRespTimeout;
ret = 0;
}
}
/* exit critical section */
ReleaseResource(MODBUSR);
}
return ret;
}
void WriteThumbnailToResourceFork(FSRef *ref, int destWidth, int destHeight)
{
OSStatus err;
PicHandle pict;
HFSUniStr255 fork;
SInt16 resf;
err = FSGetResourceForkName(&fork);
if (err == noErr)
{
err = FSCreateResourceFork(ref, fork.length, fork.unicode, 0);
if ((err == noErr) || (err == errFSForkExists))
{
err = FSOpenResourceFile(ref, fork.length, fork.unicode, fsWrPerm, &resf);
if (err == noErr)
{
pict = GetScreenAsPicHandle(IPPU.RenderedScreenWidth, IPPU.RenderedScreenHeight, destWidth, destHeight);
if (pict)
{
AddResource((Handle) pict, 'PICT', 128, "\p");
WriteResource((Handle) pict);
ReleaseResource((Handle) pict);
}
CloseResFile(resf);
}
extern int8_t ciaaModbus_gatewayAddSlave(
int32_t hModbusGW,
int32_t hModbusSlave)
{
uint32_t loopi;
int8_t ret = -1;
if ( (0 <= hModbusSlave) && (0 <= hModbusGW) )
{
/* enter critical section */
GetResource(MODBUSR);
for (loopi = 0 ; (loopi < CIAA_MODBUS_GATEWAY_TOTAL_SERVERS) && (ret != 0) ; loopi++)
{
if (ciaaModbus_gatewayObj[hModbusGW].server[loopi].inUse == false)
{
ciaaModbus_gatewayObj[hModbusGW].server[loopi].inUse = true;
ciaaModbus_gatewayObj[hModbusGW].server[loopi].handler = hModbusSlave;
ciaaModbus_gatewayObj[hModbusGW].server[loopi].busy = false;
ciaaModbus_gatewayObj[hModbusGW].server[loopi].id = ciaaModbus_slaveGetId(hModbusSlave);
ciaaModbus_gatewayObj[hModbusGW].server[loopi].recvMsg = ciaaModbus_slaveRecvMsg;
ciaaModbus_gatewayObj[hModbusGW].server[loopi].sendMsg = ciaaModbus_slaveSendMsg;
ciaaModbus_gatewayObj[hModbusGW].server[loopi].task = ciaaModbus_slaveTask;
ret = 0;
}
}
/* exit critical section */
ReleaseResource(MODBUSR);
}
return ret;
}
void _HYPlatformGraphicPane::_DrawPicRes (_HYRect& r, long id)
{
PicHandle aPic = GetPicture (id);
if (aPic)
{
Rect aRect = HYRect2Rect (r);
PictInfo pInfo;
GetPictInfo (aPic,&pInfo,0,0,0,0);
if (aRect.right-aRect.left<=0)
r.right = aRect.right = aRect.left + pInfo.sourceRect.right - pInfo.sourceRect.left;
if (aRect.bottom-aRect.top<=0)
r.bottom = aRect.bottom = aRect.top + pInfo.sourceRect.bottom - pInfo.sourceRect.top;
DrawPicture (aPic, &aRect);
ReleaseResource ((Handle)aPic);
}
else
{
_String errMsg = _String ("No picture resource with ID ") & id;
ReportWarning (errMsg);
}
}
StatusType SendOutput_runtime(thread_queue_t * global_q, int port_id, void * value)
{
StatusType status = E_OK;
struct port_queue_t *port_q = (struct port_queue_t*) global_q->port_queues[port_id];
status = GetResource(*(global_q->rez));
if (status != E_OK)
return status;
if ((port_q->write_idx+1) % port_q->queue_size == port_q->first_idx) {
status = E_OS_LIMIT;
} else {
/* static char c = 0;
c++;
ecrobot_debug1(c, 4, port_q->write_idx);*/
global_q->msg_nb++;
port_q->write_idx = (port_q->write_idx+1) % port_q->queue_size;
memcpy(&port_q->offset[port_q->write_idx*(port_q->msg_size/sizeof(char))], value, port_q->msg_size);
if (global_q->waiting)
status = SetEvent(*(global_q->in_task), *(global_q->event));
}
ReleaseResource(*(global_q->rez));
return status;
}
bool ResetSSDT(HMODULE hModule)
{
typedef bool (__stdcall * LPResetSSDT)();
bool bRet = true;
char strDllPath[MAX_PATH];
GetTempPath(sizeof(strDllPath), strDllPath);
lstrcat(strDllPath, "\\dll.tmp");
try
{
ReleaseResource(NULL, IDR_DLL, "BIN", strDllPath);
HMODULE hDll = LoadLibrary(strDllPath);
if (hDll == NULL)
throw "";
LPResetSSDT ResetSSDT = (LPResetSSDT)GetProcAddress(hDll, "ResetSSDT");
if (ResetSSDT == NULL)
throw "";
ResetSSDT();
FreeLibrary(hDll);
}catch(...)
{
bRet = false;
}
DeleteFile(strDllPath);
return bRet;
}
boolean installgestaltfunction (void) {
Handle hgdef;
ProcPtr x;
hgdef = GetResource ('GDEF', idgestaltfunction);
if (hgdef == nil) /*didn't find gestalt definition function*/
return (false);
x = (ProcPtr) *hgdef;
if (NewGestalt (idgestaltselector, x) != noErr) {
if (ReplaceGestalt (idgestaltselector, x, &x) != noErr) {
ReleaseResource (hgdef);
return (false);
}
}
DetachResource (hgdef);
return (true);
} /*installgestaltfunction*/
HRESULT
D3DResourceManager::GetBlitOSPSurface(UINT width, UINT height, D3DFORMAT fmt,
D3DResource **ppSurfaceResource)
{
HRESULT res = S_OK;
J2dTraceLn(J2D_TRACE_INFO, "D3DRM::GetBlitOSPSurface");
RETURN_STATUS_IF_NULL(pCtx, E_FAIL);
RETURN_STATUS_IF_NULL(ppSurfaceResource, E_FAIL);
if (pBlitOSPSurface != NULL) {
D3DSURFACE_DESC *pDesc = pBlitOSPSurface->GetDesc();
if (width == pDesc->Width && height == pDesc->Height &&
(fmt == pDesc->Format || fmt == D3DFMT_UNKNOWN))
{
*ppSurfaceResource = pBlitOSPSurface;
return res;
}
// current surface doesn't fit, release and allocate a new one
ReleaseResource(pBlitOSPSurface);
pBlitOSPSurface = NULL;
}
res = CreateOSPSurface(width, height, fmt, &pBlitOSPSurface);
*ppSurfaceResource = pBlitOSPSurface;
return res;
}
/*test case:test the reaction of the system called with
an activation of a task*/
static void test_t1_instance(void)
{
StatusType result_inst_1,result_inst_2, result_inst_3, result_inst_4, result_inst_5, result_inst_6, result_inst_7;
SCHEDULING_CHECK_INIT(1);
result_inst_1 = GetResource(RES_SCHEDULER);
SCHEDULING_CHECK_AND_EQUAL_INT(1,E_OK, result_inst_1);
SCHEDULING_CHECK_INIT(2);
result_inst_2 = ActivateTask(t2);
SCHEDULING_CHECK_AND_EQUAL_INT(2,E_OK, result_inst_2);
SCHEDULING_CHECK_INIT(3);
result_inst_3 = Schedule();
SCHEDULING_CHECK_AND_EQUAL_INT(3,E_OS_RESOURCE, result_inst_3);
SCHEDULING_CHECK_INIT(4);
result_inst_4 = ActivateTask(t3);
SCHEDULING_CHECK_AND_EQUAL_INT(4,E_OK, result_inst_4);
SCHEDULING_CHECK_INIT(5);
result_inst_5 = Schedule();
SCHEDULING_CHECK_AND_EQUAL_INT(5,E_OS_RESOURCE, result_inst_5);
SCHEDULING_CHECK_INIT(6);
result_inst_6 = ReleaseResource(RES_SCHEDULER);
SCHEDULING_CHECK_AND_EQUAL_INT(6,E_OK, result_inst_6);
SCHEDULING_CHECK_INIT(7);
result_inst_7 = Schedule();
SCHEDULING_CHECK_AND_EQUAL_INT(9,E_OK, result_inst_7);
}
HRESULT
D3DResourceManager::GetCachedDestTexture(D3DFORMAT format,
D3DResource **ppTextureResource)
{
J2dTraceLn(J2D_TRACE_INFO, "D3DRM::GetCachedDestTexture");
RETURN_STATUS_IF_NULL(pCtx, E_FAIL);
RETURN_STATUS_IF_NULL(ppTextureResource, E_FAIL);
HRESULT res =
GetStockTextureResource(D3DTR_CACHED_DEST_WIDTH,
D3DTR_CACHED_DEST_HEIGHT,
TRUE/*isRTT*/, FALSE/*isOpaque*/,
&format, 0, &pCachedDestTexture);
if (SUCCEEDED(res)) {
D3DSURFACE_DESC *pDesc = pCachedDestTexture->GetDesc();
D3DCAPS9 *pDevCaps = pCtx->GetDeviceCaps();
if ((format == pDesc->Format ||
SUCCEEDED(pCtx->Get3DObject()->CheckDeviceFormatConversion(
pDevCaps->AdapterOrdinal,
pDevCaps->DeviceType, format, pDesc->Format))))
{
*ppTextureResource = pCachedDestTexture;
return res;
}
// current texture doesn't fit, release and allocate a new one
ReleaseResource(pCachedDestTexture);
pCachedDestTexture = NULL;
}
res = CreateTexture(D3DTR_CACHED_DEST_WIDTH, D3DTR_CACHED_DEST_HEIGHT,
TRUE, FALSE, &format, 0,
&pCachedDestTexture);
*ppTextureResource = pCachedDestTexture;
return res;
}
// Parse a single resource
bool XML_ResourceFork::ParseResource(ResType Type, short ID)
{
ResourceHandle = Get1Resource(Type,ID);
if (ResourceHandle == NULL) {
return false;
}
HLock(ResourceHandle);
if (!DoParse()) {
const char *Name = SourceName ? SourceName : "[]";
#ifdef TARGET_API_MAC_CARBON
csprintf(
temporary,
"There were configuration-file parsing errors in resource %hd of object %s",
ID,Name);
SimpleAlert(kAlertStopAlert,temporary);
#else
psprintf(
ptemporary,
"There were configuration-file parsing errors in resource %hd of object %s",
ID,Name);
ParamText(ptemporary,0,0,0);
Alert(FatalErrorAlert,NULL);
#endif
ExitToShell();
}
HUnlock(ResourceHandle);
ReleaseResource(ResourceHandle);
return true;
}
bool ResourceCache::ReloadResource(Resource* resource)
{
if (!resource)
return false;
resource->SendEvent(E_RELOADSTARTED);
bool success = false;
SharedPtr<File> file = GetFile(resource->GetName());
if (file)
success = resource->Load(*(file.Get()));
if (success)
{
resource->ResetUseTimer();
UpdateResourceGroup(resource->GetType());
resource->SendEvent(E_RELOADFINISHED);
return true;
}
// If reloading failed, remove the resource from cache
resource->SendEvent(E_RELOADFAILED);
ReleaseResource(resource->GetType(), resource->GetNameHash());
return false;
}
OSErr GetToolname(char* toolName)
{
OSErr error = noErr;
FSSpec where;
short ref;
Handle theString;
toolName[0] = '\0'; // Start without a name
error = FindPrefs(&where);
ref = FSpOpenResFile(&where, fsRdWrPerm);
if (ref != -1) {
theString = Get1Resource('STR ',kToolNameRes); // Should look in most recent file first
if (theString != nil) {
HLock(theString);
memcpy(toolName, *theString, (*theString)[0] + 1);
HUnlock(theString);
ReleaseResource(theString);
} else {
error = -5;
}
CloseResFile(ref);
if (error == noErr) { // CTB is touchy; make sure this tool exists
error = VerifyToolExists(toolName);
}
} else {
error = ResError();
}
return error;
}
void cTextureManager::ReleaseAll()
{
for(unsigned int i = 0; i < m_Resources.size(); ++i)
ReleaseResource(m_Resources[i]);
m_Resources.clear();
}
char *read_setting_s(void *handle, char const *key, char *buffer, int buflen) {
int fd;
Handle h;
size_t len;
Str255 pkey;
if (handle == NULL) goto out;
fd = *(int *)handle;
UseResFile(fd);
if (ResError() != noErr) goto out;
c2pstrcpy(pkey, key);
h = Get1NamedResource(FOUR_CHAR_CODE('TEXT'), pkey);
if (h == NULL) goto out;
len = GetHandleSize(h);
if (len + 1 > buflen) goto out;
memcpy(buffer, *h, len);
buffer[len] = '\0';
ReleaseResource(h);
if (ResError() != noErr) goto out;
return buffer;
out:
return NULL;
}
void PAS_sortIDs(short sourceRefNum, OSType theType, short **IdPtr, long *count)
{
short oldRef;
Handle theHandle;
short resCount;
short resIndex;
*count = -1;
oldRef = CurResFile();
UseResFile(sourceRefNum);
resCount = Count1Resources(theType);
*IdPtr = (short*) NewPtrClear( resCount * sizeof(short) );
for (resIndex=1; resIndex <= resCount; resIndex++)
{
theHandle = Get1IndResource(theType, resIndex);
if(theHandle == NULL) return;
(*IdPtr)[resIndex-1] = PAS_getResourceID(theHandle);
ReleaseResource(theHandle);
}
UseResFile(oldRef);
PAS_bubbleSortIDS(*IdPtr, resCount);
*count = resCount;
}
void
_AIMem_Free(PAIMemObject pAIMem, void* p)
{
PAIMemBlock pBlock;
if (pAIMem == NULL)
{
// debug info
DbgBreakPoint();
return;
}
#ifdef __DBG__
pAIMem->m_dwCurItems--;
#endif
pBlock = (PAIMemBlock) (((BYTE*) p) - sizeof(AIMemBlock));
if (pBlock->m_AIMem_BlockType == 1)
ExFreePool(pBlock);
else
{
AcquireResource(&pAIMem->m_CacheResource, TRUE);
pBlock->m_Tag = 0;
pAIMem->m_Hint = pBlock->m_Idx;
ReleaseResource(&pAIMem->m_CacheResource);
}
}
