/* Intersect two strings on a word-by-word basis (separated by spaces).
* We typically use this to intersect OpenGL extension strings.
* Example: if s1 = "apple banana plum pear"
* and s2 = "plum banana orange"
* then return "banana plum" (or "plum banana").
*/
char *crStrIntersect( const char *s1, const char *s2 )
{
int len1, len2;
int resultLen;
char *result;
char **exten1, **exten2;
int i, j;
if (!s1 || !s2) {
/* null strings, no intersection */
return NULL;
}
len1 = crStrlen(s1);
len2 = crStrlen(s2);
/* allocate storage for result (a conservative estimate) */
resultLen = ((len1 > len2) ? len1 : len2) + 2;
result = (char *) crAlloc(resultLen);
if (!result)
{
return NULL;
}
result[0] = 0;
/* split s1 and s2 at space chars */
exten1 = crStrSplit(s1, " ");
exten2 = crStrSplit(s2, " ");
for (i = 0; exten1[i]; i++)
{
for (j = 0; exten2[j]; j++)
{
if (crStrcmp(exten1[i], exten2[j]) == 0)
{
/* found an intersection, append to result */
crStrcat(result, exten1[i]);
crStrcat(result, " ");
break;
}
}
}
/* free split strings */
crFreeStrings( exten1 );
crFreeStrings( exten2 );
/*CRASSERT(crStrlen(result) < resultLen);*/
/* all done! */
return result;
}
/**
* Ask the mothership for a new tile layout.
* Return: GL_TRUE if successfull, GL_FALSE otherwise.
*/
static GLboolean
getTilingFromMothership( WindowInfo *winInfo )
{
char response[8000];
char **n_tiles;
char **tiles;
int numTiles, i;
int maxX, maxY;
CRConnection *conn = crMothershipConnect();
CRASSERT(conn);
crMothershipIdentifySPU(conn, tilesort_spu.id);
crMothershipRequestTileLayout(conn, response, winInfo->muralWidth, winInfo->muralHeight);
crMothershipDisconnect(conn);
crDebug("Getting tile information from mothership.");
n_tiles = crStrSplitn(response, " ", 1);
numTiles = crStrToInt( n_tiles[0] );
if (numTiles <= 0)
return GL_FALSE; /* failure */
/* remove old tile list */
for (i = 0; i < tilesort_spu.num_servers; i++)
winInfo->server[i].num_extents = 0;
/* parse new tile string */
maxX = maxY = 0;
CRASSERT(n_tiles[1]);
tiles = crStrSplit(n_tiles[1], ",");
for (i = 0; i < numTiles; i++)
{
int server, x, y, w, h, t;
sscanf(tiles[i], "%d %d %d %d %d", &server, &x, &y, &w, &h);
/*crDebug("Tile on %d: %d %d %d %d", server, x1, y1, x2, y2);*/
t = winInfo->server[server].num_extents;
winInfo->server[server].extents[t].x1 = x;
winInfo->server[server].extents[t].y1 = y;
winInfo->server[server].extents[t].x2 = x + w;
winInfo->server[server].extents[t].y2 = y + h;
winInfo->server[server].num_extents = t + 1;
/* update maxX, maxY */
if (x + w > maxX)
maxX = x + w;
if (y + h > maxY)
maxY = y + h;
}
return GL_TRUE;
}
static void set_lut8( RenderSPU *render_spu, const char *response )
{
int a;
char **lut;
if (!response[0]) return;
lut = crStrSplit(response, ",");
if (!lut) return;
for (a=0; a<256; a++)
{
render_spu->lut8[0][a] = crStrToInt(lut[a]);
render_spu->lut8[1][a] = crStrToInt(lut[256+a]);
render_spu->lut8[2][a] = crStrToInt(lut[512+a]);
}
crFreeStrings(lut);
render_spu->use_lut8 = 1;
}
void
CRUT_APIENTRY
crutConnectToClients( CRUTAPI *crut_api )
{
int i, ind;
char response[8096], hostname[4096], protocol[4096];
char **newclients;
char* client;
unsigned short port;
crMothershipGetCRUTClients(crut_api->mothershipConn, response);
newclients = crStrSplit(response, " ");
crut_api->numclients = crStrToInt(newclients[0]);
ind = 1;
crut_api->crutclients = crAlloc(crut_api->numclients*sizeof(CRUTClientPointer));
for (i=0; i<crut_api->numclients; i++) {
client = newclients[ind++];
if ( !crParseURL( client, protocol, hostname, &port, DEFAULT_CRUT_PORT ) )
{
crError( "Malformed URL: \"%s\"", response );
}
crut_api->crutclients[i].mtu = crMothershipGetMTU( crut_api->mothershipConn );
crut_api->crutclients[i].send_conn = crNetAcceptClient( protocol, hostname, port, crut_api->crutclients[i].mtu, 0 );
if (!crut_api->crutclients[i].send_conn)
{
crError("Couldn't connect to the CRUT client");
}
}
}
/**
* Find the index of the given enum value in the SPUOption's list of
* possible enum values.
* Return the enum index, or -1 if not found.
*/
int crSPUGetEnumIndex( const SPUOptions *options, const char *optName, const char *value )
{
const SPUOptions *opt;
const int valueLen = crStrlen(value);
/* first, find the right option */
for (opt = options; opt->option; opt++) {
if (crStrcmp(opt->option, optName) == 0) {
char **values;
int i;
CRASSERT(opt->type == CR_ENUM);
/* break into array of strings */
/* min string should be of form "'enum1', 'enum2', 'enum3', etc" */
values = crStrSplit(opt->min, ",");
/* search the array */
for (i = 0; values[i]; i++) {
/* find leading quote */
const char *e = crStrchr(values[i], '\'');
CRASSERT(e);
if (e) {
/* test for match */
if (crStrncmp(value, e + 1, valueLen) == 0 && e[valueLen + 1] == '\'') {
crFreeStrings(values);
return i;
}
}
}
/* enum value not found! */
crFreeStrings(values);
return -1;
}
}
return -1;
}
static void
crutInitProxy(char *mothership)
{
char response[8096];
char **newserver;
char* server;
int mtu;
crutInitAPI(&crut_api, mothership);
crMothershipIdentifyCRUTProxy( crut_api.mothershipConn, response );
crMothershipGetCRUTServer( crut_api.mothershipConn, response );
newserver = crStrSplit(response, " ");
server = newserver[1];
mtu = crMothershipGetMTU(crut_api.mothershipConn);
/* set up the connection to recv on */
crut_proxy.recv_conn = crNetConnectToServer( server, DEFAULT_CRUT_PORT, mtu, 1 );
crutConnectToClients( &crut_api );
}
/**
* Do one-time initializations for the faker.
* Returns TRUE on success, FALSE otherwise.
*/
static bool
stubInitLocked(void)
{
/* Here is where we contact the mothership to find out what we're supposed
* to be doing. Networking code in a DLL initializer. I sure hope this
* works :)
*
* HOW can I pass the mothership address to this if I already know it?
*/
CRConnection *conn = NULL;
char response[1024];
char **spuchain;
int num_spus;
int *spu_ids;
char **spu_names;
const char *app_id;
int i;
int disable_sync = 0;
stubInitVars();
crGetProcName(response, 1024);
crDebug("Stub launched for %s", response);
#if defined(CR_NEWWINTRACK) && !defined(WINDOWS)
/*@todo when vm boots with compiz turned on, new code causes hang in xcb_wait_for_reply in the sync thread
* as at the start compiz runs our code under XGrabServer.
*/
if (!crStrcmp(response, "compiz") || !crStrcmp(response, "compiz_real") || !crStrcmp(response, "compiz.real")
|| !crStrcmp(response, "compiz-bin"))
{
disable_sync = 1;
}
#elif defined(WINDOWS) && defined(VBOX_WITH_WDDM) && defined(VBOX_WDDM_MINIPORT_WITH_VISIBLE_RECTS)
if (GetModuleHandle(VBOX_MODNAME_DISPD3D))
{
disable_sync = 1;
crDebug("running with " VBOX_MODNAME_DISPD3D);
stub.trackWindowVisibleRgn = 0;
stub.bRunningUnderWDDM = true;
}
#endif
/* @todo check if it'd be of any use on other than guests, no use for windows */
app_id = crGetenv( "CR_APPLICATION_ID_NUMBER" );
crNetInit( NULL, NULL );
#ifndef WINDOWS
{
CRNetServer ns;
ns.name = "vboxhgcm://host:0";
ns.buffer_size = 1024;
crNetServerConnect(&ns
#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
, NULL
#endif
);
if (!ns.conn)
{
crWarning("Failed to connect to host. Make sure 3D acceleration is enabled for this VM.");
return false;
}
else
{
crNetFreeConnection(ns.conn);
}
#if 0 && defined(CR_NEWWINTRACK)
{
Status st = XInitThreads();
if (st==0)
{
crWarning("XInitThreads returned %i", (int)st);
}
}
#endif
}
#endif
strcpy(response, "2 0 feedback 1 pack");
spuchain = crStrSplit( response, " " );
num_spus = crStrToInt( spuchain[0] );
spu_ids = (int *) crAlloc( num_spus * sizeof( *spu_ids ) );
spu_names = (char **) crAlloc( num_spus * sizeof( *spu_names ) );
for (i = 0 ; i < num_spus ; i++)
{
spu_ids[i] = crStrToInt( spuchain[2*i+1] );
spu_names[i] = crStrdup( spuchain[2*i+2] );
crDebug( "SPU %d/%d: (%d) \"%s\"", i+1, num_spus, spu_ids[i], spu_names[i] );
}
stubSetDefaultConfigurationOptions();
stub.spu = crSPULoadChain( num_spus, spu_ids, spu_names, stub.spu_dir, NULL );
crFree( spuchain );
crFree( spu_ids );
for (i = 0; i < num_spus; ++i)
crFree(spu_names[i]);
crFree( spu_names );
// spu chain load failed somewhere
if (!stub.spu) {
return false;
}
crSPUInitDispatchTable( &glim );
/* This is unlikely to change -- We still want to initialize our dispatch
* table with the functions of the first SPU in the chain. */
stubInitSPUDispatch( stub.spu );
/* we need to plug one special stub function into the dispatch table */
glim.GetChromiumParametervCR = stub_GetChromiumParametervCR;
#if !defined(VBOX_NO_NATIVEGL)
/* Load pointers to native OpenGL functions into stub.nativeDispatch */
stubInitNativeDispatch();
#endif
/*crDebug("stub init");
raise(SIGINT);*/
#ifdef WINDOWS
# ifndef CR_NEWWINTRACK
stubInstallWindowMessageHook();
# endif
#endif
#ifdef CR_NEWWINTRACK
{
int rc;
RTR3InitDll(RTR3INIT_FLAGS_UNOBTRUSIVE);
if (!disable_sync)
{
crDebug("Starting sync thread");
rc = RTThreadCreate(&stub.hSyncThread, stubSyncThreadProc, NULL, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "Sync");
if (RT_FAILURE(rc))
{
crError("Failed to start sync thread! (%x)", rc);
}
RTThreadUserWait(stub.hSyncThread, 60 * 1000);
RTThreadUserReset(stub.hSyncThread);
crDebug("Going on");
}
}
#endif
#ifdef GLX
stub.xshmSI.shmid = -1;
stub.bShmInitFailed = GL_FALSE;
stub.pGLXPixmapsHash = crAllocHashtable();
stub.bXExtensionsChecked = GL_FALSE;
stub.bHaveXComposite = GL_FALSE;
stub.bHaveXFixes = GL_FALSE;
#endif
return true;
}
void crServerSetVBoxConfiguration()
{
CRMuralInfo *defaultMural;
char response[8096];
char **spuchain;
int num_spus;
int *spu_ids;
char **spu_names;
char *spu_dir = NULL;
int i;
/* Quadrics defaults */
int my_rank = 0;
int low_context = CR_QUADRICS_DEFAULT_LOW_CONTEXT;
int high_context = CR_QUADRICS_DEFAULT_HIGH_CONTEXT;
unsigned char key[16]= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
char hostname[1024];
char **clientchain, **clientlist;
GLint dims[4];
const char * env;
defaultMural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, 0);
CRASSERT(defaultMural);
setDefaults();
/*
* Get my hostname
*/
if (crGetHostname(hostname, sizeof(hostname)))
{
crError("CRServer: Couldn't get my own hostname?");
}
strcpy(response, "1 0 render");
crDebug("CRServer: my SPU chain: %s", response);
/* response will describe the SPU chain.
* Example "2 5 wet 6 render"
*/
spuchain = crStrSplit(response, " ");
num_spus = crStrToInt(spuchain[0]);
spu_ids = (int *) crAlloc(num_spus * sizeof(*spu_ids));
spu_names = (char **) crAlloc((num_spus + 1) * sizeof(*spu_names));
for (i = 0; i < num_spus; i++)
{
spu_ids[i] = crStrToInt(spuchain[2 * i + 1]);
spu_names[i] = crStrdup(spuchain[2 * i + 2]);
crDebug("SPU %d/%d: (%d) \"%s\"", i + 1, num_spus, spu_ids[i],
spu_names[i]);
}
spu_names[i] = NULL;
//spu_dir = crStrdup(response);
crNetSetRank(0);
crNetSetContextRange(32, 35);
crNetSetNodeRange("iam0", "iamvis20");
crNetSetKey(key,sizeof(key));
crNetSetKey(key,sizeof(key));
cr_server.tcpip_port = 7000;
/*cr_server.optimizeBucket = crStrToInt(response);
cr_server.localTileSpec = crStrToInt(response);
cr_server.useL2 = crStrToInt(response);
cr_server.ignore_papi = crStrToInt(response);
if (crMothershipGetServerParam(conn, response, "overlap_blending"))
{
if (!crStrcmp(response, "blend"))
cr_server.overlapBlending = 1;
else if (!crStrcmp(response, "knockout"))
cr_server.overlapBlending = 2;
}
if (crMothershipGetServerParam(conn, response, "overlap_levels"))
cr_server.only_swap_once = crStrToInt(response);
cr_server.debug_barriers = crStrToInt(response);
cr_server.sharedDisplayLists = crStrToInt(response);
cr_server.sharedTextureObjects = crStrToInt(response);
cr_server.sharedPrograms = crStrToInt(response);
cr_server.sharedWindows = crStrToInt(response);
cr_server.uniqueWindows = crStrToInt(response);
cr_server.useDMX = crStrToInt(response);
if (crMothershipGetServerParam(conn, response, "vertprog_projection_param"))
if (crMothershipGetServerParam(conn, response, "stereo_view"))
if (crMothershipGetServerParam(conn, response, "view_matrix"))
if (crMothershipGetServerParam(conn, response, "right_view_matrix"))
if (crMothershipGetServerParam(conn, response, "projection_matrix"))
if (crMothershipGetServerParam(conn, response, "right_projection_matrix"))*/
crDebug("CRServer: my port number is %d", cr_server.tcpip_port);
/*
* Load the SPUs
*/
cr_server.head_spu =
crSPULoadChain(num_spus, spu_ids, spu_names, spu_dir, &cr_server);
env = crGetenv( "CR_SERVER_DEFAULT_RENDER_TYPE" );
if (env != NULL)
{
GLubyte redir = (env[0] - 0x30);
if (redir <= CR_SERVER_REDIR_MAXVAL)
{
int rc = crServerSetOffscreenRenderingMode(redir);
if (!RT_SUCCESS(rc))
crWarning("offscreen rendering unsupported, no offscreen rendering will be used..");
}
else
crWarning("invalid redir option %c", redir);
}
#if defined(RT_OS_DARWIN) || defined(RT_OS_WINDOWS) || defined(GLX)
else
{
int rc = crServerSetOffscreenRenderingMode(CR_SERVER_REDIR_FBO_BLT);
if (!RT_SUCCESS(rc))
crWarning("offscreen rendering unsupported, no offscreen rendering will be used..");
}
#endif
cr_server.bOffscreenRenderingDefault = cr_server.bForceOffscreenRendering;
/* Need to do this as early as possible */
cr_server.head_spu->dispatch_table.GetChromiumParametervCR(GL_WINDOW_POSITION_CR, 0, GL_INT, 2, &dims[0]);
cr_server.head_spu->dispatch_table.GetChromiumParametervCR(GL_WINDOW_SIZE_CR, 0, GL_INT, 2, &dims[2]);
defaultMural->gX = dims[0];
defaultMural->gY = dims[1];
defaultMural->width = dims[2];
defaultMural->height = dims[3];
crFree(spu_ids);
crFreeStrings(spu_names);
crFreeStrings(spuchain);
if (spu_dir)
crFree(spu_dir);
cr_server.mtu = 1024 * 30;
/*
* Get a list of all the clients talking to me.
*/
if (cr_server.vncMode) {
/* we're inside a vnc viewer */
/*if (!crMothershipSendString( conn, response, "getvncclient %s", hostname ))
crError( "Bad Mothership response: %s", response );*/
}
else {
//crMothershipGetClients(conn, response);
strcpy(response, "1 tcpip 1");
}
crDebug("CRServer: my clients: %s", response);
/*
* 'response' will now contain a number indicating the number of clients
* of this server, followed by a comma-separated list of protocol/SPU ID
* pairs.
* Example: "3 tcpip 1,gm 2,via 10"
*/
clientchain = crStrSplitn(response, " ", 1);
cr_server.numClients = crStrToInt(clientchain[0]);
if (cr_server.numClients == 0)
{
crError("I have no clients! What's a poor server to do?");
}
clientlist = crStrSplit(clientchain[1], ",");
/*
* Connect to initial set of clients.
* Call crNetAcceptClient() for each client.
* Also, look for a client that's _not_ using the file: protocol.
*/
for (i = 0; i < cr_server.numClients; i++)
{
CRClient *newClient = (CRClient *) crCalloc(sizeof(CRClient));
#ifdef VBOX
sscanf(clientlist[i], "%1023s %d", cr_server.protocol, &(newClient->spu_id));
#else
sscanf(clientlist[i], "%s %d", cr_server.protocol, &(newClient->spu_id));
#endif
newClient->conn = crNetAcceptClient(cr_server.protocol, NULL,
cr_server.tcpip_port,
cr_server.mtu, 0);
newClient->currentCtxInfo = &cr_server.MainContextInfo;
crServerAddToRunQueue(newClient);
cr_server.clients[i] = newClient;
}
/* set default client and mural */
if (cr_server.numClients > 0) {
cr_server.curClient = cr_server.clients[0];
cr_server.curClient->currentMural = defaultMural;
cr_server.client_spu_id =cr_server.clients[0]->spu_id;
}
crFreeStrings(clientchain);
crFreeStrings(clientlist);
/* Ask the mothership for the tile info */
//crServerGetTileInfoFromMothership(conn, defaultMural);
if (cr_server.vncMode) {
/* In vnc mode, we reset the mothership configuration so that it can be
* used by subsequent OpenGL apps without having to spawn a new mothership
* on a new port.
*/
crDebug("CRServer: Resetting mothership to initial state");
//crMothershipReset(conn);
}
//crMothershipDisconnect(conn);
}
/**
* Get the tile information (count, extents, etc) from the servers
* and build our corresponding data structures.
* This is called once during SPU initialization.
* Input: conn - mothership connection
*/
void
tilesortspuGetTilingFromServers(CRConnection *conn, WindowInfo *winInfo)
{
ThreadInfo *thread0 = &(tilesort_spu.thread[0]);
char response[8096];
char **serverchain, **serverlist;
int num_servers;
int i;
crDebug("Getting tile information from servers.");
/* The response to this tells us how many servers and where they are
*
* For example: 2 tcpip://foo tcpip://bar
*/
crMothershipGetServers(conn, response);
serverchain = crStrSplitn(response, " ", 1);
num_servers = crStrToInt(serverchain[0]);
CRASSERT(num_servers == tilesort_spu.num_servers);
serverlist = crStrSplit(serverchain[1], ",");
tilesort_spu.thread[0].netServer =
(CRNetServer *) crCalloc(num_servers * sizeof(CRNetServer));
tilesort_spu.thread[0].buffer =
(CRPackBuffer *) crCalloc(num_servers * sizeof(CRPackBuffer));
/** XXX: \todo there is lots of overlap between these cases. merge! */
if (tilesort_spu.localTileSpec)
{
char **displaylist, **displaychain;
double *corners;
int num_displays, idx;
double world_bbox[4];
/*
* Here we has tiles specified relative to the origin of
* whichever display they happen to land in. First, gather
* the list of displays, then get the tiles that belong on it
*/
crMothershipGetDisplays(conn, response);
displaychain = crStrSplitn(response, " ", 1);
displaylist = crStrSplit(displaychain[1], ",");
num_displays = crStrToInt(displaychain[0]);
corners = (double *) crAlloc(num_displays * 8 * sizeof(double));
tilesort_spu.displays =
(WarpDisplayInfo *) crAlloc(num_displays * sizeof(WarpDisplayInfo));
idx = 0;
for (i = 0; i < num_displays; i++)
{
float pnt[2], warped[2];
sscanf(displaylist[i],
"%d %d %d %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f",
&tilesort_spu.displays[i].id, &tilesort_spu.displays[i].width,
&tilesort_spu.displays[i].height,
&tilesort_spu.displays[i].correct[0],
&tilesort_spu.displays[i].correct[1],
&tilesort_spu.displays[i].correct[2],
&tilesort_spu.displays[i].correct[3],
&tilesort_spu.displays[i].correct[4],
&tilesort_spu.displays[i].correct[5],
&tilesort_spu.displays[i].correct[6],
&tilesort_spu.displays[i].correct[7],
&tilesort_spu.displays[i].correct[8],
&tilesort_spu.displays[i].correct_inv[0],
&tilesort_spu.displays[i].correct_inv[1],
&tilesort_spu.displays[i].correct_inv[2],
&tilesort_spu.displays[i].correct_inv[3],
&tilesort_spu.displays[i].correct_inv[4],
&tilesort_spu.displays[i].correct_inv[5],
&tilesort_spu.displays[i].correct_inv[6],
&tilesort_spu.displays[i].correct_inv[7],
&tilesort_spu.displays[i].correct_inv[8]);
pnt[0] = -1;
pnt[1] = -1;
crWarpPoint(tilesort_spu.displays[i].correct_inv, pnt, warped);
corners[idx] = warped[0];
corners[idx + 1] = warped[1];
idx += 2;
pnt[0] = -1;
pnt[1] = 1;
crWarpPoint(tilesort_spu.displays[i].correct_inv, pnt, warped);
corners[idx] = warped[0];
corners[idx + 1] = warped[1];
idx += 2;
pnt[0] = 1;
pnt[1] = 1;
crWarpPoint(tilesort_spu.displays[i].correct_inv, pnt, warped);
corners[idx] = warped[0];
corners[idx + 1] = warped[1];
idx += 2;
pnt[0] = 1;
pnt[1] = -1;
crWarpPoint(tilesort_spu.displays[i].correct_inv, pnt, warped);
corners[idx] = warped[0];
corners[idx + 1] = warped[1];
idx += 2;
}
crHullInteriorBox(corners, idx / 2, world_bbox);
crFree(corners);
/* dummy values in case i forget to override them later */
winInfo->muralWidth = tilesort_spu.displays[0].width;
winInfo->muralHeight = tilesort_spu.displays[0].height;
winInfo->passiveStereo = GL_FALSE; /* may be set true below */
for (i = 0; i < num_servers; i++)
{
char server_url[1024];
ServerWindowInfo *servWinInfo = winInfo->server + i;
char **tilechain, **tilelist;
int tile;
double cent[2], Sx, Sy;
sscanf(serverlist[i], "%s", server_url);
crDebug("Server %d: %s", i + 1, server_url);
thread0->netServer[i].name = crStrdup(server_url);
thread0->netServer[i].buffer_size = tilesort_spu.buffer_size;
/* response is just like regular GetTiles, but each tile
* is preceeded by a display id */
if (!crMothershipGetDisplayTiles(conn, response, i))
{
crError("No tile information for server %d! I can't continue!", i);
}
tilechain = crStrSplitn(response, " ", 1);
servWinInfo->num_extents = crStrToInt(tilechain[0]);
tilelist = crStrSplit(tilechain[1], ",");
servWinInfo->eyeFlags = EYE_LEFT | EYE_RIGHT;
if (crMothershipGetServerParamFromSPU( conn, i,
"stereo_view", response)) {
if (crStrcmp(response, "left") == 0) {
servWinInfo->eyeFlags = EYE_LEFT;
winInfo->passiveStereo = GL_TRUE;
}
else if (crStrcmp(response, "right") == 0) {
servWinInfo->eyeFlags = EYE_RIGHT;
winInfo->passiveStereo = GL_TRUE;
}
}
Sx = 2.0 / (world_bbox[2] - world_bbox[0]);
Sy = 2.0 / (world_bbox[3] - world_bbox[1]);
cent[0] = (world_bbox[0] + world_bbox[2]) / (2.);
cent[1] = (world_bbox[1] + world_bbox[3]) / (2.);
for (tile = 0; tile < servWinInfo->num_extents; tile++)
{
int id, x, y, w, h, a;
float disp_w, disp_h, warped[2], *align;
sscanf(tilelist[tile], "%d %d %d %d %d", &id, &x, &y, &w, &h);
/* this is the local coordinate tiling */
servWinInfo->display_ndx[tile] = -1;
for (a = 0; a < num_displays; a++)
{
if (tilesort_spu.displays[a].id == id)
servWinInfo->display_ndx[tile] = a;
}
if (servWinInfo->display_ndx[tile] == -1)
crError("Invalid Display ID %d", id);
servWinInfo->extents[tile].x1 = x;
servWinInfo->extents[tile].y1 = y;
servWinInfo->extents[tile].x2 = x + w;
servWinInfo->extents[tile].y2 = y + h;
/* warp the tile to mural space */
disp_w = (float) tilesort_spu.displays[servWinInfo->display_ndx[tile]].width;
disp_h = (float) tilesort_spu.displays[servWinInfo->display_ndx[tile]].height;
servWinInfo->world_extents[tile][0] = (float) x / disp_w;
servWinInfo->world_extents[tile][1] = (float) y / disp_h;
servWinInfo->world_extents[tile][2] = (float) x / disp_w;
servWinInfo->world_extents[tile][3] = (float) (y + h) / disp_h;
servWinInfo->world_extents[tile][4] = (float) (x + w) / disp_w;
servWinInfo->world_extents[tile][5] = (float) (y + h) / disp_h;
servWinInfo->world_extents[tile][6] = (float) (x + w) / disp_w;
servWinInfo->world_extents[tile][7] = (float) y / disp_h;
for (a = 0; a < 8; a++)
servWinInfo->world_extents[tile][a] =
(float)2.0 * servWinInfo->world_extents[tile][a] - (float)1.0;
align = tilesort_spu.displays[servWinInfo->display_ndx[tile]].correct_inv;
for (a = 0; a < 4; a++)
{
crWarpPoint(align, servWinInfo->world_extents[tile] + 2 * a, warped);
warped[0] = (warped[0] - (float)cent[0]) * (float) Sx;
warped[1] = (warped[1] - (float)cent[1]) * (float) Sy;
crDebug("%f %f warps to %f %f", servWinInfo->world_extents[tile][2 * a],
servWinInfo->world_extents[tile][2 * a + 1], warped[0],
warped[1]);
servWinInfo->world_extents[tile][2 * a] = warped[0];
servWinInfo->world_extents[tile][2 * a + 1] = warped[1];
}
/** XXX: \todo check that the tile fits w/i the display it is on */
}
crFreeStrings(tilechain);
crFreeStrings(tilelist);
}
crFreeStrings(displaychain);
crFreeStrings(displaylist);
/* can't do any fancy bucketing with this */
tilesort_spu.defaultBucketMode = WARPED_GRID;
}
else
{
/*
* Get the list of tiles from all servers.
* And compute mural size.
*/
winInfo->muralWidth = 0;
winInfo->muralHeight = 0;
for (i = 0; i < num_servers; i++)
{
char server_url[1024];
ServerWindowInfo *servWinInfo = winInfo->server + i;
char **tilechain, **tilelist;
int tile;
sscanf(serverlist[i], "%s", server_url);
crDebug("Server %d: %s", i + 1, server_url);
thread0->netServer[i].name = crStrdup(server_url);
thread0->netServer[i].buffer_size = tilesort_spu.buffer_size;
if (!crMothershipGetTiles(conn, response, i))
{
crError("No tile information for server %d! I can't continue!", i);
}
tilechain = crStrSplitn(response, " ", 1);
servWinInfo->num_extents = crStrToInt(tilechain[0]);
tilelist = crStrSplit(tilechain[1], ",");
for (tile = 0; tile < servWinInfo->num_extents; tile++)
{
int x, y, w, h;
sscanf(tilelist[tile], "%d %d %d %d", &x, &y, &w, &h);
servWinInfo->extents[tile].x1 = x;
servWinInfo->extents[tile].y1 = y;
servWinInfo->extents[tile].x2 = x + w;
servWinInfo->extents[tile].y2 = y + h;
/* update mural size */
if (servWinInfo->extents[tile].x2 > (int) winInfo->muralWidth)
{
winInfo->muralWidth = servWinInfo->extents[tile].x2;
}
if (servWinInfo->extents[tile].y2 > (int) winInfo->muralHeight)
{
winInfo->muralHeight = servWinInfo->extents[tile].y2;
}
}
crFreeStrings(tilechain);
crFreeStrings(tilelist);
/* Determine if the server should receieve left, right or both eye
* views when running in passive stereo mode.
*/
servWinInfo->eyeFlags = EYE_LEFT | EYE_RIGHT;
if (crMothershipGetServerParamFromSPU( conn, i,
"stereo_view", response)) {
if (crStrcmp(response, "left") == 0) {
servWinInfo->eyeFlags = EYE_LEFT;
winInfo->passiveStereo = GL_TRUE;
}
else if (crStrcmp(response, "right") == 0) {
servWinInfo->eyeFlags = EYE_RIGHT;
winInfo->passiveStereo = GL_TRUE;
}
}
/* get view matrices from the server */
if (crMothershipGetServerParamFromSPU( conn, i,
"view_matrix", response)) {
crMatrixInitFromString(&servWinInfo->viewMatrix[0], response);
if (!crMatrixIsIdentity(&servWinInfo->viewMatrix[0]))
winInfo->matrixSource = MATRIX_SOURCE_SERVERS;
}
if (crMothershipGetServerParamFromSPU( conn, i,
"right_view_matrix", response)) {
crMatrixInitFromString(&servWinInfo->viewMatrix[1], response);
if (!crMatrixIsIdentity(&servWinInfo->viewMatrix[1]))
winInfo->matrixSource = MATRIX_SOURCE_SERVERS;
}
/*
crMatrixPrint("Left view", &servWinInfo->viewMatrix[0]);
crMatrixPrint("Right view", &servWinInfo->viewMatrix[1]);
*/
/* Also get overriding projection matrix.
* Note that this matrix is only relevant to FRUSTUM bucketing.
*/
if (crMothershipGetServerParamFromSPU( conn, i,
"projection_matrix", response)) {
/** XXX \todo projection_matrix is obsolete, keep for a while though */
crMatrixInitFromString(&servWinInfo->projectionMatrix[0], response);
if (!crMatrixIsIdentity(&servWinInfo->projectionMatrix[0]))
winInfo->matrixSource = MATRIX_SOURCE_SERVERS;
}
if (crMothershipGetServerParamFromSPU( conn, i,
"right_projection_matrix", response)) {
crMatrixInitFromString(&servWinInfo->projectionMatrix[1], response);
if (!crMatrixIsIdentity(&servWinInfo->projectionMatrix[1]))
winInfo->matrixSource = MATRIX_SOURCE_SERVERS;
}
/*
crMatrixPrint("Left proj", &servWinInfo->projectionMatrix[0]);
crMatrixPrint("Right proj", &servWinInfo->projectionMatrix[1]);
*/
}
}
crFreeStrings(serverchain);
crFreeStrings(serverlist);
tilesortspuBucketingInit( winInfo );
}
void
crServerGatherConfiguration(char *mothership)
{
CRMuralInfo *defaultMural;
CRConnection *conn;
char response[8096];
char **spuchain;
int num_spus;
int *spu_ids;
char **spu_names;
char *spu_dir = NULL;
int i;
/* Quadrics defaults */
int my_rank = 0;
int low_context = CR_QUADRICS_DEFAULT_LOW_CONTEXT;
int high_context = CR_QUADRICS_DEFAULT_HIGH_CONTEXT;
char *low_node = "none";
char *high_node = "none";
unsigned char key[16]= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
char hostname[1024];
char **clientchain, **clientlist;
defaultMural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, 0);
CRASSERT(defaultMural);
setDefaults();
if (mothership)
{
crSetenv("CRMOTHERSHIP", mothership);
}
conn = crMothershipConnect();
if (!conn)
{
crError("Couldn't connect to the mothership, I have no idea what to do!");
}
/*
* Get my hostname
*/
if (crGetHostname(hostname, sizeof(hostname)))
{
crError("CRServer: Couldn't get my own hostname?");
}
/* Identify ourselves to the mothership */
if (cr_server.vncMode) {
/* we're running inside a vnc viewer */
if (!crMothershipSendString( conn, response, "vncserver %s", hostname ))
crError( "Bad Mothership response: %s", response );
}
else {
crMothershipIdentifyServer(conn, response);
}
crDebug("CRServer: my SPU chain: %s", response);
/* response will describe the SPU chain.
* Example "2 5 wet 6 render"
*/
spuchain = crStrSplit(response, " ");
num_spus = crStrToInt(spuchain[0]);
spu_ids = (int *) crAlloc(num_spus * sizeof(*spu_ids));
spu_names = (char **) crAlloc((num_spus + 1) * sizeof(*spu_names));
for (i = 0; i < num_spus; i++)
{
spu_ids[i] = crStrToInt(spuchain[2 * i + 1]);
spu_names[i] = crStrdup(spuchain[2 * i + 2]);
crDebug("SPU %d/%d: (%d) \"%s\"", i + 1, num_spus, spu_ids[i],
spu_names[i]);
}
spu_names[i] = NULL;
/*
* Gather configuration options.
* NOTE: when you add new options, be sure to update the
* mothership/tools/crtypes.py file's NetworkNode class's notion of
* config options.
* XXX Use the SPU option parser code here someday.
*/
if (crMothershipGetServerParam( conn, response, "spu_dir" ) && crStrlen(response) > 0)
{
spu_dir = crStrdup(response);
}
/* Quadrics networking stuff */
if (crMothershipGetRank(conn, response))
{
my_rank = crStrToInt(response);
}
crNetSetRank(my_rank);
if (crMothershipGetParam(conn, "low_context", response))
{
low_context = crStrToInt(response);
}
if (crMothershipGetParam(conn, "high_context", response))
{
high_context = crStrToInt(response);
}
crNetSetContextRange(low_context, high_context);
if (crMothershipGetParam(conn, "low_node", response))
{
low_node = crStrdup(response);
}
if (crMothershipGetParam(conn, "high_node", response))
{
high_node = crStrdup(response);
}
crNetSetNodeRange(low_node, high_node);
if (low_node)
crFree(low_node);
if (high_node)
crFree(high_node);
if (crMothershipGetParam(conn, "comm_key", response))
{
unsigned int a;
char **words, *found;
/* remove the silly []'s */
while ((found = crStrchr(response, '[')) != NULL)
*found = ' ';
while ((found = crStrchr(response, ']')) != NULL)
*found = ' ';
words = crStrSplit(response, ",");
a = 0;
while (words[a] != NULL && a < sizeof(key)) {
key[a]= crStrToInt(words[a]);
a++;
}
crFreeStrings(words);
}
crNetSetKey(key,sizeof(key));
if (crMothershipGetServerParam(conn, response, "port"))
{
cr_server.tcpip_port = crStrToInt(response);
}
if (crMothershipGetServerParam(conn, response, "optimize_bucket"))
{
cr_server.optimizeBucket = crStrToInt(response);
}
if (crMothershipGetServerParam(conn, response, "local_tile_spec"))
{
cr_server.localTileSpec = crStrToInt(response);
}
if (crMothershipGetServerParam(conn, response, "lightning2"))
{
cr_server.useL2 = crStrToInt(response);
}
if (crMothershipGetServerParam(conn, response, "ignore_papi"))
{
cr_server.ignore_papi = crStrToInt(response);
}
if (crMothershipGetServerParam(conn, response, "overlap_blending"))
{
if (!crStrcmp(response, "blend"))
cr_server.overlapBlending = 1;
else if (!crStrcmp(response, "knockout"))
cr_server.overlapBlending = 2;
}
if (crMothershipGetServerParam(conn, response, "overlap_levels"))
{
int a;
char **levels, *found;
/* remove the []'s */
while ((found = crStrchr(response, '[')))
*found = ' ';
while ((found = crStrchr(response, ']')))
*found = ' ';
levels = crStrSplit(response, ",");
a = 0;
while (levels[a] != NULL)
{
crDebug("%d: %s", a, levels[a]);
cr_server.num_overlap_intens++;
a++;
}
cr_server.overlap_intens = (float *)crAlloc(cr_server.num_overlap_intens*sizeof(float));
for (a=0; a<cr_server.num_overlap_intens; a++)
cr_server.overlap_intens[a] = crStrToFloat(levels[a]);
crFreeStrings(levels);
}
if (crMothershipGetServerParam(conn, response, "only_swap_once"))
{
cr_server.only_swap_once = crStrToInt(response);
}
if (crMothershipGetServerParam(conn, response, "debug_barriers"))
{
cr_server.debug_barriers = crStrToInt(response);
}
if (crMothershipGetServerParam(conn, response, "shared_display_lists"))
{
cr_server.sharedDisplayLists = crStrToInt(response);
}
if (crMothershipGetServerParam(conn, response, "shared_texture_objects"))
{
cr_server.sharedTextureObjects = crStrToInt(response);
}
if (crMothershipGetServerParam(conn, response, "shared_programs"))
{
cr_server.sharedPrograms = crStrToInt(response);
}
if (crMothershipGetServerParam(conn, response, "shared_windows"))
{
cr_server.sharedWindows = crStrToInt(response);
}
if (crMothershipGetServerParam(conn, response, "unique_window_ids"))
{
cr_server.uniqueWindows = crStrToInt(response);
}
if (crMothershipGetServerParam(conn, response, "use_dmx"))
{
cr_server.useDMX = crStrToInt(response);
}
if (crMothershipGetServerParam(conn, response, "vertprog_projection_param"))
{
if (crIsDigit(response[0])) {
cr_server.vpProjectionMatrixParameter = crStrToInt(response);
}
else {
cr_server.vpProjectionMatrixVariable = crStrdup(response);
}
}
if (crMothershipGetServerParam(conn, response, "stereo_view"))
{
if (crStrcmp(response, "left") == 0)
cr_server.stereoView = 0x1;
else if (crStrcmp(response, "right") == 0)
cr_server.stereoView = 0x2;
else if (crStrcmp(response, "both") == 0)
cr_server.stereoView = 0x3;
else
cr_server.stereoView = 0x3;
}
if (crMothershipGetServerParam(conn, response, "view_matrix"))
{
crMatrixInitFromString(&cr_server.viewMatrix[0], response);
cr_server.viewOverride = GL_TRUE;
}
if (crMothershipGetServerParam(conn, response, "right_view_matrix"))
{
crMatrixInitFromString(&cr_server.viewMatrix[1], response);
cr_server.viewOverride = GL_TRUE;
}
if (crMothershipGetServerParam(conn, response, "projection_matrix"))
{
crMatrixInitFromString(&cr_server.projectionMatrix[0], response);
cr_server.projectionOverride = GL_TRUE;
}
if (crMothershipGetServerParam(conn, response, "right_projection_matrix"))
{
crMatrixInitFromString(&cr_server.projectionMatrix[1], response);
cr_server.projectionOverride = GL_TRUE;
}
if (crMothershipGetServerParam(conn, response, "exit_if_no_clients"))
{
cr_server.exitIfNoClients = crStrToInt(response);
}
crDebug("CRServer: my port number is %d", cr_server.tcpip_port);
/*
* Load the SPUs
*/
cr_server.head_spu =
crSPULoadChain(num_spus, spu_ids, spu_names, spu_dir, &cr_server);
/* Need to do this as early as possible */
/* XXX DMX get window size instead? */
cr_server.head_spu->dispatch_table.GetIntegerv(GL_VIEWPORT,
(GLint *) defaultMural->underlyingDisplay);
crFree(spu_ids);
crFreeStrings(spu_names);
crFreeStrings(spuchain);
if (spu_dir)
crFree(spu_dir);
cr_server.mtu = crMothershipGetMTU( conn );
/*
* Get a list of all the clients talking to me.
*/
if (cr_server.vncMode) {
/* we're inside a vnc viewer */
if (!crMothershipSendString( conn, response, "getvncclient %s", hostname ))
crError( "Bad Mothership response: %s", response );
}
else {
crMothershipGetClients(conn, response);
}
crDebug("CRServer: my clients: %s", response);
/*
* 'response' will now contain a number indicating the number of clients
* of this server, followed by a comma-separated list of protocol/SPU ID
* pairs.
* Example: "3 tcpip 1,gm 2,via 10"
*/
clientchain = crStrSplitn(response, " ", 1);
cr_server.numClients = crStrToInt(clientchain[0]);
if (cr_server.numClients == 0)
{
crError("I have no clients! What's a poor server to do?");
}
clientlist = crStrSplit(clientchain[1], ",");
/*
* Connect to initial set of clients.
* Call crNetAcceptClient() for each client.
* Also, look for a client that's _not_ using the file: protocol.
*/
for (i = 0; i < cr_server.numClients; i++)
{
CRClient *newClient = (CRClient *) crCalloc(sizeof(CRClient));
sscanf(clientlist[i], "%s %d", cr_server.protocol, &(newClient->spu_id));
newClient->conn = crNetAcceptClient(cr_server.protocol, NULL,
cr_server.tcpip_port,
cr_server.mtu, 1);
newClient->currentCtx = cr_server.DummyContext;
crServerAddToRunQueue(newClient);
cr_server.clients[i] = newClient;
}
/* set default client and mural */
if (cr_server.numClients > 0) {
cr_server.curClient = cr_server.clients[0];
cr_server.curClient->currentMural = defaultMural;
cr_server.client_spu_id =cr_server.clients[0]->spu_id;
}
crFreeStrings(clientchain);
crFreeStrings(clientlist);
/* Ask the mothership for the tile info */
crServerGetTileInfoFromMothership(conn, defaultMural);
if (cr_server.vncMode) {
/* In vnc mode, we reset the mothership configuration so that it can be
* used by subsequent OpenGL apps without having to spawn a new mothership
* on a new port.
*/
crDebug("CRServer: Resetting mothership to initial state");
crMothershipReset(conn);
}
crMothershipDisconnect(conn);
}
