VirtualBox

source: vbox/trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/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
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
266void crServerCreateInfoDeleteCB(void *data)
267{
268 CRCreateInfo_t *pCreateInfo = (CRCreateInfo_t *) data;
269 if (pCreateInfo->pszDpyName)
270 crFree(pCreateInfo->pszDpyName);
271 crFree(pCreateInfo);
272}
273
274GLint crServerGenerateID(GLint *pCounter)
275{
276 return (*pCounter)++;
277}
278
279/*#define CR_DUMP_BLITS*/
280
281#ifdef CR_DUMP_BLITS
282static int blitnum=0;
283static int copynum=0;
284#endif
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
510void SERVER_DISPATCH_APIENTRY
511crServerDispatchBlitFramebufferEXT(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 來幫助您使用儲存庫瀏覽器

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