/****************************************************************************** * is_valid_handle * * Tests if handle is valid given the specified handle table * * PARAMS * lpTable [I] Pointer to the handle table, with respect to which the handle's * validness is tested. * handle [I] The handle tested for validness. * dwType [I] A magic value that identifies the referenced object's type. * * RETURNS * non zero, if handle is valid. * zero, if handle is not valid. */ int is_valid_handle(HANDLETABLE *lpTable, unsigned int handle, DWORD dwType) { unsigned int index = HANDLE2INDEX(handle); int ret = 0; TRACE("(lpTable=%p, handle=%d)\n", lpTable, handle); EnterCriticalSection(&lpTable->mutex); /* We don't use zero handle values */ if (!handle) goto exit; /* Check for index out of table bounds */ if (index >= lpTable->iEntries) goto exit; /* Check if this handle is currently allocated */ if (!lpTable->paEntries[index].pObject) goto exit; /* Check if this handle references an object of the correct type. */ if (lpTable->paEntries[index].pObject->dwType != dwType) goto exit; ret = 1; exit: LeaveCriticalSection(&lpTable->mutex); return ret; }
/****************************************************************************** * release_handle * * Releases resources occupied by the specified handle in the given table. * The reference count of the handled object is decremented. If it becomes * zero and if the 'destructor' function pointer member is non NULL, the * destructor function will be called. Note that release_handle does not * release resources other than the handle itself. If this is wanted, do it * in the destructor function. * * PARAMS * lpTable [I] Pointer to the handle table, from which a handle is to be * released. * handle [I] The handle, which is to be released * dwType [I] Identifier for the type of the object, for which a handle is * to be released. * * RETURNS * non zero, if successful * zero, if not successful (invalid handle) */ int release_handle(HANDLETABLE *lpTable, unsigned int handle, DWORD dwType) { unsigned int index = HANDLE2INDEX(handle); OBJECTHDR *pObject; int ret = 0; TRACE("(lpTable=%p, hande=%d)\n", lpTable, handle); EnterCriticalSection(&lpTable->mutex); if (!is_valid_handle(lpTable, handle, dwType)) goto exit; pObject = lpTable->paEntries[index].pObject; if (InterlockedDecrement(&pObject->refcount) == 0) { TRACE("destroying handle %d\n", handle); if (pObject->destructor) pObject->destructor(pObject); } lpTable->paEntries[index].pObject = NULL; lpTable->paEntries[index].iNextFree = lpTable->iFirstFree; lpTable->iFirstFree = index; ret = 1; exit: LeaveCriticalSection(&lpTable->mutex); return ret; }
bool CGlow::paint() { if(variables[2].bGet() || !variables[0].bGet()) return true; for(auto &glowObj : pGlowObjectManger->glowObjects) { if(glowObj.hEntity != -1) { CEntity<> ent{HANDLE2INDEX(glowObj.hEntity)}; if(ent.isNull()) continue; if(ent->IsDormant()) continue; //Color c = healthToColor(ent.get<int>(gEntVars.iHealth), getMaxHealth(ent)); //glowObj.r = c.r() / 255.0f; // red //glowObj.g = c.g() / 255.0f; // green //glowObj.b = c.b() / 255.0f; // blue //glowObj.a = 1.0f; // 100% alpha //Log::Console("team %d: %f %f %f", ent.get<int>(gEntVars.iTeam), glowObj.r, glowObj.g, glowObj.b); } } return true; }
/****************************************************************************** * lookup_handle * * Returns the object identified by the handle in the given handle table * * PARAMS * lpTable [I] Pointer to the handle table, in which the handle is looked up. * handle [I] The handle, which is to be looked up * lplpObject [O] Pointer to the variable, into which the pointer to the * object looked up is copied. * RETURNS * non zero, if successful * zero, if not successful (invalid handle) */ int lookup_handle(HANDLETABLE *lpTable, unsigned int handle, DWORD dwType, OBJECTHDR **lplpObject) { int ret = 0; TRACE("(lpTable=%p, handle=%d, lplpObject=%p)\n", lpTable, handle, lplpObject); EnterCriticalSection(&lpTable->mutex); if (!is_valid_handle(lpTable, handle, dwType)) { *lplpObject = NULL; goto exit; } *lplpObject = lpTable->paEntries[HANDLE2INDEX(handle)].pObject; ret = 1; exit: LeaveCriticalSection(&lpTable->mutex); return ret; }