/******************************************************************************
* 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;
}
