- Timestamp:
- Jul 7, 2009 10:49:52 AM (16 years ago)
- svn:sync-xref-src-repo-rev:
- 49651
- Location:
- trunk/src/VBox
- Files:
-
- 17 edited
-
Additions/common/crOpenGL/array/arrayspu.c (modified) (10 diffs)
-
Additions/common/crOpenGL/load.c (modified) (1 diff)
-
Additions/common/crOpenGL/pack/packspu_bufferobject.c (modified) (5 diffs)
-
Additions/common/crOpenGL/pack/packspu_client.c (modified) (12 diffs)
-
Additions/common/crOpenGL/pack/packspu_context.c (modified) (2 diffs)
-
Additions/common/crOpenGL/pack/packspu_get.py (modified) (1 diff)
-
Additions/common/crOpenGL/pack/packspu_special (modified) (1 diff)
-
GuestHost/OpenGL/glapi_parser/APIspec.txt (modified) (2 diffs)
-
GuestHost/OpenGL/packer/pack_client.c (modified) (12 diffs)
-
GuestHost/OpenGL/state_tracker/state_bufferobject.c (modified) (1 diff)
-
GuestHost/OpenGL/state_tracker/state_client.c (modified) (2 diffs)
-
HostServices/SharedOpenGL/crserverlib/get_sizes.py (modified) (1 diff)
-
HostServices/SharedOpenGL/crserverlib/server_simpleget.py (modified) (1 diff)
-
HostServices/SharedOpenGL/unpacker/unpack.py (modified) (4 diffs)
-
HostServices/SharedOpenGL/unpacker/unpack_arrays.c (modified) (1 diff)
-
HostServices/SharedOpenGL/unpacker/unpack_bufferobject.c (modified) (1 diff)
-
HostServices/SharedOpenGL/unpacker/unpacker.h (modified) (1 diff)
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/VBox/Additions/common/crOpenGL/array/arrayspu.c
r20970 r21308 478 478 } 479 479 #endif 480 //crDebug("arrayspu_DrawElements mode:0x%x, count:%d, type:0x%x", mode, count, type); 481 480 482 481 483 array_spu.self.Begin(mode); … … 521 523 static void ARRAYSPU_APIENTRY arrayspu_ColorPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) 522 524 { 523 crStateColorPointer( size, type, stride, pointer ); 525 crStateColorPointer(size, type, stride, pointer); 526 array_spu.child.ColorPointer(size, type, stride, pointer); 524 527 } 525 528 526 529 static void ARRAYSPU_APIENTRY arrayspu_SecondaryColorPointerEXT( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) 527 530 { 528 crStateSecondaryColorPointerEXT( size, type, stride, pointer ); 531 crStateSecondaryColorPointerEXT(size, type, stride, pointer); 532 array_spu.child.SecondaryColorPointerEXT(size, type, stride, pointer); 529 533 } 530 534 531 535 static void ARRAYSPU_APIENTRY arrayspu_VertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) 532 536 { 533 crStateVertexPointer( size, type, stride, pointer ); 537 crStateVertexPointer(size, type, stride, pointer); 538 array_spu.child.VertexPointer(size, type, stride, pointer); 534 539 } 535 540 536 541 static void ARRAYSPU_APIENTRY arrayspu_TexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) 537 542 { 538 crStateTexCoordPointer( size, type, stride, pointer ); 543 crStateTexCoordPointer(size, type, stride, pointer); 544 array_spu.child.TexCoordPointer(size, type, stride, pointer); 539 545 } 540 546 541 547 static void ARRAYSPU_APIENTRY arrayspu_NormalPointer( GLenum type, GLsizei stride, const GLvoid *pointer ) 542 548 { 543 crStateNormalPointer( type, stride, pointer ); 549 crStateNormalPointer(type, stride, pointer); 550 array_spu.child.NormalPointer(type, stride, pointer); 544 551 } 545 552 546 553 static void ARRAYSPU_APIENTRY arrayspu_IndexPointer( GLenum type, GLsizei stride, const GLvoid *pointer ) 547 554 { 548 crStateIndexPointer( type, stride, pointer ); 555 crStateIndexPointer(type, stride, pointer); 556 array_spu.child.IndexPointer(type, stride, pointer); 549 557 } 550 558 551 559 static void ARRAYSPU_APIENTRY arrayspu_EdgeFlagPointer( GLsizei stride, const GLvoid *pointer ) 552 560 { 553 crStateEdgeFlagPointer( stride, pointer ); 561 crStateEdgeFlagPointer(stride, pointer); 562 array_spu.child.EdgeFlagPointer(stride, pointer); 554 563 } 555 564 556 565 static void ARRAYSPU_APIENTRY arrayspu_VertexAttribPointerNV( GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer ) 557 566 { 558 crStateVertexAttribPointerNV( index, size, type, stride, pointer ); 567 crStateVertexAttribPointerNV(index, size, type, stride, pointer); 568 array_spu.child.VertexAttribPointerNV(index, size, type, stride, pointer); 559 569 } 560 570 561 571 static void ARRAYSPU_APIENTRY arrayspu_FogCoordPointerEXT( GLenum type, GLsizei stride, const GLvoid *pointer ) 562 572 { 563 crStateFogCoordPointerEXT( type, stride, pointer ); 573 crStateFogCoordPointerEXT(type, stride, pointer); 574 array_spu.child.FogCoordPointerEXT(type, stride, pointer); 564 575 } 565 576 566 577 static void ARRAYSPU_APIENTRY arrayspu_GetPointerv( GLenum pname, GLvoid **params ) 567 578 { 568 crStateGetPointerv( pname, params);579 crStateGetPointerv(pname, params); 569 580 } 570 581 571 582 static void ARRAYSPU_APIENTRY arrayspu_EnableClientState( GLenum array ) 572 583 { 573 crStateEnableClientState( array ); 584 crStateEnableClientState(array); 585 array_spu.child.EnableClientState(array); 574 586 } 575 587 576 588 static void ARRAYSPU_APIENTRY arrayspu_DisableClientState( GLenum array ) 577 589 { 578 crStateDisableClientState( array ); 590 crStateDisableClientState(array); 591 array_spu.child.DisableClientState(array); 579 592 } 580 593 581 594 static void ARRAYSPU_APIENTRY arrayspu_ClientActiveTextureARB( GLenum texture ) 582 595 { 583 crStateClientActiveTextureARB( texture ); 596 crStateClientActiveTextureARB(texture); 597 array_spu.child.ClientActiveTextureARB(texture); 584 598 } 585 599 … … 662 676 const GLvoid *pointer) 663 677 { 664 crStateVertexAttribPointerARB( index, size, type, normalized, stride, pointer ); 678 crStateVertexAttribPointerARB(index, size, type, normalized, stride, pointer); 679 array_spu.child.VertexAttribPointerARB(index, size, type, normalized, stride, pointer); 665 680 } 666 681 … … 703 718 arrayspu_GenBuffersARB( GLsizei n, GLuint * buffers ) 704 719 { 705 crStateGenBuffersARB(n, buffers);720 array_spu.child.GenBuffersARB(n, buffers); 706 721 } 707 722 … … 710 725 { 711 726 crStateDeleteBuffersARB(n, buffers); 727 array_spu.child.DeleteBuffersARB(n, buffers); 712 728 } 713 729 … … 716 732 { 717 733 crStateBindBufferARB(target, buffer); 734 array_spu.child.BindBufferARB(target, buffer); 718 735 } 719 736 … … 721 738 arrayspu_IsBufferARB (GLuint buffer) 722 739 { 723 return crStateIsBufferARB(buffer);740 return array_spu.child.IsBufferARB(buffer); 724 741 } 725 742 … … 728 745 { 729 746 crStateBufferDataARB(target, size, data, usage); 747 array_spu.child.BufferDataARB(target, size, data, usage); 730 748 } 731 749 … … 735 753 { 736 754 crStateBufferSubDataARB(target, offset, size, data); 755 array_spu.child.BufferSubDataARB(target, offset, size, data); 737 756 } 738 757 … … 752 771 arrayspu_UnmapBufferARB(GLenum target) 753 772 { 754 return crStateUnmapBufferARB(target); 773 crStateUnmapBufferARB(target); 774 return array_spu.child.UnmapBufferARB(target); 755 775 } 756 776 -
trunk/src/VBox/Additions/common/crOpenGL/load.c
r20616 r21308 589 589 #endif 590 590 591 strcpy(response, " 3 0 array 1 feedback 2pack");591 strcpy(response, "2 0 feedback 1 pack"); 592 592 spuchain = crStrSplit( response, " " ); 593 593 num_spus = crStrToInt( spuchain[0] ); -
trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_bufferobject.c
r20083 r21308 15 15 packspu_MapBufferARB( GLenum target, GLenum access ) 16 16 { 17 GLint size = -1;18 17 GET_CONTEXT(ctx); 19 18 void *buffer; 19 #if 0 20 20 CRBufferObject *bufObj; 21 GLint size = -1; 21 22 22 23 (void) crStateMapBufferARB( target, access ); … … 52 53 */ 53 54 packspu_GetBufferSubDataARB(target, 0, bufObj->size, buffer); 55 #else 56 CRASSERT(GL_TRUE == ctx->clientState->bufferobject.retainBufferData); 57 buffer = crStateMapBufferARB(target, access); 58 #endif 54 59 55 60 return buffer; 61 } 62 63 void PACKSPU_APIENTRY packspu_GetBufferSubDataARB( GLenum target, GLintptrARB offset, GLsizeiptrARB size, void * data ) 64 { 65 crStateGetBufferSubDataARB(target, offset, size, data); 56 66 } 57 67 … … 60 70 packspu_UnmapBufferARB( GLenum target ) 61 71 { 72 GET_CONTEXT(ctx); 73 74 #if 0 62 75 CRBufferObject *bufObj; 63 GET_CONTEXT(ctx);64 76 65 77 if (target == GL_ARRAY_BUFFER_ARB) { … … 76 88 /* free the buffer / unmap it */ 77 89 crFree(bufObj->pointer); 90 #endif 78 91 79 92 crStateUnmapBufferARB( target ); … … 84 97 85 98 void PACKSPU_APIENTRY 86 packspu_BufferDataARB( GLenum target, GLsizeiptrARB size, 87 const GLvoid * data, GLenum usage ) 99 packspu_BufferDataARB(GLenum target, GLsizeiptrARB size, const GLvoid * data, GLenum usage) 88 100 { 101 /*crDebug("packspu_BufferDataARB size:%d", size);*/ 89 102 crStateBufferDataARB(target, size, data, usage); 90 103 crPackBufferDataARB(target, size, data, usage); 104 } 105 106 void PACKSPU_APIENTRY 107 packspu_BufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid * data) 108 { 109 /*crDebug("packspu_BufferSubDataARB size:%d", size);*/ 110 crStateBufferSubDataARB(target, offset, size, data); 111 crPackBufferSubDataARB(target, offset, size, data); 91 112 } 92 113 -
trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_client.c
r20083 r21308 153 153 } 154 154 #endif 155 156 /*crDebug("packspu_InterleavedArrays");*/ 157 155 158 crStateInterleavedArrays( format, stride, pointer ); 156 159 } … … 160 163 packspu_ArrayElement( GLint index ) 161 164 { 165 #if 0 162 166 GLboolean serverArrays = GL_FALSE; 163 167 164 168 #if CR_ARB_vertex_buffer_object 165 169 GET_CONTEXT(ctx); 170 /*crDebug("packspu_ArrayElement index:%i", index);*/ 166 171 if (ctx->clientState->extensions.ARB_vertex_buffer_object) 167 172 serverArrays = crStateUseServerArrays(); … … 184 189 crPackExpandArrayElement( index, clientState ); 185 190 } 191 #else 192 GET_CONTEXT(ctx); 193 CRClientState *clientState = &(ctx->clientState->client); 194 crPackExpandArrayElement(index, clientState); 195 #endif 186 196 } 187 197 … … 194 204 #if CR_ARB_vertex_buffer_object 195 205 GET_CONTEXT(ctx); 206 /*crDebug("DrawElements count=%d, indices=%p", count, indices);*/ 196 207 if (ctx->clientState->extensions.ARB_vertex_buffer_object) 197 208 serverArrays = crStateUseServerArrays(); … … 212 223 crPackExpandDrawElementsSWAP( mode, count, type, indices, clientState ); 213 224 else 225 { 226 //packspu_Begin(mode); 214 227 crPackExpandDrawElements( mode, count, type, indices, clientState ); 228 //packspu_End(); 229 } 215 230 } 216 231 } … … 224 239 #if CR_ARB_vertex_buffer_object 225 240 GET_CONTEXT(ctx); 241 /*crDebug("DrawRangeElements count=%d", count);*/ 226 242 if (ctx->clientState->extensions.ARB_vertex_buffer_object) 227 243 serverArrays = crStateUseServerArrays(); … … 242 258 crPackExpandDrawRangeElementsSWAP( mode, start, end, count, type, indices, clientState ); 243 259 else 260 { 244 261 crPackExpandDrawRangeElements( mode, start, end, count, type, indices, clientState ); 262 } 245 263 } 246 264 } … … 254 272 #if CR_ARB_vertex_buffer_object 255 273 GET_CONTEXT(ctx); 274 /*crDebug("DrawArrays count=%d", count);*/ 256 275 if (ctx->clientState->extensions.ARB_vertex_buffer_object) 257 276 serverArrays = crStateUseServerArrays(); … … 302 321 void PACKSPU_APIENTRY packspu_EnableClientState( GLenum array ) 303 322 { 304 crStateEnableClientState( array ); 323 crStateEnableClientState(array); 324 crPackEnableClientState(array); 305 325 } 306 326 307 327 void PACKSPU_APIENTRY packspu_DisableClientState( GLenum array ) 308 328 { 309 crStateDisableClientState( array ); 329 crStateDisableClientState(array); 330 crPackDisableClientState(array); 310 331 } 311 332 312 333 void PACKSPU_APIENTRY packspu_ClientActiveTextureARB( GLenum texUnit ) 313 334 { 314 crStateClientActiveTextureARB( texUnit ); 315 /* XXX also send to server for texcoord arrays? */ 316 } 317 335 crStateClientActiveTextureARB(texUnit); 336 crPackClientActiveTextureARB(texUnit); 337 } 338 339 void PACKSPU_APIENTRY packspu_EnableVertexAttribArrayARB(GLuint index) 340 { 341 crStateEnableVertexAttribArrayARB(index); 342 crPackEnableVertexAttribArrayARB(index); 343 } 344 345 346 void PACKSPU_APIENTRY packspu_DisableVertexAttribArrayARB(GLuint index) 347 { 348 crStateDisableVertexAttribArrayARB(index); 349 crPackDisableVertexAttribArrayARB(index); 350 } 318 351 319 352 void PACKSPU_APIENTRY packspu_Enable( GLenum cap ) 320 353 { 321 switch (cap) { 322 case GL_VERTEX_ARRAY: 323 case GL_NORMAL_ARRAY: 324 case GL_COLOR_ARRAY: 325 case GL_INDEX_ARRAY: 326 case GL_TEXTURE_COORD_ARRAY: 327 case GL_EDGE_FLAG_ARRAY: 328 case GL_FOG_COORDINATE_ARRAY_EXT: 329 case GL_SECONDARY_COLOR_ARRAY_EXT: 330 #if CR_NV_vertex_program 331 case GL_VERTEX_ATTRIB_ARRAY0_NV: 332 case GL_VERTEX_ATTRIB_ARRAY1_NV: 333 case GL_VERTEX_ATTRIB_ARRAY2_NV: 334 case GL_VERTEX_ATTRIB_ARRAY3_NV: 335 case GL_VERTEX_ATTRIB_ARRAY4_NV: 336 case GL_VERTEX_ATTRIB_ARRAY5_NV: 337 case GL_VERTEX_ATTRIB_ARRAY6_NV: 338 case GL_VERTEX_ATTRIB_ARRAY7_NV: 339 case GL_VERTEX_ATTRIB_ARRAY8_NV: 340 case GL_VERTEX_ATTRIB_ARRAY9_NV: 341 case GL_VERTEX_ATTRIB_ARRAY10_NV: 342 case GL_VERTEX_ATTRIB_ARRAY11_NV: 343 case GL_VERTEX_ATTRIB_ARRAY12_NV: 344 case GL_VERTEX_ATTRIB_ARRAY13_NV: 345 case GL_VERTEX_ATTRIB_ARRAY14_NV: 346 case GL_VERTEX_ATTRIB_ARRAY15_NV: 347 #endif /* CR_NV_vertex_program */ 348 crStateEnableClientState(cap); 349 break; 350 default: 351 ; 352 } 354 crStateEnable(cap); 353 355 354 356 if (pack_spu.swap) … … 361 363 void PACKSPU_APIENTRY packspu_Disable( GLenum cap ) 362 364 { 363 switch (cap) { 364 case GL_VERTEX_ARRAY: 365 case GL_NORMAL_ARRAY: 366 case GL_COLOR_ARRAY: 367 case GL_INDEX_ARRAY: 368 case GL_TEXTURE_COORD_ARRAY: 369 case GL_EDGE_FLAG_ARRAY: 370 case GL_FOG_COORDINATE_ARRAY_EXT: 371 case GL_SECONDARY_COLOR_ARRAY_EXT: 372 #if CR_NV_vertex_program 373 case GL_VERTEX_ATTRIB_ARRAY0_NV: 374 case GL_VERTEX_ATTRIB_ARRAY1_NV: 375 case GL_VERTEX_ATTRIB_ARRAY2_NV: 376 case GL_VERTEX_ATTRIB_ARRAY3_NV: 377 case GL_VERTEX_ATTRIB_ARRAY4_NV: 378 case GL_VERTEX_ATTRIB_ARRAY5_NV: 379 case GL_VERTEX_ATTRIB_ARRAY6_NV: 380 case GL_VERTEX_ATTRIB_ARRAY7_NV: 381 case GL_VERTEX_ATTRIB_ARRAY8_NV: 382 case GL_VERTEX_ATTRIB_ARRAY9_NV: 383 case GL_VERTEX_ATTRIB_ARRAY10_NV: 384 case GL_VERTEX_ATTRIB_ARRAY11_NV: 385 case GL_VERTEX_ATTRIB_ARRAY12_NV: 386 case GL_VERTEX_ATTRIB_ARRAY13_NV: 387 case GL_VERTEX_ATTRIB_ARRAY14_NV: 388 case GL_VERTEX_ATTRIB_ARRAY15_NV: 389 #endif /* CR_NV_vertex_program */ 390 crStateDisableClientState(cap); 391 break; 392 default: 393 ; 394 } 365 crStateDisable(cap); 395 366 396 367 if (pack_spu.swap) … … 400 371 } 401 372 373 GLboolean PACKSPU_APIENTRY packspu_IsEnabled(GLenum cap) 374 { 375 GLboolean res = crStateIsEnabled(cap); 376 #ifdef DEBUG 377 { 378 GET_THREAD(thread); 379 int writeback = 1; 380 GLboolean return_val = (GLboolean) 0; 381 crPackIsEnabled(cap, &return_val, &writeback); 382 packspuFlush( (void *) thread ); 383 while (writeback) 384 crNetRecv(); 385 CRASSERT(return_val==res); 386 } 387 #endif 388 389 return res; 390 } 402 391 403 392 void PACKSPU_APIENTRY packspu_PushClientAttrib( GLbitfield mask ) 404 393 { 405 394 crStatePushClientAttrib(mask); 395 crPackPushClientAttrib(mask); 406 396 } 407 397 … … 409 399 { 410 400 crStatePopClientAttrib(); 411 } 401 crPackPopClientAttrib(); 402 } -
trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_context.c
r21127 r21308 163 163 /* XXX fix-up sharedCtx param here */ 164 164 pack_spu.context[slot].clientState = crStateCreateContext(NULL, visual, NULL); 165 pack_spu.context[slot].clientState->bufferobject.retainBufferData = GL_TRUE; 165 166 pack_spu.context[slot].serverCtx = serverCtx; 166 167 … … 227 228 crPackSetContext( thread->packer ); 228 229 crStateMakeCurrent( newCtx->clientState ); 230 //crStateSetCurrentPointers(newCtx->clientState, &thread->packer->current); 229 231 serverCtx = pack_spu.context[slot].serverCtx; 230 232 } -
trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_get.py
r20084 r21308 69 69 print '\t}' 70 70 if func_name in simple_funcs: 71 print '\tif (pname == GL_UNPACK_ALIGNMENT ||' 72 print '\t\tpname == GL_UNPACK_ROW_LENGTH ||' 73 print '\t\tpname == GL_UNPACK_SKIP_PIXELS ||' 74 print '\t\tpname == GL_UNPACK_LSB_FIRST ||' 75 print '\t\tpname == GL_UNPACK_SWAP_BYTES ||' 76 print '#ifdef CR_OPENGL_VERSION_1_2' 77 print '\t\tpname == GL_UNPACK_IMAGE_HEIGHT ||' 78 print '#endif' 79 print '\t\tpname == GL_UNPACK_SKIP_ROWS ||' 80 print '\t\tpname == GL_PACK_ALIGNMENT ||' 81 print '\t\tpname == GL_PACK_ROW_LENGTH ||' 82 print '\t\tpname == GL_PACK_SKIP_PIXELS ||' 83 print '\t\tpname == GL_PACK_LSB_FIRST ||' 84 print '\t\tpname == GL_PACK_SWAP_BYTES ||' 85 print '#ifdef CR_OPENGL_VERSION_1_2' 86 print '\t\tpname == GL_PACK_IMAGE_HEIGHT ||' 87 print '#endif' 88 print '\t\tpname == GL_PACK_SKIP_ROWS' 89 print '\t\t|| pname == GL_DRAW_BUFFER' 90 print '#ifdef CR_OPENGL_VERSION_1_3' 91 print '\t\t|| pname == GL_ACTIVE_TEXTURE' 92 print '#endif' 93 print '#ifdef CR_ARB_multitexture' 94 print '\t\t|| pname == GL_ACTIVE_TEXTURE_ARB' 95 print '#endif' 96 print ') {' 97 print '\t\t\tcrState%s( pname, params );' % func_name 98 print '\t\t\treturn;' 99 print '\t}' 71 print """ 72 if (pname == GL_UNPACK_ALIGNMENT 73 || pname == GL_UNPACK_ROW_LENGTH 74 || pname == GL_UNPACK_SKIP_PIXELS 75 || pname == GL_UNPACK_LSB_FIRST 76 || pname == GL_UNPACK_SWAP_BYTES 77 #ifdef CR_OPENGL_VERSION_1_2 78 || pname == GL_UNPACK_IMAGE_HEIGHT 79 #endif 80 || pname == GL_UNPACK_SKIP_ROWS 81 || pname == GL_PACK_ALIGNMENT 82 || pname == GL_PACK_ROW_LENGTH 83 || pname == GL_PACK_SKIP_PIXELS 84 || pname == GL_PACK_LSB_FIRST 85 || pname == GL_PACK_SWAP_BYTES 86 #ifdef CR_OPENGL_VERSION_1_2 87 || pname == GL_PACK_IMAGE_HEIGHT 88 #endif 89 || pname == GL_PACK_SKIP_ROWS 90 || pname == GL_DRAW_BUFFER 91 #ifdef CR_OPENGL_VERSION_1_3 92 || pname == GL_ACTIVE_TEXTURE 93 #endif 94 #ifdef CR_ARB_multitexture 95 || pname == GL_ACTIVE_TEXTURE_ARB 96 #endif 97 ) 98 { 99 crState%s( pname, params ); 100 return; 101 } 102 """ % func_name 100 103 params.append( ("&writeback", "foo", 0) ) 101 104 print '\tif (pack_spu.swap)' -
trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_special
r20467 r21308 72 72 GetAttachedObjectsARB 73 73 GetInfoLogARB 74 BufferSubDataARB 75 EnableVertexAttribArrayARB 76 DisableVertexAttribArrayARB 77 GetBufferSubDataARB 78 IsEnabled -
trunk/src/VBox/GuestHost/OpenGL/glapi_parser/APIspec.txt
r20467 r21308 3366 3366 category 1.1 3367 3367 props setclient 3368 chromium 3368 chromium extpack 3369 3369 3370 3370 name PushClientAttrib … … 3373 3373 category 1.1 3374 3374 props setclient 3375 chromium 3375 chromium extpack 3376 3376 3377 3377 -
trunk/src/VBox/GuestHost/OpenGL/packer/pack_client.c
r21306 r21308 8 8 #include "cr_opcodes.h" 9 9 #include "cr_version.h" 10 #include "state/cr_limits.h" 11 #include "cr_glstate.h" 12 13 /*Convert from GLint to GLfloat in [-1.f,1.f]*/ 14 #define CRP_I2F_NORM(i) ((2.f*((GLint)(i))+1.f) * (1.f/4294967294.f)) 15 /*Convert from GLshort to GLfloat in [-1.f,1.f]*/ 16 #define CRP_S2F_NORM(s) ((2.f*((GLshort)(s))+1.f) * (1.f/65535.f)) 17 18 19 static void crPackVertexAttrib(const CRVertexArrays *array, unsigned int attr, GLint index) 20 { 21 GLint *iPtr; 22 GLshort *sPtr; 23 unsigned char *p = array->a[attr].p + index * array->a[attr].stride; 24 25 #ifdef CR_ARB_vertex_buffer_object 26 if (array->a[attr].buffer && array->a[attr].buffer->data) 27 { 28 p = (unsigned char *)(array->a[attr].buffer->data) + (unsigned long)p; 29 } 30 #endif 31 switch (array->a[attr].type) 32 { 33 case GL_SHORT: 34 sPtr = (GLshort*) p; 35 switch (array->a[attr].size) 36 { 37 case 1: 38 if (array->a[attr].normalized) 39 crPackVertexAttrib1fARB(attr, CRP_S2F_NORM(sPtr[0])); 40 else 41 crPackVertexAttrib1svARB(attr, sPtr); 42 break; 43 case 2: 44 if (array->a[attr].normalized) 45 crPackVertexAttrib2fARB(attr, CRP_S2F_NORM(sPtr[0]), CRP_S2F_NORM(sPtr[1])); 46 else 47 crPackVertexAttrib2svARB(attr, sPtr); 48 break; 49 case 3: 50 if (array->a[attr].normalized) 51 crPackVertexAttrib3fARB(attr, CRP_S2F_NORM(sPtr[0]), CRP_S2F_NORM(sPtr[1]), CRP_S2F_NORM(sPtr[2])); 52 else 53 crPackVertexAttrib3svARB(attr, sPtr); 54 break; 55 case 4: 56 if (array->a[attr].normalized) 57 crPackVertexAttrib4NsvARB(attr, sPtr); 58 else 59 crPackVertexAttrib4svARB(attr, sPtr); 60 break; 61 } 62 break; 63 case GL_INT: 64 iPtr = (GLint*) p; 65 switch (array->a[attr].size) 66 { 67 case 1: 68 if (array->a[attr].normalized) 69 crPackVertexAttrib1fARB(attr, CRP_I2F_NORM(iPtr[0])); 70 else 71 crPackVertexAttrib1fARB(attr, iPtr[0]); 72 break; 73 case 2: 74 if (array->a[attr].normalized) 75 crPackVertexAttrib2fARB(attr, CRP_I2F_NORM(iPtr[0]), CRP_I2F_NORM(iPtr[1])); 76 else 77 crPackVertexAttrib2fARB(attr, iPtr[0], iPtr[1]); 78 break; 79 case 3: 80 if (array->a[attr].normalized) 81 crPackVertexAttrib3fARB(attr, CRP_I2F_NORM(iPtr[0]), CRP_I2F_NORM(iPtr[1]), CRP_I2F_NORM(iPtr[2])); 82 else 83 crPackVertexAttrib3fARB(attr, iPtr[0], iPtr[1], iPtr[2]); 84 break; 85 case 4: 86 if (array->a[attr].normalized) 87 crPackVertexAttrib4NivARB(attr, iPtr); 88 else 89 crPackVertexAttrib4fARB(attr, iPtr[0], iPtr[1], iPtr[2], iPtr[3]); 90 break; 91 } 92 break; 93 case GL_FLOAT: 94 switch (array->a[attr].size) 95 { 96 case 1: crPackVertexAttrib1fvARB(attr, (GLfloat *)p); break; 97 case 2: crPackVertexAttrib2fvARB(attr, (GLfloat *)p); break; 98 case 3: crPackVertexAttrib3fvARB(attr, (GLfloat *)p); break; 99 case 4: crPackVertexAttrib4fvARB(attr, (GLfloat *)p); break; 100 } 101 break; 102 case GL_DOUBLE: 103 switch (array->a[attr].size) 104 { 105 case 1: crPackVertexAttrib1dvARB(attr, (GLdouble *)p); break; 106 case 2: crPackVertexAttrib2dvARB(attr, (GLdouble *)p); break; 107 case 3: crPackVertexAttrib3dvARB(attr, (GLdouble *)p); break; 108 case 4: crPackVertexAttrib4dvARB(attr, (GLdouble *)p); break; 109 } 110 break; 111 default: 112 crWarning("Bad datatype for vertex attribute [%d] array: 0x%x\n", 113 attr, array->a[attr].type); 114 } 115 } 10 116 11 117 /* … … 16 122 { 17 123 unsigned char *p; 18 int unit; 19 20 if (c->array.e.enabled) 21 { 22 crPackEdgeFlagv(c->array.e.p + index * c->array.e.stride); 23 } 24 for (unit = 0; unit < CR_MAX_TEXTURE_UNITS; unit++) 25 { 26 if (c->array.t[unit].enabled) 27 { 28 p = c->array.t[unit].p + index * c->array.t[unit].stride; 29 switch (c->array.t[unit].type) 30 { 31 case GL_SHORT: 32 switch (c->array.t[c->curClientTextureUnit].size) 33 { 34 case 1: crPackMultiTexCoord1svARB(GL_TEXTURE0_ARB + unit, (GLshort *)p); break; 35 case 2: crPackMultiTexCoord2svARB(GL_TEXTURE0_ARB + unit, (GLshort *)p); break; 36 case 3: crPackMultiTexCoord3svARB(GL_TEXTURE0_ARB + unit, (GLshort *)p); break; 37 case 4: crPackMultiTexCoord4svARB(GL_TEXTURE0_ARB + unit, (GLshort *)p); break; 38 } 39 break; 40 case GL_INT: 41 switch (c->array.t[c->curClientTextureUnit].size) 42 { 43 case 1: crPackMultiTexCoord1ivARB(GL_TEXTURE0_ARB + unit, (GLint *)p); break; 44 case 2: crPackMultiTexCoord2ivARB(GL_TEXTURE0_ARB + unit, (GLint *)p); break; 45 case 3: crPackMultiTexCoord3ivARB(GL_TEXTURE0_ARB + unit, (GLint *)p); break; 46 case 4: crPackMultiTexCoord4ivARB(GL_TEXTURE0_ARB + unit, (GLint *)p); break; 47 } 48 break; 49 case GL_FLOAT: 50 switch (c->array.t[c->curClientTextureUnit].size) 51 { 52 case 1: crPackMultiTexCoord1fvARB(GL_TEXTURE0_ARB + unit, (GLfloat *)p); break; 53 case 2: crPackMultiTexCoord2fvARB(GL_TEXTURE0_ARB + unit, (GLfloat *)p); break; 54 case 3: crPackMultiTexCoord3fvARB(GL_TEXTURE0_ARB + unit, (GLfloat *)p); break; 55 case 4: crPackMultiTexCoord4fvARB(GL_TEXTURE0_ARB + unit, (GLfloat *)p); break; 56 } 57 break; 58 case GL_DOUBLE: 59 switch (c->array.t[c->curClientTextureUnit].size) 60 { 61 case 1: crPackMultiTexCoord1dvARB(GL_TEXTURE0_ARB + unit, (GLdouble *)p); break; 62 case 2: crPackMultiTexCoord2dvARB(GL_TEXTURE0_ARB + unit, (GLdouble *)p); break; 63 case 3: crPackMultiTexCoord3dvARB(GL_TEXTURE0_ARB + unit, (GLdouble *)p); break; 64 case 4: crPackMultiTexCoord4dvARB(GL_TEXTURE0_ARB + unit, (GLdouble *)p); break; 65 } 66 break; 67 } 68 } 69 } /* loop over texture units */ 70 71 if (c->array.i.enabled) 72 { 73 p = c->array.i.p + index * c->array.i.stride; 74 switch (c->array.i.type) 75 { 76 case GL_SHORT: crPackIndexsv((GLshort *)p); break; 77 case GL_INT: crPackIndexiv((GLint *)p); break; 78 case GL_FLOAT: crPackIndexfv((GLfloat *)p); break; 79 case GL_DOUBLE: crPackIndexdv((GLdouble *)p); break; 80 } 81 } 82 if (c->array.c.enabled) 83 { 84 p = c->array.c.p + index * c->array.c.stride; 85 switch (c->array.c.type) 86 { 87 case GL_BYTE: 88 switch (c->array.c.size) 89 { 90 case 3: crPackColor3bv((GLbyte *)p); break; 91 case 4: crPackColor4bv((GLbyte *)p); break; 92 } 93 break; 94 case GL_UNSIGNED_BYTE: 95 switch (c->array.c.size) 96 { 97 case 3: crPackColor3ubv((GLubyte *)p); break; 98 case 4: crPackColor4ubv((GLubyte *)p); break; 99 } 100 break; 101 case GL_SHORT: 102 switch (c->array.c.size) 103 { 104 case 3: crPackColor3sv((GLshort *)p); break; 105 case 4: crPackColor4sv((GLshort *)p); break; 106 } 107 break; 108 case GL_UNSIGNED_SHORT: 109 switch (c->array.c.size) 110 { 111 case 3: crPackColor3usv((GLushort *)p); break; 112 case 4: crPackColor4usv((GLushort *)p); break; 113 } 114 break; 115 case GL_INT: 116 switch (c->array.c.size) 117 { 118 case 3: crPackColor3iv((GLint *)p); break; 119 case 4: crPackColor4iv((GLint *)p); break; 120 } 121 break; 122 case GL_UNSIGNED_INT: 123 switch (c->array.c.size) 124 { 125 case 3: crPackColor3uiv((GLuint *)p); break; 126 case 4: crPackColor4uiv((GLuint *)p); break; 127 } 128 break; 129 case GL_FLOAT: 130 switch (c->array.c.size) 131 { 132 case 3: crPackColor3fv((GLfloat *)p); break; 133 case 4: crPackColor4fv((GLfloat *)p); break; 134 } 135 break; 136 case GL_DOUBLE: 137 switch (c->array.c.size) 138 { 139 case 3: crPackColor3dv((GLdouble *)p); break; 140 case 4: crPackColor4dv((GLdouble *)p); break; 141 } 142 break; 143 } 144 } 145 if (c->array.n.enabled) 146 { 147 p = c->array.n.p + index * c->array.n.stride; 148 switch (c->array.n.type) 124 unsigned int unit, attr; 125 const CRVertexArrays *array = &(c->array); 126 const GLboolean vpEnabled = crStateGetCurrent()->program.vpEnabled; 127 128 if (array->n.enabled && !(vpEnabled && array->a[VERT_ATTRIB_NORMAL].enabled)) 129 { 130 p = array->n.p + index * array->n.stride; 131 132 #ifdef CR_ARB_vertex_buffer_object 133 if (array->n.buffer && array->n.buffer->data) 134 { 135 p = (unsigned char *)(array->n.buffer->data) + (unsigned long)p; 136 } 137 #endif 138 139 switch (array->n.type) 149 140 { 150 141 case GL_BYTE: crPackNormal3bv((GLbyte *)p); break; … … 155 146 } 156 147 } 148 149 if (array->c.enabled && !(vpEnabled && array->a[VERT_ATTRIB_COLOR0].enabled)) 150 { 151 p = array->c.p + index * array->c.stride; 152 153 #ifdef CR_ARB_vertex_buffer_object 154 if (array->c.buffer && array->c.buffer->data) 155 { 156 p = (unsigned char *)(array->c.buffer->data) + (unsigned long)p; 157 } 158 #endif 159 160 switch (array->c.type) 161 { 162 case GL_BYTE: 163 switch (c->array.c.size) 164 { 165 case 3: crPackColor3bv((GLbyte *)p); break; 166 case 4: crPackColor4bv((GLbyte *)p); break; 167 } 168 break; 169 case GL_UNSIGNED_BYTE: 170 switch (c->array.c.size) 171 { 172 case 3: crPackColor3ubv((GLubyte *)p); break; 173 case 4: crPackColor4ubv((GLubyte *)p); break; 174 } 175 break; 176 case GL_SHORT: 177 switch (c->array.c.size) 178 { 179 case 3: crPackColor3sv((GLshort *)p); break; 180 case 4: crPackColor4sv((GLshort *)p); break; 181 } 182 break; 183 case GL_UNSIGNED_SHORT: 184 switch (c->array.c.size) 185 { 186 case 3: crPackColor3usv((GLushort *)p); break; 187 case 4: crPackColor4usv((GLushort *)p); break; 188 } 189 break; 190 case GL_INT: 191 switch (c->array.c.size) 192 { 193 case 3: crPackColor3iv((GLint *)p); break; 194 case 4: crPackColor4iv((GLint *)p); break; 195 } 196 break; 197 case GL_UNSIGNED_INT: 198 switch (c->array.c.size) 199 { 200 case 3: crPackColor3uiv((GLuint *)p); break; 201 case 4: crPackColor4uiv((GLuint *)p); break; 202 } 203 break; 204 case GL_FLOAT: 205 switch (c->array.c.size) 206 { 207 case 3: crPackColor3fv((GLfloat *)p); break; 208 case 4: crPackColor4fv((GLfloat *)p); break; 209 } 210 break; 211 case GL_DOUBLE: 212 switch (c->array.c.size) 213 { 214 case 3: crPackColor3dv((GLdouble *)p); break; 215 case 4: crPackColor4dv((GLdouble *)p); break; 216 } 217 break; 218 } 219 } 220 157 221 #ifdef CR_EXT_secondary_color 158 if (c->array.s.enabled) 159 { 160 p = c->array.s.p + index * c->array.s.stride; 161 switch (c->array.s.type) 222 if (array->s.enabled && !(vpEnabled && array->a[VERT_ATTRIB_COLOR1].enabled)) 223 { 224 p = array->s.p + index * array->s.stride; 225 226 #ifdef CR_ARB_vertex_buffer_object 227 if (array->s.buffer && array->s.buffer->data) 228 { 229 p = (unsigned char *)(array->s.buffer->data) + (unsigned long)p; 230 } 231 #endif 232 233 switch (array->s.type) 162 234 { 163 235 case GL_BYTE: … … 179 251 } 180 252 } 181 #endif 182 if (c->array.v.enabled) 183 { 184 p = c->array.v.p + (index * c->array.v.stride); 185 switch (c->array.v.type) 253 #endif // CR_EXT_secondary_color 254 255 256 #ifdef CR_EXT_fog_coord 257 if (array->f.enabled && !(vpEnabled && array->a[VERT_ATTRIB_FOG].enabled)) 258 { 259 p = array->f.p + index * array->f.stride; 260 261 #ifdef CR_ARB_vertex_buffer_object 262 if (array->f.buffer && array->f.buffer->data) 263 { 264 p = (unsigned char *)(array->f.buffer->data) + (unsigned long)p; 265 } 266 #endif 267 crPackFogCoordfEXT( *((GLfloat *) p) ); 268 } 269 #endif // CR_EXT_fog_coord 270 271 for (unit = 0 ; unit < CR_MAX_TEXTURE_UNITS ; unit++) 272 { 273 if (array->t[unit].enabled && !(vpEnabled && array->a[VERT_ATTRIB_TEX0+unit].enabled)) 274 { 275 p = array->t[unit].p + index * array->t[unit].stride; 276 277 #ifdef CR_ARB_vertex_buffer_object 278 if (array->t[unit].buffer && array->t[unit].buffer->data) 279 { 280 p = (unsigned char *)(array->t[unit].buffer->data) + (unsigned long)p; 281 } 282 #endif 283 284 switch (array->t[unit].type) 285 { 286 case GL_SHORT: 287 switch (array->t[unit].size) 288 { 289 case 1: crPackMultiTexCoord1svARB(GL_TEXTURE0_ARB + unit, (GLshort *)p); break; 290 case 2: crPackMultiTexCoord2svARB(GL_TEXTURE0_ARB + unit, (GLshort *)p); break; 291 case 3: crPackMultiTexCoord3svARB(GL_TEXTURE0_ARB + unit, (GLshort *)p); break; 292 case 4: crPackMultiTexCoord4svARB(GL_TEXTURE0_ARB + unit, (GLshort *)p); break; 293 } 294 break; 295 case GL_INT: 296 switch (array->t[unit].size) 297 { 298 case 1: crPackMultiTexCoord1ivARB(GL_TEXTURE0_ARB + unit, (GLint *)p); break; 299 case 2: crPackMultiTexCoord2ivARB(GL_TEXTURE0_ARB + unit, (GLint *)p); break; 300 case 3: crPackMultiTexCoord3ivARB(GL_TEXTURE0_ARB + unit, (GLint *)p); break; 301 case 4: crPackMultiTexCoord4ivARB(GL_TEXTURE0_ARB + unit, (GLint *)p); break; 302 } 303 break; 304 case GL_FLOAT: 305 switch (array->t[unit].size) 306 { 307 case 1: crPackMultiTexCoord1fvARB(GL_TEXTURE0_ARB + unit, (GLfloat *)p); break; 308 case 2: crPackMultiTexCoord2fvARB(GL_TEXTURE0_ARB + unit, (GLfloat *)p); break; 309 case 3: crPackMultiTexCoord3fvARB(GL_TEXTURE0_ARB + unit, (GLfloat *)p); break; 310 case 4: crPackMultiTexCoord4fvARB(GL_TEXTURE0_ARB + unit, (GLfloat *)p); break; 311 } 312 break; 313 case GL_DOUBLE: 314 switch (array->t[unit].size) 315 { 316 case 1: crPackMultiTexCoord1dvARB(GL_TEXTURE0_ARB + unit, (GLdouble *)p); break; 317 case 2: crPackMultiTexCoord2dvARB(GL_TEXTURE0_ARB + unit, (GLdouble *)p); break; 318 case 3: crPackMultiTexCoord3dvARB(GL_TEXTURE0_ARB + unit, (GLdouble *)p); break; 319 case 4: crPackMultiTexCoord4dvARB(GL_TEXTURE0_ARB + unit, (GLdouble *)p); break; 320 } 321 break; 322 } 323 } 324 } 325 326 if (array->i.enabled) 327 { 328 p = array->i.p + index * array->i.stride; 329 330 #ifdef CR_ARB_vertex_buffer_object 331 if (array->i.buffer && array->i.buffer->data) 332 { 333 p = (unsigned char *)(array->i.buffer->data) + (unsigned long)p; 334 } 335 #endif 336 337 switch (array->i.type) 338 { 339 case GL_SHORT: crPackIndexsv((GLshort *)p); break; 340 case GL_INT: crPackIndexiv((GLint *)p); break; 341 case GL_FLOAT: crPackIndexfv((GLfloat *)p); break; 342 case GL_DOUBLE: crPackIndexdv((GLdouble *)p); break; 343 } 344 } 345 346 if (array->e.enabled) 347 { 348 p = array->e.p + index * array->e.stride; 349 350 #ifdef CR_ARB_vertex_buffer_object 351 if (array->e.buffer && array->e.buffer->data) 352 { 353 p = (unsigned char *)(array->e.buffer->data) + (unsigned long)p; 354 } 355 #endif 356 357 crPackEdgeFlagv(p); 358 } 359 360 for (attr = 1; attr < VERT_ATTRIB_MAX; attr++) 361 { 362 if (array->a[attr].enabled) 363 { 364 crPackVertexAttrib(array, attr, index); 365 } 366 } 367 368 if (array->a[VERT_ATTRIB_POS].enabled) 369 { 370 crPackVertexAttrib(array, 0, index); 371 } 372 else if (array->v.enabled) 373 { 374 p = array->v.p + index * array->v.stride; 375 376 #ifdef CR_ARB_vertex_buffer_object 377 if (array->v.buffer && array->v.buffer->data) 378 { 379 p = (unsigned char *)(array->v.buffer->data) + (unsigned long)p; 380 } 381 #endif 382 switch (array->v.type) 186 383 { 187 384 case GL_SHORT: 188 385 switch (c->array.v.size) 189 386 { 190 case 2: crPackVertex2sv BBOX_COUNT((GLshort *)p); break;191 case 3: crPackVertex3sv BBOX_COUNT((GLshort *)p); break;192 case 4: crPackVertex4sv BBOX_COUNT((GLshort *)p); break;387 case 2: crPackVertex2sv((GLshort *)p); break; 388 case 3: crPackVertex3sv((GLshort *)p); break; 389 case 4: crPackVertex4sv((GLshort *)p); break; 193 390 } 194 391 break; … … 196 393 switch (c->array.v.size) 197 394 { 198 case 2: crPackVertex2iv BBOX_COUNT((GLint *)p); break;199 case 3: crPackVertex3iv BBOX_COUNT((GLint *)p); break;200 case 4: crPackVertex4iv BBOX_COUNT((GLint *)p); break;395 case 2: crPackVertex2iv((GLint *)p); break; 396 case 3: crPackVertex3iv((GLint *)p); break; 397 case 4: crPackVertex4iv((GLint *)p); break; 201 398 } 202 399 break; … … 204 401 switch (c->array.v.size) 205 402 { 206 case 2: crPackVertex2fv BBOX_COUNT((GLfloat *)p); break;207 case 3: crPackVertex3fv BBOX_COUNT((GLfloat *)p); break;208 case 4: crPackVertex4fv BBOX_COUNT((GLfloat *)p); break;403 case 2: crPackVertex2fv((GLfloat *)p); break; 404 case 3: crPackVertex3fv((GLfloat *)p); break; 405 case 4: crPackVertex4fv((GLfloat *)p); break; 209 406 } 210 407 break; … … 212 409 switch (c->array.v.size) 213 410 { 214 case 2: crPackVertex2dv BBOX_COUNT((GLdouble *)p); break;215 case 3: crPackVertex3dv BBOX_COUNT((GLdouble *)p); break;216 case 4: crPackVertex4dv BBOX_COUNT((GLdouble *)p); break;411 case 2: crPackVertex2dv((GLdouble *)p); break; 412 case 3: crPackVertex3dv((GLdouble *)p); break; 413 case 4: crPackVertex4dv((GLdouble *)p); break; 217 414 } 218 415 break; … … 247 444 } 248 445 249 250 /* 251 * Really pack glDrawElements (for server-side vertex arrays) 252 * Note: we pack the pointer (which is actually an index into the server-side 253 * vertex buffer) and not the actual indices. 254 */ 446 static GLsizei crPackElementsIndexSize(GLenum type) 447 { 448 switch (type) 449 { 450 case GL_UNSIGNED_BYTE: 451 return sizeof(GLubyte); 452 case GL_UNSIGNED_SHORT: 453 return sizeof(GLushort); 454 case GL_UNSIGNED_INT: 455 return sizeof(GLuint); 456 default: 457 crError("Unknown type 0x%x in crPackElementsIndexSize", type); 458 return 0; 459 } 460 } 461 255 462 void PACK_APIENTRY 256 463 crPackDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) 257 464 { 258 unsigned char *data_ptr ;465 unsigned char *data_ptr, *start_ptr; 259 466 int packet_length = sizeof(int) + sizeof(mode) + sizeof(count) + sizeof(type) + sizeof(GLintptrARB); 260 data_ptr = (unsigned char *) crPackAlloc(packet_length); 261 WRITE_DATA( 0, GLenum, CR_DRAWELEMENTS_EXTEND_OPCODE ); 262 WRITE_DATA( 4, GLenum, mode ); 263 WRITE_DATA( 8, GLsizei, count); 264 WRITE_DATA( 12, GLenum, type); 265 WRITE_DATA( 16, GLsizeiptrARB, (GLsizeiptrARB) indices ); 266 crHugePacket( CR_EXTEND_OPCODE, data_ptr ); 267 crPackFree( data_ptr ); 467 GLsizei indexsize; 468 #ifdef CR_ARB_vertex_buffer_object 469 CRBufferObject *elementsBuffer = crStateGetCurrent()->bufferobject.elementsBuffer; 470 packet_length += sizeof(GLboolean); 471 if (elementsBuffer && elementsBuffer->name) 472 { 473 /*@todo not sure it's possible, and not sure what to do*/ 474 if (!elementsBuffer->data) 475 { 476 crWarning("crPackDrawElements: trying to use bound but empty elements buffer, ignoring."); 477 return; 478 } 479 indexsize = 0; 480 } 481 else 482 #endif 483 { 484 indexsize = crPackElementsIndexSize(type); 485 } 486 487 packet_length += count * indexsize; 488 489 start_ptr = data_ptr = (unsigned char *) crPackAlloc(packet_length); 490 WRITE_DATA_AI(GLenum, CR_DRAWELEMENTS_EXTEND_OPCODE ); 491 WRITE_DATA_AI(GLenum, mode ); 492 WRITE_DATA_AI(GLsizei, count); 493 WRITE_DATA_AI(GLenum, type); 494 WRITE_DATA_AI(GLsizeiptrARB, (GLsizeiptrARB) indices ); 495 #ifdef CR_ARB_vertex_buffer_object 496 WRITE_DATA_AI(GLboolean, (GLboolean) indexsize>0); 497 #endif 498 if (indexsize>0) 499 { 500 crMemcpy(data_ptr, indices, count * indexsize); 501 } 502 crHugePacket(CR_EXTEND_OPCODE, start_ptr); 503 crPackFree(start_ptr); 504 } 505 506 void PACK_APIENTRY 507 crPackDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, 508 GLenum type, const GLvoid *indices) 509 { 510 unsigned char *data_ptr, *start_ptr; 511 int packet_length = sizeof(int) + sizeof(mode) + sizeof(start) 512 + sizeof(end) + sizeof(count) + sizeof(type) + sizeof(GLintptrARB); 513 GLsizei indexsize; 514 515 #ifdef CR_ARB_vertex_buffer_object 516 CRBufferObject *elementsBuffer = crStateGetCurrent()->bufferobject.elementsBuffer; 517 packet_length += sizeof(GLboolean); 518 if (elementsBuffer && elementsBuffer->name) 519 { 520 /*@todo not sure it's possible, and not sure what to do*/ 521 if (!elementsBuffer->data) 522 { 523 crWarning("crPackDrawElements: trying to use bound but empty elements buffer, ignoring."); 524 return; 525 } 526 indexsize = 0; 527 } 528 else 529 #endif 530 { 531 indexsize = crPackElementsIndexSize(type); 532 } 533 534 packet_length += count * indexsize; 535 536 start_ptr = data_ptr = (unsigned char *) crPackAlloc(packet_length); 537 WRITE_DATA_AI(GLenum, CR_DRAWRANGEELEMENTS_EXTEND_OPCODE); 538 WRITE_DATA_AI(GLenum, mode); 539 WRITE_DATA_AI(GLuint, start); 540 WRITE_DATA_AI(GLuint, end); 541 WRITE_DATA_AI(GLsizei, count); 542 WRITE_DATA_AI(GLenum, type); 543 WRITE_DATA_AI(GLsizeiptrARB, (GLsizeiptr) indices); 544 #ifdef CR_ARB_vertex_buffer_object 545 WRITE_DATA_AI(GLboolean, (GLboolean) indexsize>0); 546 #endif 547 if (indexsize>0) 548 { 549 crMemcpy(data_ptr, indices, count * indexsize); 550 } 551 crHugePacket(CR_EXTEND_OPCODE, start_ptr); 552 crPackFree(start_ptr); 268 553 } 269 554 … … 278 563 { 279 564 int i; 565 GLubyte *p = (GLubyte *)indices; 566 #ifdef CR_ARB_vertex_buffer_object 567 CRBufferObject *elementsBuffer = crStateGetCurrent()->bufferobject.elementsBuffer; 568 #endif 280 569 281 570 if (count < 0) … … 302 591 } 303 592 593 #ifdef CR_ARB_vertex_buffer_object 594 if (elementsBuffer && elementsBuffer->data) 595 { 596 p = (unsigned char *)(elementsBuffer->data) + (unsigned long)p; 597 } 598 #endif 599 304 600 if (mode != 999) 305 601 crPackBegin(mode); 306 602 307 switch (type) { 308 case GL_UNSIGNED_BYTE: 309 { 310 const GLubyte *p = (const GLubyte *) indices; 311 for (i = 0; i < count; i++) 312 crPackExpandArrayElement(p[i], c); 313 } 314 break; 315 case GL_UNSIGNED_SHORT: 316 { 317 const GLushort *p = (const GLushort *) indices; 603 //crDebug("crPackExpandDrawElements mode:0x%x, count:%d, type:0x%x", mode, count, type); 604 605 switch (type) 606 { 607 case GL_UNSIGNED_BYTE: 318 608 for (i=0; i<count; i++) 319 crPackExpandArrayElement(p[i], c); 320 } 321 break; 322 case GL_UNSIGNED_INT: 323 { 324 const GLuint *p = (const GLuint *) indices; 325 for (i = 0; i < count; i++) 326 crPackExpandArrayElement(p[i], c); 327 } 328 break; 329 default: 330 __PackError( __LINE__, __FILE__, GL_INVALID_ENUM, 331 "crPackDrawElements(bad type)"); 332 break; 609 { 610 crPackExpandArrayElement((GLint) *p++, c); 611 } 612 break; 613 case GL_UNSIGNED_SHORT: 614 for (i=0; i<count; i++) 615 { 616 crPackExpandArrayElement((GLint) * (GLushort *) p, c); 617 p+=sizeof (GLushort); 618 } 619 break; 620 case GL_UNSIGNED_INT: 621 for (i=0; i<count; i++) 622 { 623 crPackExpandArrayElement((GLint) * (GLuint *) p, c); 624 p+=sizeof (GLuint); 625 } 626 break; 627 default: 628 crError( "this can't happen: array_spu.self.DrawElements" ); 629 break; 333 630 } 334 631 … … 379 676 380 677 /* 381 * Really pack glDrawRangeElements (for server-side vertex arrays)382 * Note: we pack the pointer (which is actually an index into the server-side383 * vertex buffer) and not the actual indices.384 */385 void PACK_APIENTRY386 crPackDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count,387 GLenum type, const GLvoid *indices)388 {389 unsigned char *data_ptr;390 int packet_length = sizeof(int) + sizeof(mode) + sizeof(start)391 + sizeof(end) + sizeof(count) + sizeof(type) + sizeof(GLintptrARB);392 393 data_ptr = (unsigned char *) crPackAlloc(packet_length);394 WRITE_DATA( 0, GLenum, CR_DRAWRANGEELEMENTS_EXTEND_OPCODE );395 WRITE_DATA( 4, GLenum, mode );396 WRITE_DATA( 8, GLuint, start );397 WRITE_DATA( 12, GLuint, end );398 WRITE_DATA( 16, GLsizei, count );399 WRITE_DATA( 20, GLenum, type );400 WRITE_DATA( 24, GLsizeiptrARB, (GLsizeiptr) indices );401 crHugePacket( CR_EXTEND_OPCODE, data_ptr );402 crPackFree( data_ptr );403 }404 405 406 /*407 678 * glDrawRangeElements, expanded into crPackBegin/Vertex/End/etc. 408 679 */ … … 410 681 crPackExpandDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, CRClientState *c) 411 682 { 412 int i; 413 GLubyte *p = (GLubyte *)indices; 414 415 (void) end; 416 417 if (count < 0) 418 { 419 __PackError(__LINE__, __FILE__, GL_INVALID_VALUE, "crPackDrawRangeElements(negative count)"); 683 if (start>end) 684 { 685 crWarning("crPackExpandDrawRangeElements start>end (%d>%d)", start, end); 420 686 return; 421 687 } 422 688 423 if (mode > GL_POLYGON) 424 { 425 __PackError(__LINE__, __FILE__, GL_INVALID_ENUM, "crPackDrawRangeElements(bad mode)"); 426 return; 427 } 428 429 if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT && type != GL_UNSIGNED_INT) 430 { 431 __PackError(__LINE__, __FILE__, GL_INVALID_ENUM, "crPackDrawRangeElements(bad type)"); 432 return; 433 } 434 435 crPackBegin(mode); 436 switch (type) 437 { 438 case GL_UNSIGNED_BYTE: 439 for (i=0; i<count; i++) 440 { 441 crPackExpandArrayElement((GLint) *p++, c); 442 } 443 break; 444 case GL_UNSIGNED_SHORT: 445 for (i=0; i<count; i++) 446 { 447 crPackExpandArrayElement((GLint) * (GLushort *) p, c); 448 p += sizeof(GLushort); 449 } 450 break; 451 case GL_UNSIGNED_INT: 452 for (i=0; i<count; i++) 453 { 454 crPackExpandArrayElement((GLint) * (GLuint *) p, c); 455 p += sizeof(GLuint); 456 } 457 break; 458 default: 459 crError( "this can't happen: crPackDrawRangeElements" ); 460 break; 461 } 462 crPackEnd(); 689 crPackExpandDrawElements(mode, count, type, indices, c); 463 690 } 464 691 -
trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_bufferobject.c
r20975 r21308 172 172 DIRTY(bb->elementsBinding, g->neg_bitid); 173 173 } 174 /* XXXcheck bindings with the vertex arrays */174 /* @todo check bindings with the vertex arrays */ 175 175 176 176 crHashtableDelete(b->buffers, buffers[i], crStateFreeBufferObject); -
trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_client.c
r15532 r21308 1312 1312 } 1313 1313 1314 /*Returns if the given clientpointer could be used on server side directly*/ 1315 #define CRSTATE_IS_SERVER_CP(cp) (!(cp).enabled || !(cp).p || ((cp).buffer && (cp).buffer->name)) 1316 1317 static crStateDumpClientPointer(CRClientPointer *cp, const char *name, int i) 1318 { 1319 if (i<0 && cp->enabled) 1320 { 1321 crDebug("CP(%s): enabled:%d ptr:%p buffer:%p buffer.name:%i %s", 1322 name, cp->enabled, cp->p, cp->buffer, cp->buffer? cp->buffer->name:-1, 1323 CRSTATE_IS_SERVER_CP(*cp) ? "":"!FAIL!"); 1324 } 1325 else if (0==i || cp->enabled) 1326 { 1327 crDebug("CP(%s%i): enabled:%d ptr:%p buffer:%p buffer.name:%i %s", 1328 name, i, cp->enabled, cp->p, cp->buffer, cp->buffer? cp->buffer->name:-1, 1329 CRSTATE_IS_SERVER_CP(*cp) ? "":"!FAIL!"); 1330 } 1331 } 1314 1332 1315 1333 /* … … 1323 1341 CRClientState *c = &(g->client); 1324 1342 int i; 1325 1326 if (!c->array.v.enabled) 1327 return GL_FALSE; 1328 1329 if (c->array.v.enabled && (!c->array.v.buffer || !c->array.v.buffer->name)) 1330 return GL_FALSE; 1331 1332 if (c->array.n.enabled && (!c->array.n.buffer || !c->array.n.buffer->name)) 1333 return GL_FALSE; 1334 1335 if (c->array.c.enabled && (!c->array.c.buffer || !c->array.c.buffer->name)) 1336 return GL_FALSE; 1337 1338 if (c->array.i.enabled && (!c->array.i.buffer || !c->array.i.buffer->name)) 1339 return GL_FALSE; 1343 GLboolean res; 1344 1345 res = CRSTATE_IS_SERVER_CP(c->array.v) 1346 && CRSTATE_IS_SERVER_CP(c->array.n) 1347 && CRSTATE_IS_SERVER_CP(c->array.c) 1348 && CRSTATE_IS_SERVER_CP(c->array.i) 1349 && CRSTATE_IS_SERVER_CP(c->array.e) 1350 && CRSTATE_IS_SERVER_CP(c->array.s) 1351 && CRSTATE_IS_SERVER_CP(c->array.f); 1340 1352 1341 1353 for (i = 0; (unsigned int)i < g->limits.maxTextureUnits; i++) 1342 if (c->array.t[i].enabled && (!c->array.t[i].buffer || !c->array.t[i].buffer->name)) 1343 return GL_FALSE; 1344 1345 if (c->array.e.enabled && (!c->array.e.buffer || !c->array.e.buffer->name)) 1346 return GL_FALSE; 1347 1348 if (c->array.s.enabled && (!c->array.s.buffer || !c->array.s.buffer->name)) 1349 return GL_FALSE; 1350 1351 if (c->array.f.enabled && (!c->array.f.buffer || !c->array.f.buffer->name)) 1352 return GL_FALSE; 1354 if (!CRSTATE_IS_SERVER_CP(c->array.t[i])) 1355 { 1356 res = GL_FALSE; 1357 break; 1358 } 1353 1359 1354 1360 for (i = 0; (unsigned int)i < g->limits.maxVertexProgramAttribs; i++) 1355 if (c->array.a[i].enabled && (!c->array.a[i].buffer || !c->array.a[i].buffer->name)) 1356 return GL_FALSE; 1357 1358 return GL_TRUE; 1361 if (!CRSTATE_IS_SERVER_CP(c->array.a[i])) 1362 { 1363 res = GL_FALSE; 1364 break; 1365 } 1366 1367 if (!res) 1368 { 1369 crStateDumpClientPointer(&c->array.v, "v", -1); 1370 crStateDumpClientPointer(&c->array.n, "n", -1); 1371 crStateDumpClientPointer(&c->array.c, "c", -1); 1372 crStateDumpClientPointer(&c->array.i, "i", -1); 1373 crStateDumpClientPointer(&c->array.e, "e", -1); 1374 crStateDumpClientPointer(&c->array.s, "s", -1); 1375 crStateDumpClientPointer(&c->array.f, "f", -1); 1376 for (i = 0; (unsigned int)i < g->limits.maxTextureUnits; i++) 1377 crStateDumpClientPointer(&c->array.t[i], "tex", i); 1378 for (i = 0; (unsigned int)i < g->limits.maxVertexProgramAttribs; i++) 1379 crStateDumpClientPointer(&c->array.a[i], "attrib", i); 1380 crDebug("crStateUseServerArrays->%d", res); 1381 } 1382 1383 return res; 1359 1384 #else 1360 1385 return GL_FALSE; -
trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/get_sizes.py
r20916 r21308 403 403 return temp->num_values; 404 404 } 405 cr Warning( "Invalid pname to __numValues: 0x%x\\n", (int) pname );405 crDebug( "Invalid pname to __numValues: 0x%x\\n", (int) pname ); 406 406 return 0; 407 407 } -
trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_simpleget.py
r21033 r21308 49 49 print '\t(void) params;' 50 50 print '\tget_values = (%s *) crAlloc( tablesize );' % types[index] 51 print '\tif (tablesize>0)' 51 52 print '\tcr_server.head_spu->dispatch_table.%s( pname, get_values );' % func_name 52 53 print """ -
trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack.py
r15532 r21308 28 28 29 29 static void crUnpackExtend(void); 30 static void crUnpackExtendDbg(void); 31 32 /*#define CR_UNPACK_DEBUG_OPCODES*/ 33 /*#define CR_UNPACK_DEBUG_LAST_OPCODES*/ 30 34 """ 31 35 32 36 nodebug_opcodes = [ 37 "CR_MULTITEXCOORD2FARB_OPCODE", 38 "CR_VERTEX3F_OPCODE", 39 "CR_NORMAL3F_OPCODE", 40 "CR_COLOR4UB_OPCODE", 41 "CR_LOADIDENTITY_OPCODE", 42 "CR_MATRIXMODE_OPCODE", 43 "CR_LOADMATRIXF_OPCODE", 44 "CR_DISABLE_OPCODE", 45 "CR_COLOR4F_OPCODE", 46 "CR_ENABLE_OPCODE", 47 "CR_BEGIN_OPCODE", 48 "CR_END_OPCODE", 49 "CR_SECONDARYCOLOR3FEXT_OPCODE" 50 ] 51 52 nodebug_extopcodes = [ 53 "CR_ACTIVETEXTUREARB_EXTEND_OPCODE" 54 ] 33 55 34 56 # … … 199 221 cr_unpackData = (const unsigned char *)data; 200 222 223 crDebug("crUnpack: %d opcodes", num_opcodes); 224 201 225 for (i = 0 ; i < num_opcodes ; i++) 202 226 { … … 211 235 if "pack" in apiutil.ChromiumProps(func_name): 212 236 print '\t\t\tcase %s:' % apiutil.OpcodeName( func_name ) 213 # print '\t\t\t\tcrDebug("Unpack: %s");' % apiutil.OpcodeName( func_name ) 237 if not apiutil.OpcodeName(func_name) in nodebug_opcodes: 238 print """ 239 #ifdef CR_UNPACK_DEBUG_LAST_OPCODES 240 if (i==(num_opcodes-1)) 241 #endif 242 #if defined(CR_UNPACK_DEBUG_OPCODES) || defined(CR_UNPACK_DEBUG_LAST_OPCODES) 243 crDebug("Unpack: %s"); 244 #endif """ % apiutil.OpcodeName(func_name) 214 245 print '\t\t\t\tcrUnpack%s(); \n\t\t\t\tbreak;' % func_name 215 246 216 247 print """ 217 case CR_EXTEND_OPCODE: crUnpackExtend(); break; 248 case CR_EXTEND_OPCODE: 249 #ifdef CR_UNPACK_DEBUG_OPCODES 250 crUnpackExtendDbg(); 251 #else 252 # ifdef CR_UNPACK_DEBUG_LAST_OPCODES 253 if (i==(num_opcodes-1)) crUnpackExtendDbg(); 254 else 255 # endif 256 crUnpackExtend(); 257 #endif 258 break; 218 259 default: 219 260 crError( "Unknown opcode: %d", *unpack_opcodes ); … … 263 304 INCR_VAR_PTR(); 264 305 }""" 306 307 print 'static void crUnpackExtendDbg(void)' 308 print '{' 309 print '\tGLenum extend_opcode = %s;' % ReadData( 4, 'GLenum' ); 310 print '' 311 print '\t/*crDebug(\"Unpacking extended opcode \%d", extend_opcode);*/' 312 print '\tswitch( extend_opcode )' 313 print '\t{' 314 315 316 # 317 # Emit switch statement for extended opcodes 318 # 319 for func_name in keys: 320 if "extpack" in apiutil.ChromiumProps(func_name): 321 print '\t\tcase %s:' % apiutil.ExtendedOpcodeName( func_name ) 322 if not apiutil.ExtendedOpcodeName(func_name) in nodebug_extopcodes: 323 print '\t\t\tcrDebug("Unpack: %s");' % apiutil.ExtendedOpcodeName( func_name ) 324 print '\t\t\tcrUnpackExtend%s( );' % func_name 325 print '\t\t\tbreak;' 326 327 print """ default: 328 crError( "Unknown extended opcode: %d", (int) extend_opcode ); 329 break; 330 } 331 INCR_VAR_PTR(); 332 }""" -
trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack_arrays.c
r21306 r21308 117 117 void crUnpackExtendDrawElements(void) 118 118 { 119 GLenum mode = READ_DATA( 8, GLenum );120 GLsizei count = READ_DATA( 12, GLsizei );121 GLenum type = READ_DATA( 16, GLenum );119 GLenum mode = READ_DATA( 8, GLenum ); 120 GLsizei count = READ_DATA( 12, GLsizei ); 121 GLenum type = READ_DATA( 16, GLenum ); 122 122 GLintptrARB indices = READ_DATA( 20, GLintptrARB ); 123 cr_unpackDispatch.DrawElements( mode, count, type, (void *) indices); 123 void * indexptr; 124 #ifdef CR_ARB_vertex_buffer_object 125 GLboolean hasidxdata = READ_DATA(24, GLboolean); 126 indexptr = hasidxdata ? DATA_POINTER(24+sizeof(GLboolean), void) : (void*)indices; 127 #else 128 indexptr = DATA_POINTER(24, void); 129 #endif 130 /*crDebug("DrawElements: count=%i, indexptr=%p, hasidx=%p", count, indexptr, hasidxdata);*/ 131 cr_unpackDispatch.DrawElements(mode, count, type, indexptr); 124 132 } 125 133 126 134 void crUnpackExtendDrawRangeElements(void) 127 135 { 128 GLenum mode = READ_DATA( 8, GLenum );129 GLuint start = READ_DATA( 12, GLuint );130 GLuint end = READ_DATA( 16, GLuint );131 GLsizei count = READ_DATA( 20, GLsizei );132 GLenum type = READ_DATA( 24, GLenum );136 GLenum mode = READ_DATA( 8, GLenum ); 137 GLuint start = READ_DATA( 12, GLuint ); 138 GLuint end = READ_DATA( 16, GLuint ); 139 GLsizei count = READ_DATA( 20, GLsizei ); 140 GLenum type = READ_DATA( 24, GLenum ); 133 141 GLintptrARB indices = READ_DATA( 28, GLintptrARB ); 134 cr_unpackDispatch.DrawRangeElements( mode, start, end, count, type, (void *) indices); 142 void * indexptr; 143 #ifdef CR_ARB_vertex_buffer_object 144 GLboolean hasidxdata = READ_DATA(32, GLboolean); 145 indexptr = hasidxdata ? DATA_POINTER(32+sizeof(GLboolean), void) : (void*)indices; 146 #else 147 indexptr = DATA_POINTER(32, void); 148 #endif 149 cr_unpackDispatch.DrawRangeElements(mode, start, end, count, type, indexptr); 135 150 } 136 151 -
trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack_bufferobject.c
r21306 r21308 32 32 void crUnpackExtendBufferDataARB( void ) 33 33 { 34 GLenum target = READ_DATA( sizeof(int) + 4, GLenum ); 35 GLsizeiptrARB size = READ_DATA( sizeof(int) + 8, GLsizeiptrARB ); 36 GLenum usage = READ_DATA( sizeof(int) + 12, GLenum ); 37 GLvoid *data = DATA_POINTER( sizeof(int) + 16, GLvoid ); 34 GLenum target = READ_DATA(sizeof(int) + 4, GLenum); 35 GLsizeiptrARB size = READ_DATA(sizeof(int) + 8, GLsizeiptrARB); 36 GLenum usage = READ_DATA(sizeof(int) + 12, GLenum); 37 GLboolean hasdata = READ_DATA(sizeof(int) + 16, GLboolean); 38 GLvoid *data = DATA_POINTER(sizeof(int) + 16 + sizeof(GLboolean), GLvoid); 38 39 39 40 CRASSERT(sizeof(GLsizeiptrARB) == 4); 40 CRASSERT(usage == GL_STATIC_DRAW_ARB); 41 /*@todo, why?*/ 42 /*CRASSERT(usage == GL_STATIC_DRAW_ARB);*/ 41 43 42 cr_unpackDispatch.BufferDataARB( target, size, data, usage);44 cr_unpackDispatch.BufferDataARB(target, size, hasdata ? data:NULL, usage); 43 45 } 44 46 -
trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpacker.h
r15532 r21308 13 13 #define DLLDATA(type) DECLEXPORT(type) 14 14 15 #include "cr_version.h" 15 16 #include "cr_unpack.h" 16 17 #include "unpack_extend.h"
Note:
See TracChangeset
for help on using the changeset viewer.
