/* * Helper for crStateCreateContext, below. */ static CRContext * crStateCreateContextId(int i, const CRLimitsState *limits, GLint visBits, CRContext *shareCtx) { CRContext *ctx = (CRContext *) crCalloc( sizeof( *ctx ) ); int j; int node32 = i >> 5; int node = i & 0x1f; ctx->id = i; ctx->flush_func = NULL; for (j=0;j<CR_MAX_BITARRAY;j++){ if (j == node32) { ctx->bitid[j] = (1 << node); } else { ctx->bitid[j] = 0; } ctx->neg_bitid[j] = ~(ctx->bitid[j]); } if (shareCtx) { CRASSERT(shareCtx->shared); ctx->shared = shareCtx->shared; ctx->shared->refCount ++; } else { ctx->shared = crStateAllocShared(); ctx->shared->id = ctx->id; } /* use Chromium's OpenGL defaults */ crStateLimitsInit( &(ctx->limits) ); crStateExtensionsInit( &(ctx->limits), &(ctx->extensions) ); crStateBufferObjectInit( ctx ); /* must precede client state init! */ crStateClientInit( &(ctx->client) ); crStateBufferInit( ctx ); crStateCurrentInit( ctx ); crStateEvaluatorInit( ctx ); crStateFogInit( ctx ); crStateHintInit( ctx ); crStateLightingInit( ctx ); crStateLineInit( ctx ); crStateListsInit( ctx ); crStateMultisampleInit( ctx ); crStateOcclusionInit( ctx ); crStatePixelInit( ctx ); crStatePolygonInit( ctx ); crStatePointInit( ctx ); crStateProgramInit( ctx ); crStateRegCombinerInit( ctx ); crStateStencilInit( ctx ); crStateTextureInit( ctx ); crStateTransformInit( ctx ); crStateViewportInit ( ctx ); crStateFramebufferObjectInit(ctx); crStateGLSLInit(ctx); /* This has to come last. */ crStateAttribInit( &(ctx->attrib) ); ctx->renderMode = GL_RENDER; /* Initialize values that depend on the visual mode */ if (visBits & CR_DOUBLE_BIT) { ctx->limits.doubleBuffer = GL_TRUE; } if (visBits & CR_RGB_BIT) { ctx->limits.redBits = 8; ctx->limits.greenBits = 8; ctx->limits.blueBits = 8; if (visBits & CR_ALPHA_BIT) { ctx->limits.alphaBits = 8; } } else { ctx->limits.indexBits = 8; } if (visBits & CR_DEPTH_BIT) { ctx->limits.depthBits = 24; } if (visBits & CR_STENCIL_BIT) { ctx->limits.stencilBits = 8; } if (visBits & CR_ACCUM_BIT) { ctx->limits.accumRedBits = 16; ctx->limits.accumGreenBits = 16; ctx->limits.accumBlueBits = 16; if (visBits & CR_ALPHA_BIT) { ctx->limits.accumAlphaBits = 16; } } if (visBits & CR_STEREO_BIT) { ctx->limits.stereo = GL_TRUE; } if (visBits & CR_MULTISAMPLE_BIT) { ctx->limits.sampleBuffers = 1; ctx->limits.samples = 4; ctx->multisample.enabled = GL_TRUE; } if (visBits & CR_OVERLAY_BIT) { ctx->limits.level = 1; } return ctx; }
/** * Do CRServer initializations. After this, we can begin servicing clients. */ void crServerInit(int argc, char *argv[]) { int i; char *mothership = NULL; CRMuralInfo *defaultMural; for (i = 1 ; i < argc ; i++) { if (!crStrcmp( argv[i], "-mothership" )) { if (i == argc - 1) { crError( "-mothership requires an argument" ); } mothership = argv[i+1]; i++; } else if (!crStrcmp( argv[i], "-port" )) { /* This is the port on which we'll accept client connections */ if (i == argc - 1) { crError( "-port requires an argument" ); } cr_server.tcpip_port = crStrToInt(argv[i+1]); i++; } else if (!crStrcmp( argv[i], "-vncmode" )) { cr_server.vncMode = 1; } else if (!crStrcmp( argv[i], "-help" )) { crPrintHelp(); exit(0); } } signal( SIGTERM, crServerCleanup ); signal( SIGINT, crServerCleanup ); #ifndef WINDOWS signal( SIGPIPE, SIG_IGN ); #endif #if DEBUG_FP_EXCEPTIONS { fpu_control_t mask; _FPU_GETCW(mask); mask &= ~(_FPU_MASK_IM | _FPU_MASK_DM | _FPU_MASK_ZM | _FPU_MASK_OM | _FPU_MASK_UM); _FPU_SETCW(mask); } #endif cr_server.firstCallCreateContext = GL_TRUE; cr_server.firstCallMakeCurrent = GL_TRUE; /* * Create default mural info and hash table. */ cr_server.muralTable = crAllocHashtable(); defaultMural = (CRMuralInfo *) crCalloc(sizeof(CRMuralInfo)); crHashtableAdd(cr_server.muralTable, 0, defaultMural); cr_server.programTable = crAllocHashtable(); crNetInit(crServerRecv, crServerClose); crStateInit(); crServerGatherConfiguration(mothership); crStateLimitsInit( &(cr_server.limits) ); /* * Default context */ cr_server.contextTable = crAllocHashtable(); cr_server.DummyContext = crStateCreateContext( &cr_server.limits, CR_RGB_BIT | CR_DEPTH_BIT, NULL ); cr_server.curClient->currentCtx = cr_server.DummyContext; crServerInitDispatch(); crStateDiffAPI( &(cr_server.head_spu->dispatch_table) ); crUnpackSetReturnPointer( &(cr_server.return_ptr) ); crUnpackSetWritebackPointer( &(cr_server.writeback_ptr) ); cr_server.barriers = crAllocHashtable(); cr_server.semaphores = crAllocHashtable(); }
/** * Do CRServer initializations. After this, we can begin servicing clients. */ GLboolean crVBoxServerInit(void) { CRMuralInfo *defaultMural; #if DEBUG_FP_EXCEPTIONS { fpu_control_t mask; _FPU_GETCW(mask); mask &= ~(_FPU_MASK_IM | _FPU_MASK_DM | _FPU_MASK_ZM | _FPU_MASK_OM | _FPU_MASK_UM); _FPU_SETCW(mask); } #endif crNetInit(crServerRecv, crServerClose); cr_server.firstCallCreateContext = GL_TRUE; cr_server.firstCallMakeCurrent = GL_TRUE; cr_server.bIsInLoadingState = GL_FALSE; cr_server.bIsInSavingState = GL_FALSE; cr_server.pCleanupClient = NULL; /* * Create default mural info and hash table. */ cr_server.muralTable = crAllocHashtable(); defaultMural = (CRMuralInfo *) crCalloc(sizeof(CRMuralInfo)); crHashtableAdd(cr_server.muralTable, 0, defaultMural); cr_server.programTable = crAllocHashtable(); crStateInit(); crStateLimitsInit( &(cr_server.limits) ); cr_server.barriers = crAllocHashtable(); cr_server.semaphores = crAllocHashtable(); crUnpackSetReturnPointer( &(cr_server.return_ptr) ); crUnpackSetWritebackPointer( &(cr_server.writeback_ptr) ); /* * Default context */ cr_server.contextTable = crAllocHashtable(); cr_server.DummyContext = crStateCreateContext( &cr_server.limits, CR_RGB_BIT | CR_DEPTH_BIT, NULL ); cr_server.pContextCreateInfoTable = crAllocHashtable(); cr_server.pWindowCreateInfoTable = crAllocHashtable(); crServerSetVBoxConfigurationHGCM(); if (!cr_server.head_spu) return GL_FALSE; crServerInitDispatch(); crStateDiffAPI( &(cr_server.head_spu->dispatch_table) ); /*Check for PBO support*/ if (crStateGetCurrent()->extensions.ARB_pixel_buffer_object) { cr_server.bUsePBOForReadback=GL_TRUE; } return GL_TRUE; }