VirtualBox

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

Last change on this file since 43932 was 43932, checked in by vboxsync, 12 years ago

crOpenGL: host offscreen rendering to fix gnome-shell issues, repaint problems and more
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 33.4 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
14void SERVER_DISPATCH_APIENTRY crServerDispatchSelectBuffer( GLsizei size, GLuint *buffer )
15{
16 (void) size;
17 (void) buffer;
18 crError( "Unsupported network glSelectBuffer call." );
19}
20
21void 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
57void 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
217void 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
248void 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
266GLint crServerGenerateID(GLint *pCounter)
267{
268 return (*pCounter)++;
269}
270
271/*#define CR_DUMP_BLITS*/
272
273#ifdef CR_DUMP_BLITS
274static int blitnum=0;
275static int copynum=0;
276#endif
277
278# ifdef DEBUG_misha
279# define CR_CHECK_BLITS
280# include <iprt/assert.h>
281# undef CRASSERT /* iprt assert's int3 are inlined that is why are more convenient to use since they can be easily disabled individually */
282# define CRASSERT Assert
283# endif
284
285
286void SERVER_DISPATCH_APIENTRY
287crServerDispatchCopyTexSubImage2D(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(w*h*4);
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(4*w*h);
353 img2 = crAlloc(4*width*(-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+4*xoffset+4*w*yoffset;
360 dPtr=img2+4*width*(-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(4*w*h);
450 img2 = crAlloc(4*w*h);
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, 4*w*h))
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, -width*height*4, 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)sRow*width*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)dRow*width*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#ifdef CR_CHECK_BLITS
511void crDbgFree(void *pvData)
512{
513 crFree(pvData);
514}
515
516void crDbgGetTexImage2D(GLint texTarget, GLint texName, GLvoid **ppvImage, GLint *pw, GLint *ph)
517{
518 SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
519 GLint ppb, pub, dstw, dsth, otex;
520 GLint pa, pr, psp, psr, ua, ur, usp, usr;
521 GLvoid *pvImage;
522 GLint rfb, dfb, rb, db;
523
524 gl->GetIntegerv(GL_READ_FRAMEBUFFER_BINDING_EXT, &rfb);
525 gl->GetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_EXT, &dfb);
526 gl->GetIntegerv(GL_READ_BUFFER, &rb);
527 gl->GetIntegerv(GL_DRAW_BUFFER, &db);
528
529 gl->BindFramebufferEXT(GL_READ_FRAMEBUFFER_BINDING_EXT, 0);
530 gl->BindFramebufferEXT(GL_DRAW_FRAMEBUFFER_BINDING_EXT, 0);
531 gl->ReadBuffer(GL_BACK);
532 gl->DrawBuffer(GL_BACK);
533
534 gl->GetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, &ppb);
535 gl->GetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &pub);
536 gl->GetIntegerv(GL_TEXTURE_BINDING_2D, &otex);
537
538 gl->GetIntegerv(GL_PACK_ROW_LENGTH, &pr);
539 gl->GetIntegerv(GL_PACK_ALIGNMENT, &pa);
540 gl->GetIntegerv(GL_PACK_SKIP_PIXELS, &psp);
541 gl->GetIntegerv(GL_PACK_SKIP_ROWS, &psr);
542
543 gl->GetIntegerv(GL_UNPACK_ROW_LENGTH, &ur);
544 gl->GetIntegerv(GL_UNPACK_ALIGNMENT, &ua);
545 gl->GetIntegerv(GL_UNPACK_SKIP_PIXELS, &usp);
546 gl->GetIntegerv(GL_UNPACK_SKIP_ROWS, &usr);
547
548 gl->BindTexture(texTarget, texName);
549 gl->GetTexLevelParameteriv(texTarget, 0, GL_TEXTURE_WIDTH, &dstw);
550 gl->GetTexLevelParameteriv(texTarget, 0, GL_TEXTURE_HEIGHT, &dsth);
551
552 gl->PixelStorei(GL_PACK_ROW_LENGTH, 0);
553 gl->PixelStorei(GL_PACK_ALIGNMENT, 1);
554 gl->PixelStorei(GL_PACK_SKIP_PIXELS, 0);
555 gl->PixelStorei(GL_PACK_SKIP_ROWS, 0);
556
557 gl->PixelStorei(GL_UNPACK_ROW_LENGTH, 0);
558 gl->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
559 gl->PixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
560 gl->PixelStorei(GL_UNPACK_SKIP_ROWS, 0);
561
562 gl->BindBufferARB(GL_PIXEL_PACK_BUFFER, 0);
563 gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER, 0);
564
565 pvImage = crAlloc(4*dstw*dsth);
566 gl->GetTexImage(texTarget, 0, GL_BGRA, GL_UNSIGNED_BYTE, pvImage);
567
568 gl->BindTexture(texTarget, otex);
569
570 gl->PixelStorei(GL_PACK_ROW_LENGTH, pr);
571 gl->PixelStorei(GL_PACK_ALIGNMENT, pa);
572 gl->PixelStorei(GL_PACK_SKIP_PIXELS, psp);
573 gl->PixelStorei(GL_PACK_SKIP_ROWS, psr);
574
575 gl->PixelStorei(GL_UNPACK_ROW_LENGTH, ur);
576 gl->PixelStorei(GL_UNPACK_ALIGNMENT, ua);
577 gl->PixelStorei(GL_UNPACK_SKIP_PIXELS, usp);
578 gl->PixelStorei(GL_UNPACK_SKIP_ROWS, usr);
579
580 gl->BindBufferARB(GL_PIXEL_PACK_BUFFER, ppb);
581 gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER, pub);
582
583 gl->BindFramebufferEXT(GL_READ_FRAMEBUFFER_BINDING_EXT, rfb);
584 gl->BindFramebufferEXT(GL_DRAW_FRAMEBUFFER_BINDING_EXT, dfb);
585 gl->ReadBuffer(rb);
586 gl->DrawBuffer(db);
587
588 *ppvImage = pvImage;
589 *pw = dstw;
590 *ph = dsth;
591}
592
593DECLEXPORT(void) crDbgPrint(const char *format, ... )
594{
595 va_list args;
596 static char txt[8092];
597
598 va_start( args, format );
599 vsprintf( txt, format, args );
600
601 OutputDebugString(txt);
602}
603
604void crDbgDumpImage2D(const char* pszDesc, const void *pvData, uint32_t width, uint32_t height, uint32_t bpp, uint32_t pitch)
605{
606 crDbgPrint("<?dml?><exec cmd=\"!vbvdbg.ms 0x%p 0n%d 0n%d 0n%d 0n%d\">%s</exec>, ( !vbvdbg.ms 0x%p 0n%d 0n%d 0n%d 0n%d )\n",
607 pvData, width, height, bpp, pitch,
608 pszDesc,
609 pvData, width, height, bpp, pitch);
610}
611
612void crDbgDumpTexImage2D(const char* pszDesc, GLint texTarget, GLint texName, GLboolean fBreak)
613{
614 GLvoid *pvImage;
615 GLint w, h;
616 crDbgGetTexImage2D(texTarget, texName, &pvImage, &w, &h);
617 crDbgPrint("%s target(%d), name(%d), width(%d), height(%d)", pszDesc, texTarget, texName, w, h);
618 crDbgDumpImage2D("texture data", pvImage, w, h, 32, (32 * w)/8);
619 if (fBreak)
620 {
621 CRASSERT(0);
622 }
623 crDbgFree(pvImage);
624}
625#endif
626
627void SERVER_DISPATCH_APIENTRY
628crServerDispatchBlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
629 GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
630 GLbitfield mask, GLenum filter)
631{
632#ifdef CR_CHECK_BLITS
633// {
634 SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
635 GLint rfb=0, dfb=0, dtex=0, dlev=-1, rtex=0, rlev=-1, rb=0, db=0, ppb=0, pub=0, vp[4], otex, dstw, dsth;
636 GLint sdtex=0, srtex=0;
637 GLenum dStatus, rStatus;
638 CRContext *ctx = crStateGetCurrent();
639
640 CRTextureObj *tobj = 0;
641 CRTextureLevel *tl = 0;
642 GLint id, tuId, pbufId, pbufIdHw, ubufId, ubufIdHw, width, height, depth;
643
644 crDebug("===StateTracker===");
645 crDebug("Current TU: %i", ctx->texture.curTextureUnit);
646
647 tobj = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D;
648 CRASSERT(tobj);
649 tl = &tobj->level[0][0];
650 crDebug("Texture %i(hw %i), w=%i, h=%i", tobj->id, tobj->hwid, tl->width, tl->height, tl->depth);
651
652 if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
653 {
654 pbufId = ctx->bufferobject.packBuffer->hwid;
655 }
656 else
657 {
658 pbufId = 0;
659 }
660 crDebug("Pack BufferId %i", pbufId);
661
662 if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
663 {
664 ubufId = ctx->bufferobject.unpackBuffer->hwid;
665 }
666 else
667 {
668 ubufId = 0;
669 }
670 crDebug("Unpack BufferId %i", ubufId);
671
672 crDebug("===GPU===");
673 cr_server.head_spu->dispatch_table.GetIntegerv(GL_ACTIVE_TEXTURE, &tuId);
674 crDebug("Current TU: %i", tuId - GL_TEXTURE0_ARB);
675 CRASSERT(tuId - GL_TEXTURE0_ARB == ctx->texture.curTextureUnit);
676
677 cr_server.head_spu->dispatch_table.GetIntegerv(GL_TEXTURE_BINDING_2D, &id);
678 cr_server.head_spu->dispatch_table.GetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
679 cr_server.head_spu->dispatch_table.GetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height);
680 cr_server.head_spu->dispatch_table.GetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_DEPTH, &depth);
681 crDebug("Texture: %i, w=%i, h=%i, d=%i", id, width, height, depth);
682 CRASSERT(id == tobj->hwid);
683 CRASSERT(width == tl->width);
684 CRASSERT(height == tl->height);
685 CRASSERT(depth == tl->depth);
686
687 cr_server.head_spu->dispatch_table.GetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, &pbufIdHw);
688 crDebug("Hw Pack BufferId %i", pbufIdHw);
689 CRASSERT(pbufIdHw == pbufId);
690
691 cr_server.head_spu->dispatch_table.GetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &ubufIdHw);
692 crDebug("Hw Unpack BufferId %i", ubufIdHw);
693 CRASSERT(ubufIdHw == ubufId);
694
695 gl->GetIntegerv(GL_READ_FRAMEBUFFER_BINDING_EXT, &rfb);
696 gl->GetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_EXT, &dfb);
697 gl->GetIntegerv(GL_READ_BUFFER, &rb);
698 gl->GetIntegerv(GL_DRAW_BUFFER, &db);
699
700 gl->GetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, &ppb);
701 gl->GetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &pub);
702
703 gl->GetIntegerv(GL_VIEWPORT, &vp[0]);
704
705 gl->GetIntegerv(GL_TEXTURE_BINDING_2D, &otex);
706
707 gl->GetFramebufferAttachmentParameterivEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, &dtex);
708 gl->GetFramebufferAttachmentParameterivEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT, &dlev);
709 dStatus = gl->CheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT);
710
711 gl->GetFramebufferAttachmentParameterivEXT(GL_READ_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, &rtex);
712 gl->GetFramebufferAttachmentParameterivEXT(GL_READ_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT, &rlev);
713 rStatus = gl->CheckFramebufferStatusEXT(GL_READ_FRAMEBUFFER_EXT);
714
715 if (dtex)
716 {
717 CRASSERT(!dlev);
718 }
719
720 if (rtex)
721 {
722 CRASSERT(!rlev);
723 }
724
725 if (ctx->framebufferobject.drawFB)
726 {
727 CRASSERT(dfb);
728 CRASSERT(ctx->framebufferobject.drawFB->hwid == dfb);
729 CRASSERT(ctx->framebufferobject.drawFB->drawbuffer[0] == db);
730
731 CRASSERT(dStatus==GL_FRAMEBUFFER_COMPLETE_EXT);
732 CRASSERT(db==GL_COLOR_ATTACHMENT0_EXT);
733
734 CRASSERT(ctx->framebufferobject.drawFB->color[0].type == GL_TEXTURE);
735 CRASSERT(ctx->framebufferobject.drawFB->color[0].level == 0);
736 sdtex = ctx->framebufferobject.drawFB->color[0].name;
737 sdtex = crStateGetTextureHWID(sdtex);
738
739 CRASSERT(sdtex);
740 }
741 else
742 {
743 CRASSERT(!dfb);
744 }
745
746 if (ctx->framebufferobject.readFB)
747 {
748 CRASSERT(rfb);
749 CRASSERT(ctx->framebufferobject.readFB->hwid == rfb);
750
751 CRASSERT(rStatus==GL_FRAMEBUFFER_COMPLETE_EXT);
752
753 CRASSERT(ctx->framebufferobject.readFB->color[0].type == GL_TEXTURE);
754 CRASSERT(ctx->framebufferobject.readFB->color[0].level == 0);
755 srtex = ctx->framebufferobject.readFB->color[0].name;
756 srtex = crStateGetTextureHWID(srtex);
757
758 CRASSERT(srtex);
759 }
760 else
761 {
762 CRASSERT(!rfb);
763 }
764
765 CRASSERT(sdtex == dtex);
766 CRASSERT(srtex == rtex);
767
768// crDbgDumpTexImage2D("==> src tex:", GL_TEXTURE_2D, rtex, true);
769// crDbgDumpTexImage2D("==> dst tex:", GL_TEXTURE_2D, dtex, true);
770
771// }
772#endif
773#ifdef CR_DUMP_BLITS
774 SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
775 GLint rfb=0, dfb=0, dtex=0, dlev=-1, rb=0, db=0, ppb=0, pub=0, vp[4], otex, dstw, dsth;
776 GLenum status;
777 char fname[200];
778 void *img;
779
780 blitnum++;
781
782 crDebug("[%i]BlitFramebufferEXT(%i, %i, %i, %i, %i, %i, %i, %i, %x, %x)", blitnum, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
783 crDebug("%i, %i <-> %i, %i", srcX1-srcX0, srcY1-srcY0, dstX1-dstX0, dstY1-dstY0);
784
785 gl->GetIntegerv(GL_READ_FRAMEBUFFER_BINDING_EXT, &rfb);
786 gl->GetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING_EXT, &dfb);
787 gl->GetIntegerv(GL_READ_BUFFER, &rb);
788 gl->GetIntegerv(GL_DRAW_BUFFER, &db);
789
790 gl->GetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, &ppb);
791 gl->GetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &pub);
792
793 gl->GetIntegerv(GL_VIEWPORT, &vp[0]);
794
795 gl->GetIntegerv(GL_TEXTURE_BINDING_2D, &otex);
796
797 CRASSERT(!rfb && dfb);
798 gl->GetFramebufferAttachmentParameterivEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, &dtex);
799 gl->GetFramebufferAttachmentParameterivEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT, &dlev);
800 status = gl->CheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT);
801
802 CRASSERT(status==GL_FRAMEBUFFER_COMPLETE_EXT
803 && db==GL_COLOR_ATTACHMENT0_EXT
804 && (rb==GL_FRONT || rb==GL_BACK)
805 && !rfb && dfb && dtex && !dlev
806 && !ppb && !pub);
807
808 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);
809 crDebug("Viewport [%i, %i, %i, %i]", vp[0], vp[1], vp[2], vp[3]);
810
811 gl->PixelStorei(GL_PACK_ROW_LENGTH, 0);
812 gl->PixelStorei(GL_PACK_ALIGNMENT, 1);
813 gl->PixelStorei(GL_PACK_SKIP_PIXELS, 0);
814 gl->PixelStorei(GL_PACK_SKIP_ROWS, 0);
815
816 gl->PixelStorei(GL_UNPACK_ROW_LENGTH, 0);
817 gl->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
818 gl->PixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
819 gl->PixelStorei(GL_UNPACK_SKIP_ROWS, 0);
820
821 gl->BindTexture(GL_TEXTURE_2D, dtex);
822 gl->GetTexLevelParameteriv(GL_TEXTURE_2D, dlev, GL_TEXTURE_WIDTH, &dstw);
823 gl->GetTexLevelParameteriv(GL_TEXTURE_2D, dlev, GL_TEXTURE_HEIGHT, &dsth);
824 gl->BindTexture(GL_TEXTURE_2D, otex);
825 crDebug("Dst is %i, %i", dstw, dsth);
826
827 CRASSERT(vp[2]>=dstw && vp[3]>=dsth);
828 img = crAlloc(vp[2]*vp[3]*4);
829 CRASSERT(img);
830
831 gl->ReadPixels(0, 0, vp[2], vp[3], GL_BGRA, GL_UNSIGNED_BYTE, img);
832 sprintf(fname, "blit%iA_src.tga", blitnum);
833 crDumpNamedTGA(fname, vp[2], vp[3], img);
834
835 gl->BindTexture(GL_TEXTURE_2D, dtex);
836 gl->GetTexImage(GL_TEXTURE_2D, dlev, GL_BGRA, GL_UNSIGNED_BYTE, img);
837 sprintf(fname, "blit%iB_dst.tga", blitnum);
838 crDumpNamedTGA(fname, dstw, dsth, img);
839 gl->BindTexture(GL_TEXTURE_2D, otex);
840#endif
841
842 cr_server.head_spu->dispatch_table.BlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1,
843 dstX0, dstY0, dstX1, dstY1,
844 mask, filter);
845
846//#ifdef CR_CHECK_BLITS
847// crDbgDumpTexImage2D("<== src tex:", GL_TEXTURE_2D, rtex, true);
848// crDbgDumpTexImage2D("<== dst tex:", GL_TEXTURE_2D, dtex, true);
849//#endif
850#ifdef CR_DUMP_BLITS
851 gl->BindTexture(GL_TEXTURE_2D, dtex);
852 gl->GetTexImage(GL_TEXTURE_2D, dlev, GL_BGRA, GL_UNSIGNED_BYTE, img);
853 sprintf(fname, "blit%iC_res.tga", blitnum);
854 crDumpNamedTGA(fname, dstw, dsth, img);
855 gl->BindTexture(GL_TEXTURE_2D, otex);
856 crFree(img);
857#endif
858}
859
860void SERVER_DISPATCH_APIENTRY crServerDispatchDrawBuffer( GLenum mode )
861{
862 crStateDrawBuffer( mode );
863
864 if (!crStateGetCurrent()->framebufferobject.drawFB)
865 {
866 if (mode == GL_FRONT || mode == GL_FRONT_LEFT)
867 cr_server.curClient->currentMural->bFbDraw = GL_TRUE;
868
869 if (crServerIsRedirectedToFBO()
870 && cr_server.curClient->currentMural->idFBO)
871 {
872 switch (mode)
873 {
874 case GL_BACK:
875 case GL_BACK_LEFT:
876 mode = GL_COLOR_ATTACHMENT0;
877 break;
878 case GL_FRONT:
879 case GL_FRONT_LEFT:
880 crDebug("Setting GL_FRONT with FBO mode! (0x%x)", mode);
881 mode = GL_COLOR_ATTACHMENT0;
882 break;
883 default:
884 crWarning("unexpected mode! 0x%x", mode);
885 break;
886 }
887 }
888 }
889
890 cr_server.head_spu->dispatch_table.DrawBuffer( mode );
891}
892
893void SERVER_DISPATCH_APIENTRY crServerDispatchReadBuffer( GLenum mode )
894{
895 crStateReadBuffer( mode );
896
897 if (crServerIsRedirectedToFBO()
898 && cr_server.curClient->currentMural->idFBO
899 && !crStateGetCurrent()->framebufferobject.readFB)
900 {
901 switch (mode)
902 {
903 case GL_BACK:
904 case GL_BACK_LEFT:
905 mode = GL_COLOR_ATTACHMENT0;
906 break;
907 case GL_FRONT:
908 case GL_FRONT_LEFT:
909 crWarning("GL_FRONT not supported for FBO mode!");
910 mode = GL_COLOR_ATTACHMENT0;
911 break;
912 default:
913 crWarning("unexpected mode! 0x%x", mode);
914 break;
915 }
916 }
917 cr_server.head_spu->dispatch_table.ReadBuffer( mode );
918}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette