server_misc.c@ 40693

Last change on this file since 40693 was 40691, checked in by vboxsync, 13 years ago
crOpenGL: basics for using multiple contexts on host
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 22.2 KB

Line
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_SHARED_DISPLAY_LISTS_CR:
224	cr_server.sharedDisplayLists = value;
225	break;
226	case GL_SHARED_TEXTURE_OBJECTS_CR:
227	cr_server.sharedTextureObjects = value;
228	break;
229	case GL_SHARED_PROGRAMS_CR:
230	cr_server.sharedPrograms = value;
231	break;
232	case GL_SERVER_CURRENT_EYE_CR:
233	cr_server.currentEye = value ? 1 : 0;
234	break;
235	default:
236	/* Pass the parameter info to the head SPU */
237	cr_server.head_spu->dispatch_table.ChromiumParameteriCR( target, value );
238	}
239	}
240
241
242	void SERVER_DISPATCH_APIENTRY crServerDispatchChromiumParameterfCR(GLenum target, GLfloat value)
243	{
244	switch (target) {
245	case GL_SHARED_DISPLAY_LISTS_CR:
246	cr_server.sharedDisplayLists = (int) value;
247	break;
248	case GL_SHARED_TEXTURE_OBJECTS_CR:
249	cr_server.sharedTextureObjects = (int) value;
250	break;
251	case GL_SHARED_PROGRAMS_CR:
252	cr_server.sharedPrograms = (int) value;
253	break;
254	default:
255	/* Pass the parameter info to the head SPU */
256	cr_server.head_spu->dispatch_table.ChromiumParameterfCR( target, value );
257	}
258	}
259
260	void crServerCreateInfoDeleteCB(void *data)
261	{
262	CRCreateInfo_t pCreateInfo = (CRCreateInfo_t ) data;
263	if (pCreateInfo->pszDpyName)
264	crFree(pCreateInfo->pszDpyName);
265	crFree(pCreateInfo);
266	}
267
268	GLint crServerGenerateID(GLint *pCounter)
269	{
270	return (*pCounter)++;
271	}
272
273	/#define CR_DUMP_BLITS/
274
275	#ifdef CR_DUMP_BLITS
276	static int blitnum=0;
277	static int copynum=0;
278	#endif
279
280	void SERVER_DISPATCH_APIENTRY
281	crServerDispatchCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
282	{
283	/@todo pbo/fbo disabled for now as it's slower, check on other gpus/
284	static int siHavePBO = 0;
285	static int siHaveFBO = 0;
286
287	if ((target!=GL_TEXTURE_2D) \|\| (height>=0))
288	{
289	cr_server.head_spu->dispatch_table.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
290
291	#ifdef CR_DUMP_BLITS
292	{
293	SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
294	void *img;
295	GLint w, h;
296	char fname[200];
297
298	copynum++;
299
300	gl->GetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w);
301	gl->GetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &h);
302
303	img = crAlloc(wh4);
304	CRASSERT(img);
305
306	gl->GetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_BYTE, img);
307	sprintf(fname, "copy_blit%i_copy_%i.tga", blitnum, copynum);
308	crDumpNamedTGA(fname, w, h, img);
309	crFree(img);
310	}
311	#endif
312	}
313	else /* negative height, means we have to Yinvert the source pixels while copying */
314	{
315	SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
316
317	if (siHavePBO<0)
318	{
319	const char ext = (const char)gl->GetString(GL_EXTENSIONS);
320	siHavePBO = crStrstr(ext, "GL_ARB_pixel_buffer_object") ? 1:0;
321	}
322
323	if (siHaveFBO<0)
324	{
325	const char ext = (const char)gl->GetString(GL_EXTENSIONS);
326	siHaveFBO = crStrstr(ext, "GL_EXT_framebuffer_object") ? 1:0;
327	}
328
329	if (siHavePBO==0 && siHaveFBO==0)
330	{
331	#if 1
332	GLint dRow, sRow;
333	for (dRow=yoffset, sRow=y-height-1; dRow<yoffset-height; dRow++, sRow--)
334	{
335	gl->CopyTexSubImage2D(target, level, xoffset, dRow, x, sRow, width, 1);
336	}
337	#else
338	{
339	GLint w, h, i;
340	char img1, img2, sPtr, dPtr;
341	CRContext *ctx = crStateGetCurrent();
342
343	w = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->level[0][level].width;
344	h = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->level[0][level].height;
345
346	img1 = crAlloc(4wh);
347	img2 = crAlloc(4width(-height));
348	CRASSERT(img1 && img2);
349
350	gl->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, -height);
351	gl->GetTexImage(target, level, GL_RGBA, GL_UNSIGNED_BYTE, img1);
352
353	sPtr=img1+4xoffset+4w*yoffset;
354	dPtr=img2+4width(-height-1);
355
356	for (i=0; i<-height; ++i)
357	{
358	crMemcpy(dPtr, sPtr, 4*width);
359	sPtr += 4*w;
360	dPtr -= 4*width;
361	}
362
363	gl->TexSubImage2D(target, level, xoffset, yoffset, width, -height, GL_RGBA, GL_UNSIGNED_BYTE, img2);
364
365	crFree(img1);
366	crFree(img2);
367	}
368	#endif
369	}
370	else if (siHaveFBO==1) /@todo more states to set and restore here/
371	{
372	GLuint tID, fboID;
373	GLenum status;
374	CRContext *ctx = crStateGetCurrent();
375
376	gl->GenTextures(1, &tID);
377	gl->BindTexture(target, tID);
378	gl->CopyTexImage2D(target, level, GL_RGBA, x, y, width, -height, 0);
379	gl->GenFramebuffersEXT(1, &fboID);
380	gl->BindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboID);
381	gl->FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, target,
382	ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->hwid, level);
383	status = gl->CheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
384	if (status != GL_FRAMEBUFFER_COMPLETE_EXT)
385	{
386	crWarning("Framebuffer status 0x%x", status);
387	}
388
389	gl->Enable(target);
390	gl->PushAttrib(GL_VIEWPORT_BIT);
391	gl->Viewport(xoffset, yoffset, width, -height);
392	gl->MatrixMode(GL_PROJECTION);
393	gl->PushMatrix();
394	gl->LoadIdentity();
395	gl->MatrixMode(GL_MODELVIEW);
396	gl->PushMatrix();
397	gl->LoadIdentity();
398
399	gl->Disable(GL_DEPTH_TEST);
400	gl->Disable(GL_CULL_FACE);
401	gl->Disable(GL_STENCIL_TEST);
402	gl->Disable(GL_SCISSOR_TEST);
403
404	gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
405	gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
406	gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
407	gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
408	gl->TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
409
410	gl->Begin(GL_QUADS);
411	gl->TexCoord2f(0.0f, 1.0f);
412	gl->Vertex2f(-1.0, -1.0);
413
414	gl->TexCoord2f(0.0f, 0.0f);
415	gl->Vertex2f(-1.0f, 1.0f);
416
417	gl->TexCoord2f(1.0f, 0.0f);
418	gl->Vertex2f(1.0f, 1.0f);
419
420	gl->TexCoord2f(1.0f, 1.0f);
421	gl->Vertex2f(1.0f, -1.0f);
422	gl->End();
423
424	gl->PopMatrix();
425	gl->MatrixMode(GL_PROJECTION);
426	gl->PopMatrix();
427	gl->PopAttrib();
428
429	gl->FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, target, 0, level);
430	gl->BindFramebufferEXT(GL_FRAMEBUFFER_EXT, ctx->framebufferobject.drawFB ? ctx->framebufferobject.drawFB->hwid:0);
431	gl->BindTexture(target, ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->hwid);
432	gl->DeleteFramebuffersEXT(1, &fboID);
433	gl->DeleteTextures(1, &tID);
434
435	#if 0
436	{
437	GLint dRow, sRow, w, h;
438	void img1, img2;
439
440	w = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->level[0][level].width;
441	h = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->level[0][level].height;
442
443	img1 = crAlloc(4wh);
444	img2 = crAlloc(4wh);
445	CRASSERT(img1 && img2);
446
447	gl->GetTexImage(target, level, GL_BGRA, GL_UNSIGNED_BYTE, img1);
448
449
450	for (dRow=yoffset, sRow=y-height-1; dRow<yoffset-height; dRow++, sRow--)
451	{
452	gl->CopyTexSubImage2D(target, level, xoffset, dRow, x, sRow, width, 1);
453	}
454
455	gl->GetTexImage(target, level, GL_BGRA, GL_UNSIGNED_BYTE, img2);
456
457	if (crMemcmp(img1, img2, 4wh))
458	{
459	crDebug("MISMATCH! (%x, %i, ->%i,%i <-%i, %i [%ix%i])", target, level, xoffset, yoffset, x, y, width, height);
460	crDumpTGA(w, h, img1);
461	crDumpTGA(w, h, img2);
462	DebugBreak();
463	}
464	crFree(img1);
465	crFree(img2);
466	}
467	#endif
468	}
469	else
470	{
471	GLuint pboId, dRow, sRow;
472	CRContext *ctx = crStateGetCurrent();
473
474	gl->GenBuffersARB(1, &pboId);
475	gl->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, pboId);
476	gl->BufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, -widthheight4, 0, GL_STATIC_COPY_ARB);
477
478	#if 1
479	gl->ReadPixels(x, y, width, -height, GL_RGBA, GL_UNSIGNED_BYTE, 0);
480	gl->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, ctx->bufferobject.packBuffer->hwid);
481
482	gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pboId);
483	for (dRow=yoffset, sRow=-height-1; dRow<yoffset-height; dRow++, sRow--)
484	{
485	gl->TexSubImage2D(target, level, xoffset, dRow, width, 1, GL_RGBA, GL_UNSIGNED_BYTE, (void)((uintptr_t)sRowwidth*4));
486	}
487	#else /few times slower again/
488	for (dRow=0, sRow=y-height-1; dRow<-height; dRow++, sRow--)
489	{
490	gl->ReadPixels(x, sRow, width, 1, GL_RGBA, GL_UNSIGNED_BYTE, (void)((uintptr_t)dRowwidth*4));
491	}
492	gl->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, ctx->bufferobject.packBuffer->hwid);
493
494	gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pboId);
495	gl->TexSubImage2D(target, level, xoffset, yoffset, width, -height, GL_RGBA, GL_UNSIGNED_BYTE, 0);
496	#endif
497
498	gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, ctx->bufferobject.unpackBuffer->hwid);
499	gl->DeleteBuffersARB(1, &pboId);
500	}
501	}
502	}
503
504	void SERVER_DISPATCH_APIENTRY
505	crServerDispatchBlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
506	GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
507	GLbitfield mask, GLenum filter)
508	{
509	#ifdef CR_DUMP_BLITS
510	SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
511	GLint rfb=0, dfb=0, dtex=0, dlev=-1, rb=0, db=0, ppb=0, pub=0, vp[4], otex, dstw, dsth;
512	GLenum status;
513	char fname[200];
514	void *img;
515
516	blitnum++;
517
518	crDebug("[%i]BlitFramebufferEXT(%i, %i, %i, %i, %i, %i, %i, %i, %x, %x)", blitnum, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
519	crDebug("%i, %i <-> %i, %i", srcX1-srcX0, srcY1-srcY0, dstX1-dstX0, dstY1-dstY0);
520
521	gl->GetIntegerv(GL_READ_FRAMEBUFFER_BINDING_EXT, &rfb);
522	gl->GetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_EXT, &dfb);
523	gl->GetIntegerv(GL_READ_BUFFER, &rb);
524	gl->GetIntegerv(GL_DRAW_BUFFER, &db);
525
526	gl->GetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, &ppb);
527	gl->GetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &pub);
528
529	gl->GetIntegerv(GL_VIEWPORT, &vp[0]);
530
531	gl->GetIntegerv(GL_TEXTURE_BINDING_2D, &otex);
532
533	CRASSERT(!rfb && dfb);
534	gl->GetFramebufferAttachmentParameterivEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, &dtex);
535	gl->GetFramebufferAttachmentParameterivEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT, &dlev);
536	status = gl->CheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT);
537
538	CRASSERT(status==GL_FRAMEBUFFER_COMPLETE_EXT
539	&& db==GL_COLOR_ATTACHMENT0_EXT
540	&& (rb==GL_FRONT \|\| rb==GL_BACK)
541	&& !rfb && dfb && dtex && !dlev
542	&& !ppb && !pub);
543
544	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);
545	crDebug("Viewport [%i, %i, %i, %i]", vp[0], vp[1], vp[2], vp[3]);
546
547	gl->PixelStorei(GL_PACK_ROW_LENGTH, 0);
548	gl->PixelStorei(GL_PACK_ALIGNMENT, 1);
549	gl->PixelStorei(GL_PACK_SKIP_PIXELS, 0);
550	gl->PixelStorei(GL_PACK_SKIP_ROWS, 0);
551
552	gl->PixelStorei(GL_UNPACK_ROW_LENGTH, 0);
553	gl->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
554	gl->PixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
555	gl->PixelStorei(GL_UNPACK_SKIP_ROWS, 0);
556
557	gl->BindTexture(GL_TEXTURE_2D, dtex);
558	gl->GetTexLevelParameteriv(GL_TEXTURE_2D, dlev, GL_TEXTURE_WIDTH, &dstw);
559	gl->GetTexLevelParameteriv(GL_TEXTURE_2D, dlev, GL_TEXTURE_HEIGHT, &dsth);
560	gl->BindTexture(GL_TEXTURE_2D, otex);
561	crDebug("Dst is %i, %i", dstw, dsth);
562
563	CRASSERT(vp[2]>=dstw && vp[3]>=dsth);
564	img = crAlloc(vp[2]vp[3]4);
565	CRASSERT(img);
566
567	gl->ReadPixels(0, 0, vp[2], vp[3], GL_BGRA, GL_UNSIGNED_BYTE, img);
568	sprintf(fname, "blit%iA_src.tga", blitnum);
569	crDumpNamedTGA(fname, vp[2], vp[3], img);
570
571	gl->BindTexture(GL_TEXTURE_2D, dtex);
572	gl->GetTexImage(GL_TEXTURE_2D, dlev, GL_BGRA, GL_UNSIGNED_BYTE, img);
573	sprintf(fname, "blit%iB_dst.tga", blitnum);
574	crDumpNamedTGA(fname, dstw, dsth, img);
575	gl->BindTexture(GL_TEXTURE_2D, otex);
576	#endif
577
578	cr_server.head_spu->dispatch_table.BlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1,
579	dstX0, dstY0, dstX1, dstY1,
580	mask, filter);
581
582	#ifdef CR_DUMP_BLITS
583	gl->BindTexture(GL_TEXTURE_2D, dtex);
584	gl->GetTexImage(GL_TEXTURE_2D, dlev, GL_BGRA, GL_UNSIGNED_BYTE, img);
585	sprintf(fname, "blit%iC_res.tga", blitnum);
586	crDumpNamedTGA(fname, dstw, dsth, img);
587	gl->BindTexture(GL_TEXTURE_2D, otex);
588	crFree(img);
589	#endif
590	}

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: