C++ crWarning函数代码示例

DECLEXPORT(BOOL) WINAPI wglSwapLayerBuffers_prox( HDC hdc, UINT planes )
{
    CR_DDI_PROLOGUE();
    if (planes == WGL_SWAP_MAIN_PLANE)
    {
        return wglSwapBuffers_prox(hdc);
    }
    else
    {
        crWarning( "wglSwapLayerBuffers: unsupported" );
        return 0;
    }
}

int renderspuIatPatcherPatchEntry(void *pvEntry, void *pvValue, void **ppvOldVal)
{
    void **ppfn = (void**)pvEntry;
    DWORD dwOldProtect = 0;

    if (!VirtualProtect(pvEntry, sizeof (pvEntry), PAGE_READWRITE, &dwOldProtect))
    {
        crWarning("VirtualProtect 1 failed, %d", GetLastError());
        return VERR_ACCESS_DENIED;
    }

    if (ppvOldVal)
        *ppvOldVal = *ppfn;
    *ppfn = pvValue;

    if (!VirtualProtect(pvEntry, sizeof (pvEntry), dwOldProtect, &dwOldProtect))
    {
        crWarning("VirtualProtect 2 failed, %d.. ignoring", GetLastError());
    }

    return VINF_SUCCESS;
}

void crServerRedirMuralFBO(CRMuralInfo *mural, GLboolean redir)
{
    if (redir)
    {
        if (!crServerSupportRedirMuralFBO())
        {
            crWarning("FBO not supported, can't redirect window output");
            return;
        }

        cr_server.head_spu->dispatch_table.WindowShow(mural->spuWindow, GL_FALSE);

        if (mural->idFBO==0)
        {
            crServerCreateMuralFBO(mural);
        }

        if (!crStateGetCurrent()->framebufferobject.drawFB)
        {
            cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, mural->idFBO);
        }
        if (!crStateGetCurrent()->framebufferobject.readFB)
        {
            cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_READ_FRAMEBUFFER, mural->idFBO);
        }

        crStateGetCurrent()->buffer.width = 0;
        crStateGetCurrent()->buffer.height = 0;
    }
    else
    {
        cr_server.head_spu->dispatch_table.WindowShow(mural->spuWindow, mural->bVisible);

        if (mural->bUseFBO && crServerSupportRedirMuralFBO())
        {
            if (!crStateGetCurrent()->framebufferobject.drawFB)
            {
                cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, 0);
            }
            if (!crStateGetCurrent()->framebufferobject.readFB)
            {
                cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_READ_FRAMEBUFFER, 0);
            }
        }

        crStateGetCurrent()->buffer.width = mural->width;
        crStateGetCurrent()->buffer.height = mural->height;
    }

    mural->bUseFBO = redir;
}

int CrBltMuralSetCurrent(PCR_BLITTER pBlitter, const CR_BLITTER_WINDOW *pMural)
{
    if (pMural)
    {
        if (!memcmp(&pBlitter->CurrentMural, pMural, sizeof (pBlitter->CurrentMural)))
            return VINF_SUCCESS;
        memcpy(&pBlitter->CurrentMural, pMural, sizeof (pBlitter->CurrentMural));
    }
    else
    {
        if (CrBltIsEntered(pBlitter))
        {
            crWarning("can not set null mural for entered bleater");
            return VERR_INVALID_STATE;
        }
        if (!pBlitter->CurrentMural.Base.id)
            return VINF_SUCCESS;
        pBlitter->CurrentMural.Base.id = 0;
    }

    pBlitter->Flags.CurrentMuralChanged = 1;

    if (!CrBltIsEntered(pBlitter))
        return VINF_SUCCESS;
    else if (!pBlitter->CtxInfo.Base.id)
    {
        crWarning("setting current mural for entered no-context blitter");
        return VERR_INVALID_STATE;
    }

    crWarning("changing mural for entered blitter, is is somewhat expected?");

    pBlitter->pDispatch->Flush();

    pBlitter->pDispatch->MakeCurrent(pMural->Base.id, pBlitter->i32MakeCurrentUserData, pBlitter->CtxInfo.Base.id);

    return VINF_SUCCESS;
}

void CrBltBlitTexMural(PCR_BLITTER pBlitter, bool fBb, const VBOXVR_TEXTURE *pSrc, const RTRECT *paSrcRects, const RTRECT *paDstRects, uint32_t cRects, uint32_t fFlags)
{
    if (!CrBltIsEntered(pBlitter))
    {
        crWarning("CrBltBlitTexMural: blitter not entered");
        return;
    }

    RTRECTSIZE DstSize = {pBlitter->CurrentMural.width, pBlitter->CurrentMural.height};

    pBlitter->pDispatch->BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, 0);

    crBltBlitTexBuf(pBlitter, pSrc, paSrcRects, fBb ? GL_BACK : GL_FRONT, &DstSize, paDstRects, cRects, fFlags);
}

int main( int argc, char *argv[] )
{
	CRConnection *conn = crMothershipConnect( );
	if (conn)
	{
		crMothershipSendString( conn, NULL, "reset" );
		crMothershipDisconnect( conn );
	}
	else
	{
		crWarning( "\n\nNO MOTHERSHIP RUNNING?!\n\n");
	}
	return 0;
}

/**
 * Transform the given object-space bounds to window coordinates and
 * update the window's bounding box union.
 */
static void
AccumulateObjectBBox(const GLfloat * bbox)
{
	GLfloat proj[16], modl[16], viewport[4];
	GLfloat x1, y1, z1, x2, y2, z2;
	CRrecti winBox;
	GET_CONTEXT(context);
	WindowInfo *window = context->currentWindow;

	x1 = bbox[0];
	y1 = bbox[1];
	z1 = bbox[2];
	x2 = bbox[3];
	y2 = bbox[4];
	z2 = bbox[5];

	/* transform by modelview and projection */
	binaryswap_spu.super.GetFloatv(GL_PROJECTION_MATRIX, proj);
	binaryswap_spu.super.GetFloatv(GL_MODELVIEW_MATRIX, modl);
    
	crProjectBBox(modl, proj, &x1, &y1, &z1, &x2, &y2, &z2);

	/* Sanity check... */
	if (x2 < x1 || y2 < y1 || z2 < z1)
	{
		crWarning("Damnit!!!!, we screwed up the clipping somehow...");
		return;
	}
    
	/* adjust depth for alpha composite */
	binaryswap_spu.depth = z1;

	/* map to window coords */
	binaryswap_spu.super.GetFloatv(GL_VIEWPORT, viewport);
	winBox.x1 = (int) ((x1 + 1.0f) * (viewport[2] * 0.5F) + viewport[0]);
	winBox.y1 = (int) ((y1 + 1.0f) * (viewport[3] * 0.5F) + viewport[1]);
	winBox.x2 = (int) ((x2 + 1.0f) * (viewport[2] * 0.5F) + viewport[0]);
	winBox.y2 = (int) ((y2 + 1.0f) * (viewport[3] * 0.5F) + viewport[1]);

	if (window->bboxUnion.x1 == 0 && window->bboxUnion.x2 == 0)
	{
		/* this is the first box */
		window->bboxUnion = winBox;
	}
	else
	{
		/* compute union of current screen bbox and this one */
		crRectiUnion(&window->bboxUnion, &window->bboxUnion, &winBox);
	}
}

VBOXBLITTERDECL(void) CrBltImgFree(PCR_BLITTER pBlitter, CR_BLITTER_IMG *pDst)
{
    if (!CrBltIsEntered(pBlitter))
    {
        crWarning("CrBltImgFree: blitter not entered");
        return;
    }

    if (pDst->pvData)
    {
        RTMemFree(pDst->pvData);
        pDst->pvData = NULL;
    }
}

BOOL APIENTRY DrvSwapLayerBuffers(HDC hdc, UINT fuPlanes)
{
    CR_DDI_PROLOGUE();
    if (fuPlanes == 1)
    {
        return DrvSwapBuffers(hdc);
    }
    else
    {
        crWarning( "DrvSwapLayerBuffers: unsupported" );
        CRASSERT(false);
        return 0;
    }
}

static void
PushMatrix(void)
{
	if (CurrentStack->depth < CurrentStack->maxDepth) {
		/* copy matrix */
		*(CurrentStack->top + 1) = *(CurrentStack->top);
		/* Move the stack pointer */
		CurrentStack->depth++;
		CurrentStack->top = CurrentStack->stack + CurrentStack->depth;
	}
	else {
		crWarning("Stack overflow in dlm_bbox.c");
	}
}

void DLM_APIENTRY crDLMListBase( GLuint base )
{
	CRDLMContextState *listState = CURRENT_STATE();

	if (listState == NULL)
	{
		crWarning
			("DLM error: ListBase(%d) called with no current state (%s line %d)\n",
			 (int) base, __FILE__, __LINE__);
		return;
	}

	listState->listBase = base;
}

GLuint DLM_APIENTRY crDLMGenLists(GLsizei range)
{
	CRDLMContextState *listState = CURRENT_STATE();

	if (listState == NULL)
	{
		crWarning
			("DLM error: GenLists(%d) called with no current state (%s line %d)\n",
			 (int) range, __FILE__, __LINE__);
		return 0;
	}

	return crHashtableAllocKeys(listState->dlm->displayLists, range);
}

static void RENDER_APIENTRY
renderspuDestroyContext( GLint ctx )
{
    ContextInfo *context, *curCtx;

    CRASSERT(ctx);

    if (ctx == CR_RENDER_DEFAULT_CONTEXT_ID)
    {
        crWarning("request to destroy a default context, ignoring");
        return;
    }

    context = (ContextInfo *) crHashtableSearch(render_spu.contextTable, ctx);
    CRASSERT(context);
    {
        if (!context)
        {
            crWarning("request to delete inexistent context");
            return;
        }
    }

    curCtx = GET_CONTEXT_VAL();
    CRASSERT(curCtx);
    if (curCtx == context)
    {
        renderspuMakeCurrent( CR_RENDER_DEFAULT_WINDOW_ID, 0, CR_RENDER_DEFAULT_CONTEXT_ID );
        curCtx = GET_CONTEXT_VAL();
		Assert(curCtx);
		Assert(curCtx != context);
    }

    crHashtableDelete(render_spu.contextTable, ctx, NULL);

    renderspuContextMarkDeletedAndRelease(context);
}

void CR_APIENTRY glSeparableFilter2D( GLenum target, GLenum internalformat, GLsizei width,
				      GLsizei height, GLenum format, GLenum type,
				      const GLvoid *row, const GLvoid *column )
#endif
{
	(void) target;
	(void) internalformat;
	(void) width;
	(void) height;
	(void) format;
	(void) type;
	(void) row;
	(void) column;
	crWarning("glSeparableFilter2D not implemented by VMGL/Chromium");
}

CRConnection *crMothershipConnect( void )
{
	const char *mother_server;

	crNetInit( NULL, NULL );

	mother_server = crGetenv( "CRMOTHERSHIP" );
	if (!mother_server)
	{
		crWarning( "Couldn't find the CRMOTHERSHIP environment variable, defaulting to localhost" );
		mother_server = "localhost";
	}

	return crNetConnectToServer( mother_server, DEFAULT_MOTHERSHIP_PORT, 8096, 0 );
}