server_misc.c@ 41109

最後變更在這個檔案從41109是 41109,由 vboxsync 提交於 13 年前
crOpenGL,wined3d,wddm: second part of fixing resource leakage, basics for cr commands submission from r0 miniport driver (for r0 visible region reporting, WPF 3D rendering fixes w/o Aero, etc.)
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Id`
檔案大小: 22.4 KB

行
1	/* Copyright (c) 2001, Stanford University
2	* All rights reserved
3	*
4	* See the file LICENSE.txt for information on redistributing this software.
5	*/
6
7	#include "server_dispatch.h"
8	#include "server.h"
9	#include "cr_error.h"
10	#include "cr_mem.h"
11	#include "cr_string.h"
12	#include "cr_pixeldata.h"
13
14	void SERVER_DISPATCH_APIENTRY crServerDispatchSelectBuffer( GLsizei size, GLuint *buffer )
15	{
16	(void) size;
17	(void) buffer;
18	crError( "Unsupported network glSelectBuffer call." );
19	}
20
21	void SERVER_DISPATCH_APIENTRY crServerDispatchGetChromiumParametervCR(GLenum target, GLuint index, GLenum type, GLsizei count, GLvoid *values)
22	{
23	GLubyte local_storage[4096];
24	GLint bytes = 0;
25
26	switch (type) {
27	case GL_BYTE:
28	case GL_UNSIGNED_BYTE:
29	bytes = count * sizeof(GLbyte);
30	break;
31	case GL_SHORT:
32	case GL_UNSIGNED_SHORT:
33	bytes = count * sizeof(GLshort);
34	break;
35	case GL_INT:
36	case GL_UNSIGNED_INT:
37	bytes = count * sizeof(GLint);
38	break;
39	case GL_FLOAT:
40	bytes = count * sizeof(GLfloat);
41	break;
42	case GL_DOUBLE:
43	bytes = count * sizeof(GLdouble);
44	break;
45	default:
46	crError("Bad type in crServerDispatchGetChromiumParametervCR");
47	}
48
49	CRASSERT(bytes >= 0);
50	CRASSERT(bytes < 4096);
51
52	cr_server.head_spu->dispatch_table.GetChromiumParametervCR( target, index, type, count, local_storage );
53
54	crServerReturnValue( local_storage, bytes );
55	}
56
57	void SERVER_DISPATCH_APIENTRY crServerDispatchChromiumParametervCR(GLenum target, GLenum type, GLsizei count, const GLvoid *values)
58	{
59	CRMuralInfo *mural = cr_server.curClient->currentMural;
60	static int gather_connect_count = 0;
61
62	switch (target) {
63	case GL_SET_MAX_VIEWPORT_CR:
64	{
65	GLint maxDims = (GLint )values;
66	cr_server.limits.maxViewportDims[0] = maxDims[0];
67	cr_server.limits.maxViewportDims[1] = maxDims[1];
68	}
69	break;
70
71	case GL_TILE_INFO_CR:
72	/* message from tilesort SPU to set new tile bounds */
73	{
74	GLint numTiles, muralWidth, muralHeight, server, tiles;
75	GLint *tileBounds;
76	CRASSERT(count >= 4);
77	CRASSERT((count - 4) % 4 == 0); /* must be multiple of four */
78	CRASSERT(type == GL_INT);
79	numTiles = (count - 4) / 4;
80	tileBounds = (GLint *) values;
81	server = tileBounds[0];
82	muralWidth = tileBounds[1];
83	muralHeight = tileBounds[2];
84	tiles = tileBounds[3];
85	CRASSERT(tiles == numTiles);
86	tileBounds += 4; /* skip over header values */
87	/*crServerNewMuralTiling(mural, muralWidth, muralHeight, numTiles, tileBounds);
88	mural->viewportValidated = GL_FALSE;*/
89	}
90	break;
91
92	case GL_GATHER_DRAWPIXELS_CR:
93	if (cr_server.only_swap_once && cr_server.curClient != cr_server.clients[0])
94	break;
95	cr_server.head_spu->dispatch_table.ChromiumParametervCR( target, type, count, values );
96	break;
97
98	case GL_GATHER_CONNECT_CR:
99	/*
100	* We want the last connect to go through,
101	* otherwise we might deadlock in CheckWindowSize()
102	* in the readback spu
103	*/
104	gather_connect_count++;
105	if (cr_server.only_swap_once && (gather_connect_count != cr_server.numClients))
106	{
107	break;
108	}
109	cr_server.head_spu->dispatch_table.ChromiumParametervCR( target, type, count, values );
110	gather_connect_count = 0;
111	break;
112
113	case GL_SERVER_VIEW_MATRIX_CR:
114	/* Set this server's view matrix which will get premultiplied onto the
115	* modelview matrix. For non-planar tilesort and stereo.
116	*/
117	CRASSERT(count == 18);
118	CRASSERT(type == GL_FLOAT);
119	/* values[0] is the server index. Ignored here but used in tilesort SPU */
120	/* values[1] is the left/right eye index (0 or 1) */
121	{
122	const GLfloat v = (const GLfloat ) values;
123	const int eye = v[1] == 0.0 ? 0 : 1;
124	crMatrixInitFromFloats(&cr_server.viewMatrix[eye], v + 2);
125
126	crDebug("Got GL_SERVER_VIEW_MATRIX_CR:\n"
127	" %f %f %f %f\n"
128	" %f %f %f %f\n"
129	" %f %f %f %f\n"
130	" %f %f %f %f",
131	cr_server.viewMatrix[eye].m00,
132	cr_server.viewMatrix[eye].m10,
133	cr_server.viewMatrix[eye].m20,
134	cr_server.viewMatrix[eye].m30,
135	cr_server.viewMatrix[eye].m01,
136	cr_server.viewMatrix[eye].m11,
137	cr_server.viewMatrix[eye].m21,
138	cr_server.viewMatrix[eye].m31,
139	cr_server.viewMatrix[eye].m02,
140	cr_server.viewMatrix[eye].m12,
141	cr_server.viewMatrix[eye].m22,
142	cr_server.viewMatrix[eye].m32,
143	cr_server.viewMatrix[eye].m03,
144	cr_server.viewMatrix[eye].m13,
145	cr_server.viewMatrix[eye].m23,
146	cr_server.viewMatrix[eye].m33);
147	}
148	cr_server.viewOverride = GL_TRUE;
149	break;
150
151	case GL_SERVER_PROJECTION_MATRIX_CR:
152	/* Set this server's projection matrix which will get replace the user's
153	* projection matrix. For non-planar tilesort and stereo.
154	*/
155	CRASSERT(count == 18);
156	CRASSERT(type == GL_FLOAT);
157	/* values[0] is the server index. Ignored here but used in tilesort SPU */
158	/* values[1] is the left/right eye index (0 or 1) */
159	{
160	const GLfloat v = (const GLfloat ) values;
161	const int eye = v[1] == 0.0 ? 0 : 1;
162	crMatrixInitFromFloats(&cr_server.projectionMatrix[eye], v + 2);
163
164	crDebug("Got GL_SERVER_PROJECTION_MATRIX_CR:\n"
165	" %f %f %f %f\n"
166	" %f %f %f %f\n"
167	" %f %f %f %f\n"
168	" %f %f %f %f",
169	cr_server.projectionMatrix[eye].m00,
170	cr_server.projectionMatrix[eye].m10,
171	cr_server.projectionMatrix[eye].m20,
172	cr_server.projectionMatrix[eye].m30,
173	cr_server.projectionMatrix[eye].m01,
174	cr_server.projectionMatrix[eye].m11,
175	cr_server.projectionMatrix[eye].m21,
176	cr_server.projectionMatrix[eye].m31,
177	cr_server.projectionMatrix[eye].m02,
178	cr_server.projectionMatrix[eye].m12,
179	cr_server.projectionMatrix[eye].m22,
180	cr_server.projectionMatrix[eye].m32,
181	cr_server.projectionMatrix[eye].m03,
182	cr_server.projectionMatrix[eye].m13,
183	cr_server.projectionMatrix[eye].m23,
184	cr_server.projectionMatrix[eye].m33);
185
186	if (cr_server.projectionMatrix[eye].m33 == 0.0f) {
187	float x = cr_server.projectionMatrix[eye].m00;
188	float y = cr_server.projectionMatrix[eye].m11;
189	float a = cr_server.projectionMatrix[eye].m20;
190	float b = cr_server.projectionMatrix[eye].m21;
191	float c = cr_server.projectionMatrix[eye].m22;
192	float d = cr_server.projectionMatrix[eye].m32;
193	float znear = -d / (1.0f - c);
194	float zfar = (c - 1.0f) * znear / (c + 1.0f);
195	float left = znear * (a - 1.0f) / x;
196	float right = 2.0f * znear / x + left;
197	float bottom = znear * (b - 1.0f) / y;
198	float top = 2.0f * znear / y + bottom;
199	crDebug("Frustum: left, right, bottom, top, near, far: %f, %f, %f, %f, %f, %f", left, right, bottom, top, znear, zfar);
200	}
201	else {
202	/* Todo: Add debug output for orthographic projection*/
203	}
204
205	}
206	cr_server.projectionOverride = GL_TRUE;
207	break;
208
209	default:
210	/* Pass the parameter info to the head SPU */
211	cr_server.head_spu->dispatch_table.ChromiumParametervCR( target, type, count, values );
212	break;
213	}
214	}
215
216
217	void SERVER_DISPATCH_APIENTRY crServerDispatchChromiumParameteriCR(GLenum target, GLint value)
218	{
219	switch (target) {
220	case GL_SHARE_CONTEXT_RESOURCES_CR:
221	crStateShareContext(value);
222	break;
223	case GL_RCUSAGE_TEXTURE_SET_CR:
224	crStateSetTextureUsed(value, GL_TRUE);
225	break;
226	case GL_RCUSAGE_TEXTURE_CLEAR_CR:
227	crStateSetTextureUsed(value, GL_FALSE);
228	break;
229	case GL_SHARED_DISPLAY_LISTS_CR:
230	cr_server.sharedDisplayLists = value;
231	break;
232	case GL_SHARED_TEXTURE_OBJECTS_CR:
233	cr_server.sharedTextureObjects = value;
234	break;
235	case GL_SHARED_PROGRAMS_CR:
236	cr_server.sharedPrograms = value;
237	break;
238	case GL_SERVER_CURRENT_EYE_CR:
239	cr_server.currentEye = value ? 1 : 0;
240	break;
241	default:
242	/* Pass the parameter info to the head SPU */
243	cr_server.head_spu->dispatch_table.ChromiumParameteriCR( target, value );
244	}
245	}
246
247
248	void SERVER_DISPATCH_APIENTRY crServerDispatchChromiumParameterfCR(GLenum target, GLfloat value)
249	{
250	switch (target) {
251	case GL_SHARED_DISPLAY_LISTS_CR:
252	cr_server.sharedDisplayLists = (int) value;
253	break;
254	case GL_SHARED_TEXTURE_OBJECTS_CR:
255	cr_server.sharedTextureObjects = (int) value;
256	break;
257	case GL_SHARED_PROGRAMS_CR:
258	cr_server.sharedPrograms = (int) value;
259	break;
260	default:
261	/* Pass the parameter info to the head SPU */
262	cr_server.head_spu->dispatch_table.ChromiumParameterfCR( target, value );
263	}
264	}
265
266	void crServerCreateInfoDeleteCB(void *data)
267	{
268	CRCreateInfo_t pCreateInfo = (CRCreateInfo_t ) data;
269	if (pCreateInfo->pszDpyName)
270	crFree(pCreateInfo->pszDpyName);
271	crFree(pCreateInfo);
272	}
273
274	GLint crServerGenerateID(GLint *pCounter)
275	{
276	return (*pCounter)++;
277	}
278
279	/#define CR_DUMP_BLITS/
280
281	#ifdef CR_DUMP_BLITS
282	static int blitnum=0;
283	static int copynum=0;
284	#endif
285
286	void SERVER_DISPATCH_APIENTRY
287	crServerDispatchCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
288	{
289	/@todo pbo/fbo disabled for now as it's slower, check on other gpus/
290	static int siHavePBO = 0;
291	static int siHaveFBO = 0;
292
293	if ((target!=GL_TEXTURE_2D) \|\| (height>=0))
294	{
295	cr_server.head_spu->dispatch_table.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
296
297	#ifdef CR_DUMP_BLITS
298	{
299	SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
300	void *img;
301	GLint w, h;
302	char fname[200];
303
304	copynum++;
305
306	gl->GetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w);
307	gl->GetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &h);
308
309	img = crAlloc(wh4);
310	CRASSERT(img);
311
312	gl->GetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_BYTE, img);
313	sprintf(fname, "copy_blit%i_copy_%i.tga", blitnum, copynum);
314	crDumpNamedTGA(fname, w, h, img);
315	crFree(img);
316	}
317	#endif
318	}
319	else /* negative height, means we have to Yinvert the source pixels while copying */
320	{
321	SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
322
323	if (siHavePBO<0)
324	{
325	const char ext = (const char)gl->GetString(GL_EXTENSIONS);
326	siHavePBO = crStrstr(ext, "GL_ARB_pixel_buffer_object") ? 1:0;
327	}
328
329	if (siHaveFBO<0)
330	{
331	const char ext = (const char)gl->GetString(GL_EXTENSIONS);
332	siHaveFBO = crStrstr(ext, "GL_EXT_framebuffer_object") ? 1:0;
333	}
334
335	if (siHavePBO==0 && siHaveFBO==0)
336	{
337	#if 1
338	GLint dRow, sRow;
339	for (dRow=yoffset, sRow=y-height-1; dRow<yoffset-height; dRow++, sRow--)
340	{
341	gl->CopyTexSubImage2D(target, level, xoffset, dRow, x, sRow, width, 1);
342	}
343	#else
344	{
345	GLint w, h, i;
346	char img1, img2, sPtr, dPtr;
347	CRContext *ctx = crStateGetCurrent();
348
349	w = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->level[0][level].width;
350	h = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->level[0][level].height;
351
352	img1 = crAlloc(4wh);
353	img2 = crAlloc(4width(-height));
354	CRASSERT(img1 && img2);
355
356	gl->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, -height);
357	gl->GetTexImage(target, level, GL_RGBA, GL_UNSIGNED_BYTE, img1);
358
359	sPtr=img1+4xoffset+4w*yoffset;
360	dPtr=img2+4width(-height-1);
361
362	for (i=0; i<-height; ++i)
363	{
364	crMemcpy(dPtr, sPtr, 4*width);
365	sPtr += 4*w;
366	dPtr -= 4*width;
367	}
368
369	gl->TexSubImage2D(target, level, xoffset, yoffset, width, -height, GL_RGBA, GL_UNSIGNED_BYTE, img2);
370
371	crFree(img1);
372	crFree(img2);
373	}
374	#endif
375	}
376	else if (siHaveFBO==1) /@todo more states to set and restore here/
377	{
378	GLuint tID, fboID;
379	GLenum status;
380	CRContext *ctx = crStateGetCurrent();
381
382	gl->GenTextures(1, &tID);
383	gl->BindTexture(target, tID);
384	gl->CopyTexImage2D(target, level, GL_RGBA, x, y, width, -height, 0);
385	gl->GenFramebuffersEXT(1, &fboID);
386	gl->BindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboID);
387	gl->FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, target,
388	ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->hwid, level);
389	status = gl->CheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
390	if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
391	{
392	crWarning("Framebuffer status 0x%x", status);
393	}
394
395	gl->Enable(target);
396	gl->PushAttrib(GL_VIEWPORT_BIT);
397	gl->Viewport(xoffset, yoffset, width, -height);
398	gl->MatrixMode(GL_PROJECTION);
399	gl->PushMatrix();
400	gl->LoadIdentity();
401	gl->MatrixMode(GL_MODELVIEW);
402	gl->PushMatrix();
403	gl->LoadIdentity();
404
405	gl->Disable(GL_DEPTH_TEST);
406	gl->Disable(GL_CULL_FACE);
407	gl->Disable(GL_STENCIL_TEST);
408	gl->Disable(GL_SCISSOR_TEST);
409
410	gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
411	gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
412	gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
413	gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
414	gl->TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
415
416	gl->Begin(GL_QUADS);
417	gl->TexCoord2f(0.0f, 1.0f);
418	gl->Vertex2f(-1.0, -1.0);
419
420	gl->TexCoord2f(0.0f, 0.0f);
421	gl->Vertex2f(-1.0f, 1.0f);
422
423	gl->TexCoord2f(1.0f, 0.0f);
424	gl->Vertex2f(1.0f, 1.0f);
425
426	gl->TexCoord2f(1.0f, 1.0f);
427	gl->Vertex2f(1.0f, -1.0f);
428	gl->End();
429
430	gl->PopMatrix();
431	gl->MatrixMode(GL_PROJECTION);
432	gl->PopMatrix();
433	gl->PopAttrib();
434
435	gl->FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, target, 0, level);
436	gl->BindFramebufferEXT(GL_FRAMEBUFFER_EXT, ctx->framebufferobject.drawFB ? ctx->framebufferobject.drawFB->hwid:0);
437	gl->BindTexture(target, ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->hwid);
438	gl->DeleteFramebuffersEXT(1, &fboID);
439	gl->DeleteTextures(1, &tID);
440
441	#if 0
442	{
443	GLint dRow, sRow, w, h;
444	void img1, img2;
445
446	w = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->level[0][level].width;
447	h = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->level[0][level].height;
448
449	img1 = crAlloc(4wh);
450	img2 = crAlloc(4wh);
451	CRASSERT(img1 && img2);
452
453	gl->GetTexImage(target, level, GL_BGRA, GL_UNSIGNED_BYTE, img1);
454
455
456	for (dRow=yoffset, sRow=y-height-1; dRow<yoffset-height; dRow++, sRow--)
457	{
458	gl->CopyTexSubImage2D(target, level, xoffset, dRow, x, sRow, width, 1);
459	}
460
461	gl->GetTexImage(target, level, GL_BGRA, GL_UNSIGNED_BYTE, img2);
462
463	if (crMemcmp(img1, img2, 4wh))
464	{
465	crDebug("MISMATCH! (%x, %i, ->%i,%i <-%i, %i [%ix%i])", target, level, xoffset, yoffset, x, y, width, height);
466	crDumpTGA(w, h, img1);
467	crDumpTGA(w, h, img2);
468	DebugBreak();
469	}
470	crFree(img1);
471	crFree(img2);
472	}
473	#endif
474	}
475	else
476	{
477	GLuint pboId, dRow, sRow;
478	CRContext *ctx = crStateGetCurrent();
479
480	gl->GenBuffersARB(1, &pboId);
481	gl->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, pboId);
482	gl->BufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, -widthheight4, 0, GL_STATIC_COPY_ARB);
483
484	#if 1
485	gl->ReadPixels(x, y, width, -height, GL_RGBA, GL_UNSIGNED_BYTE, 0);
486	gl->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, ctx->bufferobject.packBuffer->hwid);
487
488	gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pboId);
489	for (dRow=yoffset, sRow=-height-1; dRow<yoffset-height; dRow++, sRow--)
490	{
491	gl->TexSubImage2D(target, level, xoffset, dRow, width, 1, GL_RGBA, GL_UNSIGNED_BYTE, (void)((uintptr_t)sRowwidth*4));
492	}
493	#else /few times slower again/
494	for (dRow=0, sRow=y-height-1; dRow<-height; dRow++, sRow--)
495	{
496	gl->ReadPixels(x, sRow, width, 1, GL_RGBA, GL_UNSIGNED_BYTE, (void)((uintptr_t)dRowwidth*4));
497	}
498	gl->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, ctx->bufferobject.packBuffer->hwid);
499
500	gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pboId);
501	gl->TexSubImage2D(target, level, xoffset, yoffset, width, -height, GL_RGBA, GL_UNSIGNED_BYTE, 0);
502	#endif
503
504	gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, ctx->bufferobject.unpackBuffer->hwid);
505	gl->DeleteBuffersARB(1, &pboId);
506	}
507	}
508	}
509
510	void SERVER_DISPATCH_APIENTRY
511	crServerDispatchBlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
512	GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
513	GLbitfield mask, GLenum filter)
514	{
515	#ifdef CR_DUMP_BLITS
516	SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
517	GLint rfb=0, dfb=0, dtex=0, dlev=-1, rb=0, db=0, ppb=0, pub=0, vp[4], otex, dstw, dsth;
518	GLenum status;
519	char fname[200];
520	void *img;
521
522	blitnum++;
523
524	crDebug("[%i]BlitFramebufferEXT(%i, %i, %i, %i, %i, %i, %i, %i, %x, %x)", blitnum, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
525	crDebug("%i, %i <-> %i, %i", srcX1-srcX0, srcY1-srcY0, dstX1-dstX0, dstY1-dstY0);
526
527	gl->GetIntegerv(GL_READ_FRAMEBUFFER_BINDING_EXT, &rfb);
528	gl->GetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_EXT, &dfb);
529	gl->GetIntegerv(GL_READ_BUFFER, &rb);
530	gl->GetIntegerv(GL_DRAW_BUFFER, &db);
531
532	gl->GetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, &ppb);
533	gl->GetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &pub);
534
535	gl->GetIntegerv(GL_VIEWPORT, &vp[0]);
536
537	gl->GetIntegerv(GL_TEXTURE_BINDING_2D, &otex);
538
539	CRASSERT(!rfb && dfb);
540	gl->GetFramebufferAttachmentParameterivEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, &dtex);
541	gl->GetFramebufferAttachmentParameterivEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT, &dlev);
542	status = gl->CheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT);
543
544	CRASSERT(status==GL_FRAMEBUFFER_COMPLETE_EXT
545	&& db==GL_COLOR_ATTACHMENT0_EXT
546	&& (rb==GL_FRONT \|\| rb==GL_BACK)
547	&& !rfb && dfb && dtex && !dlev
548	&& !ppb && !pub);
549
550	crDebug("Src[rb 0x%x, fbo %i] Dst[db 0x%x, fbo %i(0x%x), tex %i.%i]", rb, rfb, db, dfb, status, dtex, dlev);
551	crDebug("Viewport [%i, %i, %i, %i]", vp[0], vp[1], vp[2], vp[3]);
552
553	gl->PixelStorei(GL_PACK_ROW_LENGTH, 0);
554	gl->PixelStorei(GL_PACK_ALIGNMENT, 1);
555	gl->PixelStorei(GL_PACK_SKIP_PIXELS, 0);
556	gl->PixelStorei(GL_PACK_SKIP_ROWS, 0);
557
558	gl->PixelStorei(GL_UNPACK_ROW_LENGTH, 0);
559	gl->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
560	gl->PixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
561	gl->PixelStorei(GL_UNPACK_SKIP_ROWS, 0);
562
563	gl->BindTexture(GL_TEXTURE_2D, dtex);
564	gl->GetTexLevelParameteriv(GL_TEXTURE_2D, dlev, GL_TEXTURE_WIDTH, &dstw);
565	gl->GetTexLevelParameteriv(GL_TEXTURE_2D, dlev, GL_TEXTURE_HEIGHT, &dsth);
566	gl->BindTexture(GL_TEXTURE_2D, otex);
567	crDebug("Dst is %i, %i", dstw, dsth);
568
569	CRASSERT(vp[2]>=dstw && vp[3]>=dsth);
570	img = crAlloc(vp[2]vp[3]4);
571	CRASSERT(img);
572
573	gl->ReadPixels(0, 0, vp[2], vp[3], GL_BGRA, GL_UNSIGNED_BYTE, img);
574	sprintf(fname, "blit%iA_src.tga", blitnum);
575	crDumpNamedTGA(fname, vp[2], vp[3], img);
576
577	gl->BindTexture(GL_TEXTURE_2D, dtex);
578	gl->GetTexImage(GL_TEXTURE_2D, dlev, GL_BGRA, GL_UNSIGNED_BYTE, img);
579	sprintf(fname, "blit%iB_dst.tga", blitnum);
580	crDumpNamedTGA(fname, dstw, dsth, img);
581	gl->BindTexture(GL_TEXTURE_2D, otex);
582	#endif
583
584	cr_server.head_spu->dispatch_table.BlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1,
585	dstX0, dstY0, dstX1, dstY1,
586	mask, filter);
587
588	#ifdef CR_DUMP_BLITS
589	gl->BindTexture(GL_TEXTURE_2D, dtex);
590	gl->GetTexImage(GL_TEXTURE_2D, dlev, GL_BGRA, GL_UNSIGNED_BYTE, img);
591	sprintf(fname, "blit%iC_res.tga", blitnum);
592	crDumpNamedTGA(fname, dstw, dsth, img);
593	gl->BindTexture(GL_TEXTURE_2D, otex);
594	crFree(img);
595	#endif
596	}

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_misc.c@ 41109

以其他格式下載: