VirtualBox

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

最後變更 在這個檔案從34382是 33601,由 vboxsync 提交於 14 年 前

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

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