scene::scene(string filename){
cout << "Reading scene from " << filename << " ..." << endl;
cout << " " << endl;
char* fname = (char*)filename.c_str();
fp_in.open(fname);
if(fp_in.is_open()){
while(fp_in.good()){
string line;
utilityCore::safeGetline(fp_in,line);
if(!line.empty()){
vector<string> tokens = utilityCore::tokenizeString(line);
if(strcmp(tokens[0].c_str(), "MATERIAL")==0){
loadMaterial(tokens[1]);
cout << " " << endl;
}else if(strcmp(tokens[0].c_str(), "OBJECT")==0){
loadObject(tokens[1]);
cout << " " << endl;
}else if(strcmp(tokens[0].c_str(), "CAMERA")==0){
loadCamera();
cout << " " << endl;
}
}
}
}
}
Scene::Scene(string filename) {
cout << "Reading scene from " << filename << " ..." << endl;
cout << " " << endl;
char* fname = (char*)filename.c_str();
fp_in.open(fname);
if (!fp_in.is_open()) {
cout << "Error reading from file - aborting!" << endl;
throw;
}
while (fp_in.good()) {
string line;
utilityCore::safeGetline(fp_in, line);
if (!line.empty()) {
vector<string> tokens = utilityCore::tokenizeString(line);
if (strcmp(tokens[0].c_str(), "MATERIAL") == 0) {
loadMaterial(tokens[1]);
cout << " " << endl;
} else if (strcmp(tokens[0].c_str(), "OBJECT") == 0) {
loadGeom(tokens[1]);
cout << " " << endl;
} else if (strcmp(tokens[0].c_str(), "CAMERA") == 0) {
loadCamera();
cout << " " << endl;
} else if (strcmp(tokens[0].c_str(), "TEXTURE") == 0) {
loadTexture(tokens[1]);
cout << " " << endl;
}
}
}
}
void setupCamera() {
int x;
int y;
int z;
cameraDataStruct *pCamera;
freezeTime();
currentCamera = startGameVar1;
loadCamera(roomDataTable[currentDisplayedRoom].cameraIdxTable[startGameVar1]);
pCamera = cameraDataTable[currentCamera];
setupPointTransformSM(pCamera->_alpha, pCamera->_beta, pCamera->_gamma);
#if INTERNAL_DEBUGGER
if(debuggerVar_topCamera)
setupPointTransformSM(0x100, 0, 0);
#endif
x = (pCamera->_x - roomDataTable[currentDisplayedRoom].worldX) * 10;
y = (roomDataTable[currentDisplayedRoom].worldY - pCamera->_y) * 10;
z = (roomDataTable[currentDisplayedRoom].worldZ - pCamera->_z) * 10;
#if INTERNAL_DEBUGGER
if(debuggerVar_topCamera) {
x = actorTable[genVar9].worldX + actorTable[genVar9].modX;
y = debufferVar_topCameraZoom;
z = actorTable[genVar9].worldZ + actorTable[genVar9].modZ;
}
#endif
setupSelfModifyingCode(x, y, z); // setup camera position
setupSMCode(160, 100, pCamera->_focal1, pCamera->_focal2, pCamera->_focal3); // setup focale
#if INTERNAL_DEBUGGER
if(debuggerVar_topCamera)
setupSMCode(160, 100, 1000, 100, 100); // setup focale
#endif
setupCameraSub1();
updateAllActorAndObjects();
createActorList();
// setupCameraSub3();
setupCameraSub4();
/* setupCameraSub5();
*/
if(mainVar1 == 2) {
setupCameraVar1 = 2;
} else {
if(setupCameraVar1 != 2) {
setupCameraVar1 = 1;
}
}
mainVar1 = 0;
unfreezeTime();
}
//Generate camera_000nnn.rib
void generateRIBCamera(unsigned int idFrame)
{
char bufferFileNumber[10];
sprintf(bufferFileNumber, "%05d", idFrame);
std::stringstream fileName;
fileName << "rib_scene" FILE_SEPARATOR_CHAR "cameras" FILE_SEPARATOR_CHAR "camera_" << bufferFileNumber << ".rib";
FILE* oFile = fopen(fileName.str().c_str(), "w");
fprintf(oFile, "## Camera frame: %s\n\n", bufferFileNumber);
//fprintf(oFile, "Translate 0 -15 70\n");
//fprintf(oFile, "Rotate -30 1 0 0\n");
//fprintf(oFile, "Rotate 45 0 1 0\n\n");
Camera camera = loadCamera(idFrame);
if (camera.eyePosition == LVector3(0.0, 0.0, 0.0))
{
fprintf(oFile, "Translate 0 -3 40\n");
fprintf(oFile, "Rotate -15 1 0 0\n");
fprintf(oFile, "Rotate 45 0 1 0\n\n");
}
else
{
//Camera with position and lookat
float tEyeX = camera.eyePosition.x - camera.lookAt.x;
float tEyeY = camera.eyePosition.y - camera.lookAt.y;
float tEyeZ = camera.eyePosition.z - camera.lookAt.z;
float rc = sqrt(tEyeX*tEyeX + tEyeY*tEyeY + tEyeZ*tEyeZ);
float tc = acos(tEyeY / rc) * 180.0 / CONV_PI - 90;
float pc = - atan2(tEyeZ , tEyeX) * 180.0 / CONV_PI + 90;
fprintf(oFile, "Rotate %f 1 0 0 #Camera lookat tilt\n", tc);
fprintf(oFile, "Rotate %f 0 1 0 #Camera lookat rotate\n", pc);
fprintf(oFile, "Translate %f %f %f #Camera position\n", -camera.eyePosition.x, -camera.eyePosition.y, camera.eyePosition.z);
fprintf(oFile, "Scale 1 1 -1 #Right-hand Coordinate System\n");
/*
//Camera position with lookat at origin (0,0,0)
float r = sqrt(camera.eyePosition.x*camera.eyePosition.x +
camera.eyePosition.y*camera.eyePosition.y +
camera.eyePosition.z*camera.eyePosition.z);
float t = acos(camera.eyePosition.y / r) * 180.0 / CONV_PI - 90;
float p = - atan2(camera.eyePosition.z , camera.eyePosition.x) * 180.0 / CONV_PI + 90;
fprintf(oFile, "Translate 0 0 %f #Camera position\n", r);
fprintf(oFile, "Rotate %f 1 0 0 #Camera tilt\n", t);
fprintf(oFile, "Rotate %f 0 1 0 #Camera rotate\n", p);
fprintf(oFile, "Scale 1 1 -1 #Right-hand Coordinate System\n");
*/
}
//For Dragon shatter animation
//fprintf(oFile, "Rotate -18 1 0 0\n");
//fprintf(oFile, "Translate 0 -15 48\n");
//fprintf(oFile, "Rotate -30 0 1 0\n\n");
fclose (oFile);
}
void DoLoadCamera(){
char basepath[PATH_MAX];
if ( firstCam && firstCam->HasBeenSaved() ) {
CAMERA_ExtractFilePath( firstCam->GetFileName(), basepath );
}
else{
strcpy( basepath, g_FuncTable.m_pfnGetGamePath() );
}
const gchar *filename = g_FuncTable.m_pfnFileDialog( (GtkWidget *)g_pRadiantWnd, TRUE, "Open Camera File", basepath, "camera", NULL );
if ( filename ) {
CCamera *cam = AllocCam();
char fullpathtofile[PATH_MAX];
if ( cam ) {
Q_realpath( filename, fullpathtofile, PATH_MAX );
// see if this camera file was already loaded
CCamera *checkCam = firstCam->GetNext(); // not the first one as we just allocated it
while ( checkCam ) {
if ( !strcmp( fullpathtofile, checkCam->GetFileName() ) ) {
char error[PATH_MAX + 64];
FreeCam( cam );
sprintf( error, "Camera file \'%s\' is already loaded", fullpathtofile );
g_FuncTable.m_pfnMessageBox( (GtkWidget *)g_pRadiantWnd, error, "Load error", MB_OK, NULL );
//g_free( filename );
return;
}
checkCam = checkCam->GetNext();
}
if ( loadCamera( cam->GetCamNum(), fullpathtofile ) ) {
cam->GetCam()->buildCamera();
cam->SetFileName( filename, true );
SetCurrentCam( cam );
RefreshCamListCombo();
g_FuncTable.m_pfnSysUpdateWindows( W_XY_OVERLAY | W_CAMERA );
}
else {
char error[PATH_MAX + 64];
FreeCam( cam );
sprintf( error, "An error occured during the loading of \'%s\'", fullpathtofile );
g_FuncTable.m_pfnMessageBox( (GtkWidget *)g_pRadiantWnd, error, "Load error", MB_OK, NULL );
}
//g_free( filename );
}
else {
g_FuncTable.m_pfnMessageBox( (GtkWidget *)g_pRadiantWnd, "No free camera slots available", "Load error", MB_OK, NULL );
}
}
}
//compute the camera path using the camera keyframes
void computeCubicSplineCameraPath()
{
//Build the cubic splines
CubicSpline splineEyePosition;
CubicSpline splineLookAt;
vector<int> keyIdFrame;
//Add points CubicSpline
for (unsigned int fc = 0; fc <= LarmorPhysx::ConfigManager::total_anim_steps; ++fc)
{
Camera cam = loadCamera(fc);
if(cam.keyframe)
{
cout << "Add point to camera path: frame: " << fc << endl;
splineEyePosition.addPoint(cam.eyePosition);
splineLookAt.addPoint(cam.lookAt);
keyIdFrame.push_back(fc);
}
}
//compute paths
splineEyePosition.compute();
splineLookAt.compute();
//draw camera path getting the points from the spline objects
for(int kf = 0; kf < keyIdFrame.size()-1; kf++)
{
int fc0 = keyIdFrame.at(kf);
int fc1 = keyIdFrame.at(kf+1);
int framesInterval = fc1 - fc0;
double frameStep = 1.0L / framesInterval;
double cubicPos = 0.0;
cout << "interpolation from keyframe: " << fc0 << endl;
for(int pf = fc0+1; pf < fc1; pf++)
{
cout << "interpolation frame: " << pf << endl;
cubicPos += frameStep;
LVector3 eyePosition = splineEyePosition.getPoint(kf, cubicPos);
LVector3 lookAt = splineLookAt.getPoint(kf, cubicPos);
//Create the Camera object and save
Camera camera;
camera.idFrame = pf;
camera.eyePosition = eyePosition;
camera.lookAt = lookAt;
camera.keyframe = false;
//Save camera
saveCamera(camera);
}
cout << "interpolation to keyframe: " << fc1 << endl;
}
}
void SceneXMLParser::loadSimulation(const std::string& file_name,
bool rendering_enabled,
bool gpu_enabled,
openglframework::GLFWViewer* viewer,
Simulation** sim,
scalar& dt,
scalar& max_time,
scalar& steps_per_sec_cap,
openglframework::Color& bgcolor,
std::string& description) {
// Load the xml document
std::vector<char> xmlchars;
rapidxml::xml_document<> doc;
loadXMLFile( file_name, xmlchars, doc );
// Attempt to locate the root node
rapidxml::xml_node<>* node = doc.first_node("scene");
if( node == NULL )
{
std::cerr << outputmod::startred << "ERROR IN XMLSCENEPARSER:" << outputmod::endred
<< "Failed to parse xml scene file. Failed to locate root <scene> node. Exiting." << std::endl;
exit(1);
}
loadMaxTime(node, max_time);
loadMaxSimFrequency(node, steps_per_sec_cap);
if (rendering_enabled) {
loadCamera(node, viewer);
loadViewport(node, viewer);
}
Stepper* stepper = NULL;
loadStepper(node, dt, &stepper);
loadBackgroundColor(node, bgcolor);
loadSceneDescriptionString(node, description);
Scene* scene = new Scene();
loadSimpleGravityForces(node, *scene);
loadFluids(node, *scene, gpu_enabled);
SceneRenderer *renderer = NULL;
if (rendering_enabled)
renderer = new SceneRenderer(scene);
*sim = new Simulation(scene, stepper, renderer);
}
void HouScene::load( const QString &filename )
{
// open new file
QFile file;
file.setFileName(filename);
file.open(QIODevice::ReadOnly | QIODevice::Text);
QJsonDocument sd = QJsonDocument::fromJson(file.readAll());
QJsonObject root = sd.object();
// cameras ---
if( root.contains("cameras") )
{
QJsonObject cameras = root.value("cameras").toObject();
for( auto it = cameras.begin(), end = cameras.end(); it != end; ++it )
m_cameras[it.key()] = loadCamera( it.value().toObject() );
}
}
void LVRMainWindow::connectSignalsAndSlots()
{
QObject::connect(m_actionOpen, SIGNAL(activated()), this, SLOT(loadModel()));
QObject::connect(m_actionExport, SIGNAL(activated()), this, SLOT(exportSelectedModel()));
QObject::connect(treeWidget, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(showTreeContextMenu(const QPoint&)));
QObject::connect(treeWidget, SIGNAL(itemClicked(QTreeWidgetItem*, int)), this, SLOT(restoreSliders(QTreeWidgetItem*, int)));
QObject::connect(treeWidget, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(setModelVisibility(QTreeWidgetItem*, int)));
QObject::connect(m_actionQuit, SIGNAL(activated()), qApp, SLOT(quit()));
QObject::connect(m_actionShowColorDialog, SIGNAL(activated()), this, SLOT(showColorDialog()));
QObject::connect(m_actionRenameModelItem, SIGNAL(activated()), this, SLOT(renameModelItem()));
QObject::connect(m_actionDeleteModelItem, SIGNAL(activated()), this, SLOT(deleteModelItem()));
QObject::connect(m_actionExportModelTransformed, SIGNAL(activated()), this, SLOT(exportSelectedModel()));
QObject::connect(m_actionReset_Camera, SIGNAL(activated()), this, SLOT(updateView()));
QObject::connect(m_actionStore_Current_View, SIGNAL(activated()), this, SLOT(saveCamera()));
QObject::connect(m_actionRecall_Stored_View, SIGNAL(activated()), this, SLOT(loadCamera()));
QObject::connect(m_actionCameraPathTool, SIGNAL(activated()), this, SLOT(openCameraPathTool()));
QObject::connect(m_actionEstimate_Normals, SIGNAL(activated()), this, SLOT(estimateNormals()));
QObject::connect(m_actionMarching_Cubes, SIGNAL(activated()), this, SLOT(reconstructUsingMarchingCubes()));
QObject::connect(m_actionPlanar_Marching_Cubes, SIGNAL(activated()), this, SLOT(reconstructUsingPlanarMarchingCubes()));
QObject::connect(m_actionExtended_Marching_Cubes, SIGNAL(activated()), this, SLOT(reconstructUsingExtendedMarchingCubes()));
QObject::connect(m_actionPlanar_Optimization, SIGNAL(activated()), this, SLOT(optimizePlanes()));
QObject::connect(m_actionRemove_Artifacts, SIGNAL(activated()), this, SLOT(removeArtifacts()));
QObject::connect(m_actionRemove_Outliers, SIGNAL(activated()), this, SLOT(removeOutliers()));
QObject::connect(m_actionMLS_Projection, SIGNAL(activated()), this, SLOT(applyMLSProjection()));
QObject::connect(m_actionICP_Using_Manual_Correspondance, SIGNAL(activated()), this, SLOT(manualICP()));
QObject::connect(m_menuAbout, SIGNAL(triggered(QAction*)), this, SLOT(showAboutDialog(QAction*)));
QObject::connect(m_correspondanceDialog->m_dialog, SIGNAL(accepted()), m_pickingInteractor, SLOT(correspondenceSearchOff()));
QObject::connect(m_correspondanceDialog->m_dialog, SIGNAL(accepted()), this, SLOT(alignPointClouds()));
QObject::connect(m_correspondanceDialog->m_dialog, SIGNAL(rejected()), m_pickingInteractor, SLOT(correspondenceSearchOff()));
QObject::connect(m_correspondanceDialog, SIGNAL(addArrow(LVRVtkArrow*)), this, SLOT(addArrow(LVRVtkArrow*)));
QObject::connect(m_correspondanceDialog, SIGNAL(removeArrow(LVRVtkArrow*)), this, SLOT(removeArrow(LVRVtkArrow*)));
QObject::connect(m_correspondanceDialog, SIGNAL(disableCorrespondenceSearch()), m_pickingInteractor, SLOT(correspondenceSearchOff()));
QObject::connect(m_correspondanceDialog, SIGNAL(enableCorrespondenceSearch()), m_pickingInteractor, SLOT(correspondenceSearchOn()));
QObject::connect(m_actionShow_Points, SIGNAL(toggled(bool)), this, SLOT(togglePoints(bool)));
QObject::connect(m_actionShow_Normals, SIGNAL(toggled(bool)), this, SLOT(toggleNormals(bool)));
QObject::connect(m_actionShow_Mesh, SIGNAL(toggled(bool)), this, SLOT(toggleMeshes(bool)));
QObject::connect(m_actionShow_Wireframe, SIGNAL(toggled(bool)), this, SLOT(toggleWireframe(bool)));
QObject::connect(m_actionShowBackgroundSettings, SIGNAL(activated()), this, SLOT(showBackgroundDialog()));
QObject::connect(m_horizontalSliderPointSize, SIGNAL(valueChanged(int)), this, SLOT(changePointSize(int)));
QObject::connect(m_horizontalSliderTransparency, SIGNAL(valueChanged(int)), this, SLOT(changeTransparency(int)));
QObject::connect(m_comboBoxShading, SIGNAL(currentIndexChanged(int)), this, SLOT(changeShading(int)));
QObject::connect(m_buttonCameraPathTool, SIGNAL(pressed()), this, SLOT(openCameraPathTool()));
QObject::connect(m_buttonCreateMesh, SIGNAL(pressed()), this, SLOT(reconstructUsingMarchingCubes()));
QObject::connect(m_buttonExportData, SIGNAL(pressed()), this, SLOT(exportSelectedModel()));
QObject::connect(m_buttonTransformModel, SIGNAL(pressed()), this, SLOT(showTransformationDialog()));
QObject::connect(m_pickingInteractor, SIGNAL(firstPointPicked(double*)),m_correspondanceDialog, SLOT(firstPointPicked(double*)));
QObject::connect(m_pickingInteractor, SIGNAL(secondPointPicked(double*)),m_correspondanceDialog, SLOT(secondPointPicked(double*)));
QObject::connect(this, SIGNAL(correspondenceDialogOpened()), m_pickingInteractor, SLOT(correspondenceSearchOn()));
}
// The cgame module is making a system call
qintptr CLWS_CgameSystemCalls( qintptr* args ) {
switch ( args[ 0 ] ) {
case WSCG_PRINT:
common->Printf( "%s", ( char* )VMA( 1 ) );
return 0;
case WSCG_ERROR:
common->Error( "%s", ( char* )VMA( 1 ) );
return 0;
case WSCG_MILLISECONDS:
return Sys_Milliseconds();
case WSCG_CVAR_REGISTER:
Cvar_Register( ( vmCvar_t* )VMA( 1 ), ( char* )VMA( 2 ), ( char* )VMA( 3 ), args[ 4 ] );
return 0;
case WSCG_CVAR_UPDATE:
Cvar_Update( ( vmCvar_t* )VMA( 1 ) );
return 0;
case WSCG_CVAR_SET:
Cvar_Set( ( char* )VMA( 1 ), ( char* )VMA( 2 ) );
return 0;
case WSCG_CVAR_VARIABLESTRINGBUFFER:
Cvar_VariableStringBuffer( ( char* )VMA( 1 ), ( char* )VMA( 2 ), args[ 3 ] );
return 0;
case WSCG_ARGC:
return Cmd_Argc();
case WSCG_ARGV:
Cmd_ArgvBuffer( args[ 1 ], ( char* )VMA( 2 ), args[ 3 ] );
return 0;
case WSCG_ARGS:
Cmd_ArgsBuffer( ( char* )VMA( 1 ), args[ 2 ] );
return 0;
case WSCG_FS_FOPENFILE:
return FS_FOpenFileByMode( ( char* )VMA( 1 ), ( fileHandle_t* )VMA( 2 ), ( fsMode_t )args[ 3 ] );
case WSCG_FS_READ:
FS_Read( VMA( 1 ), args[ 2 ], args[ 3 ] );
return 0;
case WSCG_FS_WRITE:
return FS_Write( VMA( 1 ), args[ 2 ], args[ 3 ] );
case WSCG_FS_FCLOSEFILE:
FS_FCloseFile( args[ 1 ] );
return 0;
case WSCG_SENDCONSOLECOMMAND:
Cbuf_AddText( ( char* )VMA( 1 ) );
return 0;
case WSCG_ADDCOMMAND:
CLT3_AddCgameCommand( ( char* )VMA( 1 ) );
return 0;
case WSCG_REMOVECOMMAND:
Cmd_RemoveCommand( ( char* )VMA( 1 ) );
return 0;
case WSCG_SENDCLIENTCOMMAND:
CL_AddReliableCommand( ( char* )VMA( 1 ) );
return 0;
case WSCG_UPDATESCREEN:
SCR_UpdateScreen();
return 0;
case WSCG_CM_LOADMAP:
CLT3_CM_LoadMap( ( char* )VMA( 1 ) );
return 0;
case WSCG_CM_NUMINLINEMODELS:
return CM_NumInlineModels();
case WSCG_CM_INLINEMODEL:
return CM_InlineModel( args[ 1 ] );
case WSCG_CM_TEMPBOXMODEL:
return CM_TempBoxModel( ( float* )VMA( 1 ), ( float* )VMA( 2 ), false );
case WSCG_CM_TEMPCAPSULEMODEL:
return CM_TempBoxModel( ( float* )VMA( 1 ), ( float* )VMA( 2 ), true );
case WSCG_CM_POINTCONTENTS:
return CM_PointContentsQ3( ( float* )VMA( 1 ), args[ 2 ] );
case WSCG_CM_TRANSFORMEDPOINTCONTENTS:
return CM_TransformedPointContentsQ3( ( float* )VMA( 1 ), args[ 2 ], ( float* )VMA( 3 ), ( float* )VMA( 4 ) );
case WSCG_CM_BOXTRACE:
CM_BoxTraceQ3( ( q3trace_t* )VMA( 1 ), ( float* )VMA( 2 ), ( float* )VMA( 3 ), ( float* )VMA( 4 ), ( float* )VMA( 5 ), args[ 6 ], args[ 7 ], false );
return 0;
case WSCG_CM_TRANSFORMEDBOXTRACE:
CM_TransformedBoxTraceQ3( ( q3trace_t* )VMA( 1 ), ( float* )VMA( 2 ), ( float* )VMA( 3 ), ( float* )VMA( 4 ), ( float* )VMA( 5 ), args[ 6 ], args[ 7 ], ( float* )VMA( 8 ), ( float* )VMA( 9 ), false );
return 0;
case WSCG_CM_CAPSULETRACE:
CM_BoxTraceQ3( ( q3trace_t* )VMA( 1 ), ( float* )VMA( 2 ), ( float* )VMA( 3 ), ( float* )VMA( 4 ), ( float* )VMA( 5 ), args[ 6 ], args[ 7 ], true );
return 0;
case WSCG_CM_TRANSFORMEDCAPSULETRACE:
CM_TransformedBoxTraceQ3( ( q3trace_t* )VMA( 1 ), ( float* )VMA( 2 ), ( float* )VMA( 3 ), ( float* )VMA( 4 ), ( float* )VMA( 5 ), args[ 6 ], args[ 7 ], ( float* )VMA( 8 ), ( float* )VMA( 9 ), true );
return 0;
case WSCG_CM_MARKFRAGMENTS:
return R_MarkFragmentsWolf( args[ 1 ], ( const vec3_t* )VMA( 2 ), ( float* )VMA( 3 ), args[ 4 ], ( float* )VMA( 5 ), args[ 6 ], ( markFragment_t* )VMA( 7 ) );
case WSCG_S_STARTSOUND:
S_StartSound( ( float* )VMA( 1 ), args[ 2 ], args[ 3 ], args[ 4 ], 0.5 );
return 0;
case WSCG_S_STARTSOUNDEX:
S_StartSoundEx( ( float* )VMA( 1 ), args[ 2 ], args[ 3 ], args[ 4 ], args[ 5 ], 127 );
return 0;
case WSCG_S_STARTLOCALSOUND:
S_StartLocalSound( args[ 1 ], args[ 2 ], 127 );
return 0;
case WSCG_S_CLEARLOOPINGSOUNDS:
CLWS_ClearLoopingSounds( args[ 1 ] );
return 0;
case WSCG_S_ADDLOOPINGSOUND:
// FIXME MrE: handling of looping sounds changed
S_AddLoopingSound( args[ 1 ], ( float* )VMA( 2 ), ( float* )VMA( 3 ), args[ 4 ], args[ 5 ], args[ 6 ], 0 );
return 0;
case WSCG_S_STOPSTREAMINGSOUND:
S_StopEntStreamingSound( args[ 1 ] );
return 0;
case WSCG_S_STOPLOOPINGSOUND:
// RF, not functional anymore, since we reverted to old looping code
return 0;
case WSCG_S_UPDATEENTITYPOSITION:
S_UpdateEntityPosition( args[ 1 ], ( float* )VMA( 2 ) );
return 0;
case WSCG_S_GETVOICEAMPLITUDE:
return S_GetVoiceAmplitude( args[ 1 ] );
case WSCG_S_RESPATIALIZE:
S_Respatialize( args[ 1 ], ( float* )VMA( 2 ), ( vec3_t* )VMA( 3 ), args[ 4 ] );
return 0;
case WSCG_S_REGISTERSOUND:
return S_RegisterSound( ( char* )VMA( 1 ) );
case WSCG_S_STARTBACKGROUNDTRACK:
S_StartBackgroundTrack( ( char* )VMA( 1 ), ( char* )VMA( 2 ), args[ 3 ] ); //----(SA) added fadeup time
return 0;
case WSCG_S_FADESTREAMINGSOUND:
S_FadeStreamingSound( VMF( 1 ), args[ 2 ], args[ 3 ] ); //----(SA) added music/all-streaming options
return 0;
case WSCG_S_STARTSTREAMINGSOUND:
S_StartStreamingSound( ( char* )VMA( 1 ), ( char* )VMA( 2 ), args[ 3 ], args[ 4 ], args[ 5 ] );
return 0;
case WSCG_S_FADEALLSOUNDS:
S_FadeAllSounds( VMF( 1 ), args[ 2 ], false ); //----(SA) added
return 0;
case WSCG_R_LOADWORLDMAP:
R_LoadWorld( ( char* )VMA( 1 ) );
return 0;
case WSCG_R_REGISTERMODEL:
return R_RegisterModel( ( char* )VMA( 1 ) );
case WSCG_R_REGISTERSKIN:
return R_RegisterSkin( ( char* )VMA( 1 ) );
case WSCG_R_GETSKINMODEL:
return R_GetSkinModel( args[ 1 ], ( char* )VMA( 2 ), ( char* )VMA( 3 ) );
case WSCG_R_GETMODELSHADER:
return R_GetShaderFromModel( args[ 1 ], args[ 2 ], args[ 3 ] );
case WSCG_R_REGISTERSHADER:
return R_RegisterShader( ( char* )VMA( 1 ) );
case WSCG_R_REGISTERFONT:
R_RegisterFont( ( char* )VMA( 1 ), args[ 2 ], ( fontInfo_t* )VMA( 3 ) );
case WSCG_R_REGISTERSHADERNOMIP:
return R_RegisterShaderNoMip( ( char* )VMA( 1 ) );
case WSCG_R_CLEARSCENE:
R_ClearScene();
return 0;
case WSCG_R_ADDREFENTITYTOSCENE:
CLWS_AddRefEntityToScene( ( wsrefEntity_t* )VMA( 1 ) );
return 0;
case WSCG_R_ADDPOLYTOSCENE:
R_AddPolyToScene( args[ 1 ], args[ 2 ], ( polyVert_t* )VMA( 3 ), 1 );
return 0;
case WSCG_R_ADDPOLYSTOSCENE:
R_AddPolyToScene( args[ 1 ], args[ 2 ], ( polyVert_t* )VMA( 3 ), args[ 4 ] );
return 0;
case WSCG_RB_ZOMBIEFXADDNEWHIT:
return 0;
case WSCG_R_ADDLIGHTTOSCENE:
R_AddLightToScene( ( float* )VMA( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), args[ 6 ] );
return 0;
case WSCG_R_ADDCORONATOSCENE:
R_AddCoronaToScene( ( float* )VMA( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), args[ 6 ], args[ 7 ] );
return 0;
case WSCG_R_SETFOG:
R_SetFog( args[ 1 ], args[ 2 ], args[ 3 ], VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ) );
return 0;
case WSCG_R_RENDERSCENE:
CLWS_RenderScene( ( wsrefdef_t* )VMA( 1 ) );
return 0;
case WSCG_R_SETCOLOR:
R_SetColor( ( float* )VMA( 1 ) );
return 0;
case WSCG_R_DRAWSTRETCHPIC:
R_StretchPic( VMF( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ), VMF( 8 ), args[ 9 ] );
return 0;
case WSCG_R_DRAWSTRETCHPIC_GRADIENT:
R_StretchPicGradient( VMF( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ), VMF( 8 ), args[ 9 ], ( float* )VMA( 10 ), args[ 11 ] );
return 0;
case WSCG_R_MODELBOUNDS:
R_ModelBounds( args[ 1 ], ( float* )VMA( 2 ), ( float* )VMA( 3 ) );
return 0;
case WSCG_R_LERPTAG:
return CLWS_LerpTag( ( orientation_t* )VMA( 1 ), ( wsrefEntity_t* )VMA( 2 ), ( char* )VMA( 3 ), args[ 4 ] );
case WSCG_GETGLCONFIG:
CLWS_GetGlconfig( ( wsglconfig_t* )VMA( 1 ) );
return 0;
case WSCG_GETGAMESTATE:
CLWS_GetGameState( ( wsgameState_t* )VMA( 1 ) );
return 0;
case WSCG_GETCURRENTSNAPSHOTNUMBER:
CLWS_GetCurrentSnapshotNumber( ( int* )VMA( 1 ), ( int* )VMA( 2 ) );
return 0;
case WSCG_GETSNAPSHOT:
return CLWS_GetSnapshot( args[ 1 ], ( wssnapshot_t* )VMA( 2 ) );
case WSCG_GETSERVERCOMMAND:
return CLT3_GetServerCommand( args[ 1 ] );
case WSCG_GETCURRENTCMDNUMBER:
return CLT3_GetCurrentCmdNumber();
case WSCG_GETUSERCMD:
return CLWS_GetUserCmd( args[ 1 ], ( wsusercmd_t* )VMA( 2 ) );
case WSCG_SETUSERCMDVALUE:
CLWS_SetUserCmdValue( args[ 1 ], args[ 2 ], VMF( 3 ), args[ 4 ] ); //----(SA) modified // NERVE - SMF - added fourth arg [cld]
return 0;
case WSCG_MEMORY_REMAINING:
return 0x4000000;
case WSCG_KEY_ISDOWN:
return Key_IsDown( args[ 1 ] );
case WSCG_KEY_GETCATCHER:
return Key_GetCatcher();
case WSCG_KEY_SETCATCHER:
KeyQ3_SetCatcher( args[ 1 ] );
return 0;
case WSCG_KEY_GETKEY:
return Key_GetKey( ( char* )VMA( 1 ) );
case WSCG_MEMSET:
return ( qintptr )memset( VMA( 1 ), args[ 2 ], args[ 3 ] );
case WSCG_MEMCPY:
return ( qintptr )memcpy( VMA( 1 ), VMA( 2 ), args[ 3 ] );
case WSCG_STRNCPY:
String::NCpy( ( char* )VMA( 1 ), ( char* )VMA( 2 ), args[ 3 ] );
return args[ 1 ];
case WSCG_SIN:
return FloatAsInt( sin( VMF( 1 ) ) );
case WSCG_COS:
return FloatAsInt( cos( VMF( 1 ) ) );
case WSCG_ATAN2:
return FloatAsInt( atan2( VMF( 1 ), VMF( 2 ) ) );
case WSCG_SQRT:
return FloatAsInt( sqrt( VMF( 1 ) ) );
case WSCG_FLOOR:
return FloatAsInt( floor( VMF( 1 ) ) );
case WSCG_CEIL:
return FloatAsInt( ceil( VMF( 1 ) ) );
case WSCG_ACOS:
return FloatAsInt( idMath::ACos( VMF( 1 ) ) );
case WSCG_PC_ADD_GLOBAL_DEFINE:
return PC_AddGlobalDefine( ( char* )VMA( 1 ) );
case WSCG_PC_LOAD_SOURCE:
return PC_LoadSourceHandle( ( char* )VMA( 1 ) );
case WSCG_PC_FREE_SOURCE:
return PC_FreeSourceHandle( args[ 1 ] );
case WSCG_PC_READ_TOKEN:
return PC_ReadTokenHandleQ3( args[ 1 ], ( q3pc_token_t* )VMA( 2 ) );
case WSCG_PC_SOURCE_FILE_AND_LINE:
return PC_SourceFileAndLine( args[ 1 ], ( char* )VMA( 2 ), ( int* )VMA( 3 ) );
case WSCG_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack();
return 0;
case WSCG_REAL_TIME:
return Com_RealTime( ( qtime_t* )VMA( 1 ) );
case WSCG_SNAPVECTOR:
Sys_SnapVector( ( float* )VMA( 1 ) );
return 0;
case WSCG_SENDMOVESPEEDSTOGAME:
SVWS_SendMoveSpeedsToGame( args[ 1 ], ( char* )VMA( 2 ) );
return 0;
case WSCG_CIN_PLAYCINEMATIC:
return CIN_PlayCinematicStretched( ( char* )VMA( 1 ), args[ 2 ], args[ 3 ], args[ 4 ], args[ 5 ], args[ 6 ] );
case WSCG_CIN_STOPCINEMATIC:
return CIN_StopCinematic( args[ 1 ] );
case WSCG_CIN_RUNCINEMATIC:
return CIN_RunCinematic( args[ 1 ] );
case WSCG_CIN_DRAWCINEMATIC:
CIN_DrawCinematic( args[ 1 ] );
return 0;
case WSCG_CIN_SETEXTENTS:
CIN_SetExtents( args[ 1 ], args[ 2 ], args[ 3 ], args[ 4 ], args[ 5 ] );
return 0;
case WSCG_R_REMAP_SHADER:
R_RemapShader( ( char* )VMA( 1 ), ( char* )VMA( 2 ), ( char* )VMA( 3 ) );
return 0;
case WSCG_TESTPRINTINT:
common->Printf( "%s%i\n", ( char* )VMA( 1 ), static_cast<int>( args[ 2 ] ) );
return 0;
case WSCG_TESTPRINTFLOAT:
common->Printf( "%s%f\n", ( char* )VMA( 1 ), VMF( 2 ) );
return 0;
case WSCG_LOADCAMERA:
return loadCamera( args[ 1 ], ( char* )VMA( 2 ) );
case WSCG_STARTCAMERA:
CLWS_StartCamera( args[ 1 ], args[ 2 ] );
return 0;
case WSCG_STOPCAMERA:
CLWS_StopCamera( args[ 1 ] );
return 0;
case WSCG_GETCAMERAINFO:
return getCameraInfo( args[ 1 ], args[ 2 ], ( float* )VMA( 3 ), ( float* )VMA( 4 ), ( float* )VMA( 5 ) );
case WSCG_GET_ENTITY_TOKEN:
return R_GetEntityToken( ( char* )VMA( 1 ), args[ 2 ] );
case WSCG_INGAME_POPUP:
CLWS_InGamePopup( ( char* )VMA( 1 ) );
return 0;
case WSCG_INGAME_CLOSEPOPUP:
UIT3_KeyEvent( K_ESCAPE, true );
return 0;
case WSCG_LIMBOCHAT:
CLT3_AddToLimboChat( ( char* )VMA( 1 ) );
return 0;
case WSCG_GETMODELINFO:
return SVWS_GetModelInfo( args[ 1 ], ( char* )VMA( 2 ), ( animModelInfo_t** )VMA( 3 ) );
default:
common->Error( "Bad cgame system trap: %i", static_cast<int>( args[ 0 ] ) );
}
return 0;
}
tracking_window::tracking_window(QWidget *parent,ODFModel* new_handle,bool handle_release_) :
QMainWindow(parent),handle(new_handle),handle_release(handle_release_),
ui(new Ui::tracking_window),scene(*this,new_handle),slice(new_handle)
{
ODFModel* odf_model = (ODFModel*)handle;
FibData& fib_data = odf_model->fib_data;
odf_size = fib_data.fib.odf_table.size();
odf_face_size = fib_data.fib.odf_faces.size();
has_odfs = fib_data.fib.has_odfs() ? 1:0;
// check whether first index is "fa0"
is_dti = (fib_data.view_item[0].name[0] == 'f');
ui->setupUi(this);
{
setGeometry(10,10,800,600);
ui->regionDockWidget->setMinimumWidth(0);
ui->dockWidget->setMinimumWidth(0);
ui->dockWidget_3->setMinimumWidth(0);
ui->renderingLayout->addWidget(renderWidget = new RenderingTableWidget(*this,ui->renderingWidgetHolder,has_odfs));
ui->centralLayout->insertWidget(1,glWidget = new GLWidget(renderWidget->getData("anti_aliasing").toInt(),
*this,renderWidget,ui->centralwidget));
ui->verticalLayout_3->addWidget(regionWidget = new RegionTableWidget(*this,ui->regionDockWidget));
ui->tractverticalLayout->addWidget(tractWidget = new TractTableWidget(*this,ui->TractWidgetHolder));
ui->graphicsView->setScene(&scene);
ui->graphicsView->setCursor(Qt::CrossCursor);
scene.statusbar = ui->statusbar;
color_bar.reset(new color_bar_dialog(this));
}
// setup fa threshold
{
for(int index = 0;index < fib_data.fib.index_name.size();++index)
ui->tracking_index->addItem((fib_data.fib.index_name[index]+" threshold").c_str());
ui->tracking_index->setCurrentIndex(0);
ui->step_size->setValue(fib_data.vs[0]/2.0);
}
// setup sliders
{
slice_no_update = true;
ui->SagSlider->setRange(0,slice.geometry[0]-1);
ui->CorSlider->setRange(0,slice.geometry[1]-1);
ui->AxiSlider->setRange(0,slice.geometry[2]-1);
ui->SagSlider->setValue(slice.slice_pos[0]);
ui->CorSlider->setValue(slice.slice_pos[1]);
ui->AxiSlider->setValue(slice.slice_pos[2]);
ui->glSagBox->setRange(0,slice.geometry[0]-1);
ui->glCorBox->setRange(0,slice.geometry[1]-1);
ui->glAxiBox->setRange(0,slice.geometry[2]-1);
ui->glSagBox->setValue(slice.slice_pos[0]);
ui->glCorBox->setValue(slice.slice_pos[1]);
ui->glAxiBox->setValue(slice.slice_pos[2]);
slice_no_update = false;
on_SliceModality_currentIndexChanged(0);
for (unsigned int index = 0;index < fib_data.view_item.size(); ++index)
{
ui->sliceViewBox->addItem(fib_data.view_item[index].name.c_str());
if(fib_data.view_item[index].is_overlay)
ui->overlay->addItem(fib_data.view_item[index].name.c_str());
}
ui->sliceViewBox->setCurrentIndex(0);
ui->overlay->setCurrentIndex(0);
if(ui->overlay->count() == 1)
ui->overlay->hide();
}
is_qsdr = !handle->fib_data.trans_to_mni.empty();
// setup atlas
if(!fa_template_imp.I.empty() && fib_data.vs[0] > 0.5 && !is_qsdr)
{
mi3_arg.scaling[0] = slice.voxel_size[0] / std::fabs(fa_template_imp.tran[0]);
mi3_arg.scaling[1] = slice.voxel_size[1] / std::fabs(fa_template_imp.tran[5]);
mi3_arg.scaling[2] = slice.voxel_size[2] / std::fabs(fa_template_imp.tran[10]);
image::reg::align_center(slice.source_images,fa_template_imp.I,mi3_arg);
mi3.reset(new manual_alignment(this,slice.source_images,fa_template_imp.I,mi3_arg));
is_qsdr = false;
}
else
ui->actionManual_Registration->setEnabled(false);
ui->actionConnectometry->setEnabled(handle->fib_data.fib.has_odfs() && is_qsdr);
for(int index = 0;index < atlas_list.size();++index)
ui->atlasListBox->addItem(atlas_list[index].name.c_str());
{
if(is_dti)
ui->actionQuantitative_anisotropy_QA->setText("Save FA...");
for (int index = fib_data.other_mapping_index; index < fib_data.view_item.size(); ++index)
{
std::string& name = fib_data.view_item[index].name;
QAction* Item = new QAction(this);
Item->setText(QString("Save %1...").arg(name.c_str()));
Item->setData(QString(name.c_str()));
Item->setVisible(true);
connect(Item, SIGNAL(triggered()),tractWidget, SLOT(save_tracts_data_as()));
ui->menuSave->addAction(Item);
}
}
// opengl
{
connect(renderWidget->treemodel,SIGNAL(dataChanged(QModelIndex,QModelIndex)),
glWidget,SLOT(updateGL()));
connect(ui->tbDefaultParam,SIGNAL(clicked()),renderWidget,SLOT(setDefault()));
connect(ui->tbDefaultParam,SIGNAL(clicked()),glWidget,SLOT(updateGL()));
connect(ui->glSagSlider,SIGNAL(valueChanged(int)),this,SLOT(glSliderValueChanged()));
connect(ui->glCorSlider,SIGNAL(valueChanged(int)),this,SLOT(glSliderValueChanged()));
connect(ui->glAxiSlider,SIGNAL(valueChanged(int)),this,SLOT(glSliderValueChanged()));
connect(ui->glSagCheck,SIGNAL(stateChanged(int)),glWidget,SLOT(updateGL()));
connect(ui->glCorCheck,SIGNAL(stateChanged(int)),glWidget,SLOT(updateGL()));
connect(ui->glAxiCheck,SIGNAL(stateChanged(int)),glWidget,SLOT(updateGL()));
connect(ui->glSagView,SIGNAL(clicked()),this,SLOT(on_SagView_clicked()));
connect(ui->glCorView,SIGNAL(clicked()),this,SLOT(on_CorView_clicked()));
connect(ui->glAxiView,SIGNAL(clicked()),this,SLOT(on_AxiView_clicked()));
connect(ui->addSlices,SIGNAL(clicked()),this,SLOT(on_actionInsert_T1_T2_triggered()));
connect(ui->actionAdd_surface,SIGNAL(triggered()),glWidget,SLOT(addSurface()));
connect(ui->SliceModality,SIGNAL(currentIndexChanged(int)),glWidget,SLOT(updateGL()));
connect(ui->actionSave_Screen,SIGNAL(triggered()),glWidget,SLOT(catchScreen()));
connect(ui->actionSave_3D_screen_in_high_resolution,SIGNAL(triggered()),glWidget,SLOT(catchScreen2()));
connect(ui->actionLoad_Camera,SIGNAL(triggered()),glWidget,SLOT(loadCamera()));
connect(ui->actionSave_Camera,SIGNAL(triggered()),glWidget,SLOT(saveCamera()));
connect(ui->actionLoad_mapping,SIGNAL(triggered()),glWidget,SLOT(loadMapping()));
connect(ui->actionSave_mapping,SIGNAL(triggered()),glWidget,SLOT(saveMapping()));
connect(ui->actionSave_Rotation_Images,SIGNAL(triggered()),glWidget,SLOT(saveRotationSeries()));
connect(ui->actionSave_Left_Right_3D_Image,SIGNAL(triggered()),glWidget,SLOT(saveLeftRight3DImage()));
}
// scene view
{
connect(ui->SagSlider,SIGNAL(valueChanged(int)),this,SLOT(SliderValueChanged()));
connect(ui->CorSlider,SIGNAL(valueChanged(int)),this,SLOT(SliderValueChanged()));
connect(ui->AxiSlider,SIGNAL(valueChanged(int)),this,SLOT(SliderValueChanged()));
connect(&scene,SIGNAL(need_update()),&scene,SLOT(show_slice()));
connect(&scene,SIGNAL(need_update()),glWidget,SLOT(updateGL()));
connect(ui->fa_threshold,SIGNAL(valueChanged(double)),&scene,SLOT(show_slice()));
connect(ui->contrast,SIGNAL(valueChanged(int)),&scene,SLOT(show_slice()));
connect(ui->offset,SIGNAL(valueChanged(int)),&scene,SLOT(show_slice()));
connect(ui->show_fiber,SIGNAL(clicked()),&scene,SLOT(show_slice()));
connect(ui->show_pos,SIGNAL(clicked()),&scene,SLOT(show_slice()));
connect(ui->show_lr,SIGNAL(clicked()),&scene,SLOT(show_slice()));
connect(ui->zoom,SIGNAL(valueChanged(double)),&scene,SLOT(show_slice()));
connect(ui->zoom,SIGNAL(valueChanged(double)),&scene,SLOT(center()));
connect(ui->actionAxial_View,SIGNAL(triggered()),this,SLOT(on_AxiView_clicked()));
connect(ui->actionCoronal_View,SIGNAL(triggered()),this,SLOT(on_CorView_clicked()));
connect(ui->actionSagittal_view,SIGNAL(triggered()),this,SLOT(on_SagView_clicked()));
connect(ui->actionSave_ROI_Screen,SIGNAL(triggered()),&scene,SLOT(catch_screen()));
connect(ui->actionSave_Anisotrpy_Map_as,SIGNAL(triggered()),&scene,SLOT(save_slice_as()));
connect(ui->overlay,SIGNAL(currentIndexChanged(int)),this,SLOT(on_sliceViewBox_currentIndexChanged(int)));
}
// regions
{
connect(regionWidget,SIGNAL(need_update()),&scene,SLOT(show_slice()));
connect(regionWidget,SIGNAL(need_update()),glWidget,SLOT(updateGL()));
connect(ui->whole_brain,SIGNAL(clicked()),regionWidget,SLOT(whole_brain()));
connect(ui->view_style,SIGNAL(currentIndexChanged(int)),&scene,SLOT(show_slice()));
//atlas
connect(ui->addRegionFromAtlas,SIGNAL(clicked()),regionWidget,SLOT(add_atlas()));
connect(ui->actionNewRegion,SIGNAL(triggered()),regionWidget,SLOT(new_region()));
connect(ui->actionOpenRegion,SIGNAL(triggered()),regionWidget,SLOT(load_region()));
connect(ui->actionSaveRegionAs,SIGNAL(triggered()),regionWidget,SLOT(save_region()));
connect(ui->actionSave_Voxel_Data_As,SIGNAL(triggered()),regionWidget,SLOT(save_region_info()));
connect(ui->actionDeleteRegion,SIGNAL(triggered()),regionWidget,SLOT(delete_region()));
connect(ui->actionDeleteRegionAll,SIGNAL(triggered()),regionWidget,SLOT(delete_all_region()));
// actions
connect(ui->actionShift_X,SIGNAL(triggered()),regionWidget,SLOT(action_shiftx()));
connect(ui->actionShift_X_2,SIGNAL(triggered()),regionWidget,SLOT(action_shiftnx()));
connect(ui->actionShift_Y,SIGNAL(triggered()),regionWidget,SLOT(action_shifty()));
connect(ui->actionShift_Y_2,SIGNAL(triggered()),regionWidget,SLOT(action_shiftny()));
connect(ui->actionShift_Z,SIGNAL(triggered()),regionWidget,SLOT(action_shiftz()));
connect(ui->actionShift_Z_2,SIGNAL(triggered()),regionWidget,SLOT(action_shiftnz()));
connect(ui->actionFlip_X,SIGNAL(triggered()),regionWidget,SLOT(action_flipx()));
connect(ui->actionFlip_Y,SIGNAL(triggered()),regionWidget,SLOT(action_flipy()));
connect(ui->actionFlip_Z,SIGNAL(triggered()),regionWidget,SLOT(action_flipz()));
connect(ui->actionThreshold,SIGNAL(triggered()),regionWidget,SLOT(action_threshold()));
connect(ui->actionSmoothing,SIGNAL(triggered()),regionWidget,SLOT(action_smoothing()));
connect(ui->actionErosion,SIGNAL(triggered()),regionWidget,SLOT(action_erosion()));
connect(ui->actionDilation,SIGNAL(triggered()),regionWidget,SLOT(action_dilation()));
connect(ui->actionNegate,SIGNAL(triggered()),regionWidget,SLOT(action_negate()));
connect(ui->actionDefragment,SIGNAL(triggered()),regionWidget,SLOT(action_defragment()));
connect(ui->actionCheck_all_regions,SIGNAL(triggered()),regionWidget,SLOT(check_all()));
connect(ui->actionUnckech_all_regions,SIGNAL(triggered()),regionWidget,SLOT(uncheck_all()));
connect(ui->actionWhole_brain_seeding,SIGNAL(triggered()),regionWidget,SLOT(whole_brain()));
connect(ui->actionRegion_statistics,SIGNAL(triggered()),regionWidget,SLOT(show_statistics()));
}
// tracts
{
connect(ui->perform_tracking,SIGNAL(clicked()),tractWidget,SLOT(start_tracking()));
connect(ui->stopTracking,SIGNAL(clicked()),tractWidget,SLOT(stop_tracking()));
connect(tractWidget,SIGNAL(need_update()),glWidget,SLOT(makeTracts()));
connect(tractWidget,SIGNAL(need_update()),glWidget,SLOT(updateGL()));
connect(glWidget,SIGNAL(edited()),tractWidget,SLOT(edit_tracts()));
connect(glWidget,SIGNAL(region_edited()),glWidget,SLOT(updateGL()));
connect(glWidget,SIGNAL(region_edited()),&scene,SLOT(show_slice()));
connect(ui->actionOpenTract,SIGNAL(triggered()),tractWidget,SLOT(load_tracts()));
connect(ui->actionMerge_All,SIGNAL(triggered()),tractWidget,SLOT(merge_all()));
connect(ui->actionCopyTrack,SIGNAL(triggered()),tractWidget,SLOT(copy_track()));
connect(ui->actionDeleteTract,SIGNAL(triggered()),tractWidget,SLOT(delete_tract()));
connect(ui->actionDeleteTractAll,SIGNAL(triggered()),tractWidget,SLOT(delete_all_tract()));
connect(ui->actionOpen_Colors,SIGNAL(triggered()),tractWidget,SLOT(load_tracts_color()));
connect(ui->actionSave_Tracts_Colors_As,SIGNAL(triggered()),tractWidget,SLOT(save_tracts_color_as()));
connect(ui->actionUndo,SIGNAL(triggered()),tractWidget,SLOT(undo_tracts()));
connect(ui->actionRedo,SIGNAL(triggered()),tractWidget,SLOT(redo_tracts()));
connect(ui->actionTrim,SIGNAL(triggered()),tractWidget,SLOT(trim_tracts()));
connect(ui->actionSet_Color,SIGNAL(triggered()),tractWidget,SLOT(set_color()));
connect(ui->actionK_means,SIGNAL(triggered()),tractWidget,SLOT(clustering_kmeans()));
connect(ui->actionEM,SIGNAL(triggered()),tractWidget,SLOT(clustering_EM()));
connect(ui->actionHierarchical,SIGNAL(triggered()),tractWidget,SLOT(clustering_hie()));
connect(ui->actionOpen_Cluster_Labels,SIGNAL(triggered()),tractWidget,SLOT(open_cluster_label()));
//setup menu
connect(ui->actionSaveTractAs,SIGNAL(triggered()),tractWidget,SLOT(save_tracts_as()));
connect(ui->actionSave_All_Tracts_As,SIGNAL(triggered()),tractWidget,SLOT(save_all_tracts_as()));
connect(ui->actionQuantitative_anisotropy_QA,SIGNAL(triggered()),tractWidget,SLOT(save_fa_as()));
connect(ui->actionSave_End_Points_As,SIGNAL(triggered()),tractWidget,SLOT(save_end_point_as()));
connect(ui->actionStatistics,SIGNAL(triggered()),tractWidget,SLOT(show_tracts_statistics()));
connect(ui->track_up,SIGNAL(clicked()),tractWidget,SLOT(move_up()));
connect(ui->track_down,SIGNAL(clicked()),tractWidget,SLOT(move_down()));
}
// recall the setting
{
QSettings settings;
if(!default_geo.size())
default_geo = saveGeometry();
if(!default_state.size())
default_state = saveState();
restoreGeometry(settings.value("geometry").toByteArray());
restoreState(settings.value("state").toByteArray());
ui->turning_angle->setValue(settings.value("turning_angle",60).toDouble());
ui->smoothing->setValue(settings.value("smoothing",0.0).toDouble());
ui->min_length->setValue(settings.value("min_length",0.0).toDouble());
ui->max_length->setValue(settings.value("max_length",500).toDouble());
ui->tracking_method->setCurrentIndex(settings.value("tracking_method",0).toInt());
ui->seed_plan->setCurrentIndex(settings.value("seed_plan",0).toInt());
ui->initial_direction->setCurrentIndex(settings.value("initial_direction",0).toInt());
ui->interpolation->setCurrentIndex(settings.value("interpolation",0).toInt());
ui->tracking_plan->setCurrentIndex(settings.value("tracking_plan",0).toInt());
ui->track_count->setValue(settings.value("track_count",2000).toInt());
ui->thread_count->setCurrentIndex(settings.value("thread_count",0).toInt());
ui->glSagCheck->setChecked(settings.value("SagSlice",1).toBool());
ui->glCorCheck->setChecked(settings.value("CorSlice",1).toBool());
ui->glAxiCheck->setChecked(settings.value("AxiSlice",1).toBool());
ui->RenderingQualityBox->setCurrentIndex(settings.value("RenderingQuality",1).toInt());
ui->view_style->setCurrentIndex((settings.value("view_style",0).toInt()));
ui->RAS->setChecked(settings.value("RAS",0).toBool());
}
{
scene.center();
slice_no_update = false;
copy_target = 0;
}
on_glAxiView_clicked();
if(scene.neurology_convention)
on_glAxiView_clicked();
qApp->installEventFilter(this);
}
bool idCameraDef::getCameraInfo(long time, idVec3 &origin, idVec3 &direction, float *fv)
{
char buff[1024];
if((time - startTime) / 1000 > totalTime)
{
return false;
}
for(int i = 0; i < events.Num(); i++)
{
if(time >= startTime + events[i]->getTime() && !events[i]->getTriggered())
{
events[i]->setTriggered(true);
if(events[i]->getType() == idCameraEvent::EVENT_TARGET)
{
setActiveTargetByName(events[i]->getParam());
getActiveTarget()->start(startTime + events[i]->getTime());
//Com_Printf("Triggered event switch to target: %s\n",events[i]->getParam());
}
else if(events[i]->getType() == idCameraEvent::EVENT_TRIGGER)
{
// empty!
}
else if(events[i]->getType() == idCameraEvent::EVENT_FOV)
{
memset(buff, 0, sizeof(buff));
strcpy(buff, events[i]->getParam());
const char *param1 = strtok(buff, " \t,\0");
const char *param2 = strtok(NULL, " \t,\0");
float len = (param2) ? atof(param2) : 0;
float newfov = (param1) ? atof(param1) : 90;
fov.reset(fov.getFOV(time), newfov, time, len);
//*fv = fov = atof(events[i]->getParam());
}
else if(events[i]->getType() == idCameraEvent::EVENT_FADEIN)
{
float time = atof(events[i]->getParam());
Cbuf_AddText(va("fade 0 0 0 0 %f", time));
Cbuf_Execute();
}
else if(events[i]->getType() == idCameraEvent::EVENT_FADEOUT)
{
float time = atof(events[i]->getParam());
Cbuf_AddText(va("fade 0 0 0 255 %f", time));
Cbuf_Execute();
}
else if(events[i]->getType() == idCameraEvent::EVENT_CAMERA)
{
memset(buff, 0, sizeof(buff));
strcpy(buff, events[i]->getParam());
const char *param1 = strtok(buff, " \t,\0");
const char *param2 = strtok(NULL, " \t,\0");
if(param2)
{
loadCamera(atoi(param1), va("cameras/%s.camera", param2));
startCamera(time);
}
else
{
loadCamera(0, va("cameras/%s.camera", events[i]->getParam()));
startCamera(time);
}
return true;
}
else if(events[i]->getType() == idCameraEvent::EVENT_STOP)
{
return false;
}
}
}
origin = *cameraPosition->getPosition(time);
CHECK_NAN_VEC(origin);
*fv = fov.getFOV(time);
idVec3 temp = origin;
int numTargets = targetPositions.Num();
if(numTargets == 0)
{
// empty!
}
else
{
temp = *getActiveTarget()->getPosition(time);
}
temp -= origin;
temp.Normalize();
direction = temp;
return true;
}
/*
====================
CL_CgameSystemCalls
The cgame module is making a system call
====================
*/
intptr_t CL_CgameSystemCalls( intptr_t *args ) {
switch ( args[0] ) {
case CG_PRINT:
Com_Printf( "%s", (const char*)VMA(1) );
return 0;
case CG_ERROR:
Com_Error( ERR_DROP, "%s", (const char*)VMA(1) );
return 0;
case CG_MILLISECONDS:
return Sys_Milliseconds();
case CG_CVAR_REGISTER:
Cvar_Register( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[4] );
return 0;
case CG_CVAR_UPDATE:
Cvar_Update( VMA( 1 ) );
return 0;
case CG_CVAR_SET:
Cvar_SetSafe( VMA(1), VMA(2) );
return 0;
case CG_CVAR_VARIABLESTRINGBUFFER:
Cvar_VariableStringBuffer( VMA( 1 ), VMA( 2 ), args[3] );
return 0;
case CG_ARGC:
return Cmd_Argc();
case CG_ARGV:
Cmd_ArgvBuffer( args[1], VMA( 2 ), args[3] );
return 0;
case CG_ARGS:
Cmd_ArgsBuffer( VMA( 1 ), args[2] );
return 0;
case CG_FS_FOPENFILE:
return FS_FOpenFileByMode( VMA( 1 ), VMA( 2 ), args[3] );
case CG_FS_READ:
FS_Read( VMA( 1 ), args[2], args[3] );
return 0;
case CG_FS_WRITE:
return FS_Write( VMA( 1 ), args[2], args[3] );
case CG_FS_FCLOSEFILE:
FS_FCloseFile( args[1] );
return 0;
case CG_SENDCONSOLECOMMAND:
Cbuf_AddText( VMA( 1 ) );
return 0;
case CG_ADDCOMMAND:
CL_AddCgameCommand( VMA( 1 ) );
return 0;
case CG_REMOVECOMMAND:
Cmd_RemoveCommandSafe( VMA(1) );
return 0;
case CG_SENDCLIENTCOMMAND:
CL_AddReliableCommand(VMA(1), qfalse);
return 0;
case CG_UPDATESCREEN:
// this is used during lengthy level loading, so pump message loop
// Com_EventLoop(); // FIXME: if a server restarts here, BAD THINGS HAPPEN!
// We can't call Com_EventLoop here, a restart will crash and this _does_ happen
// if there is a map change while we are downloading at pk3.
// ZOID
SCR_UpdateScreen();
return 0;
case CG_CM_LOADMAP:
CL_CM_LoadMap( VMA( 1 ) );
return 0;
case CG_CM_NUMINLINEMODELS:
return CM_NumInlineModels();
case CG_CM_INLINEMODEL:
return CM_InlineModel( args[1] );
case CG_CM_TEMPBOXMODEL:
return CM_TempBoxModel( VMA( 1 ), VMA( 2 ), qfalse );
case CG_CM_TEMPCAPSULEMODEL:
return CM_TempBoxModel( VMA( 1 ), VMA( 2 ), qtrue );
case CG_CM_POINTCONTENTS:
return CM_PointContents( VMA( 1 ), args[2] );
case CG_CM_TRANSFORMEDPOINTCONTENTS:
return CM_TransformedPointContents( VMA( 1 ), args[2], VMA( 3 ), VMA( 4 ) );
case CG_CM_BOXTRACE:
CM_BoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[6], args[7], /*int capsule*/ qfalse );
return 0;
case CG_CM_TRANSFORMEDBOXTRACE:
CM_TransformedBoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[6], args[7], VMA( 8 ), VMA( 9 ), /*int capsule*/ qfalse );
return 0;
case CG_CM_CAPSULETRACE:
CM_BoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[6], args[7], /*int capsule*/ qtrue );
return 0;
case CG_CM_TRANSFORMEDCAPSULETRACE:
CM_TransformedBoxTrace( VMA( 1 ), VMA( 2 ), VMA( 3 ), VMA( 4 ), VMA( 5 ), args[6], args[7], VMA( 8 ), VMA( 9 ), /*int capsule*/ qtrue );
return 0;
case CG_CM_MARKFRAGMENTS:
return re.MarkFragments( args[1], VMA( 2 ), VMA( 3 ), args[4], VMA( 5 ), args[6], VMA( 7 ) );
case CG_S_STARTSOUND:
S_StartSound( VMA( 1 ), args[2], args[3], args[4] );
return 0;
//----(SA) added
case CG_S_STARTSOUNDEX:
S_StartSoundEx( VMA( 1 ), args[2], args[3], args[4], args[5] );
return 0;
//----(SA) end
case CG_S_STARTLOCALSOUND:
S_StartLocalSound( args[1], args[2] );
return 0;
case CG_S_CLEARLOOPINGSOUNDS:
S_ClearLoopingSounds( args[1] ); // (SA) modified so no_pvs sounds can function
return 0;
case CG_S_ADDLOOPINGSOUND:
// FIXME MrE: handling of looping sounds changed
S_AddLoopingSound( args[1], VMA( 2 ), VMA( 3 ), args[4], args[5], args[6] );
return 0;
case CG_S_ADDREALLOOPINGSOUND:
S_AddLoopingSound( args[1], VMA( 2 ), VMA( 3 ), args[4], args[5], args[6] );
//S_AddRealLoopingSound( args[1], VMA(2), VMA(3), args[4], args[5] );
return 0;
case CG_S_STOPLOOPINGSOUND:
// RF, not functional anymore, since we reverted to old looping code
//S_StopLoopingSound( args[1] );
return 0;
case CG_S_UPDATEENTITYPOSITION:
S_UpdateEntityPosition( args[1], VMA( 2 ) );
return 0;
// Ridah, talking animations
case CG_S_GETVOICEAMPLITUDE:
return S_GetVoiceAmplitude( args[1] );
// done.
case CG_S_RESPATIALIZE:
S_Respatialize( args[1], VMA( 2 ), VMA( 3 ), args[4] );
return 0;
case CG_S_REGISTERSOUND:
return S_RegisterSound( VMA( 1 ), qfalse );
case CG_S_STARTBACKGROUNDTRACK:
S_StartBackgroundTrack( VMA( 1 ), VMA( 2 ) );
return 0;
case CG_S_STARTSTREAMINGSOUND:
S_StartStreamingSound( VMA( 1 ), VMA( 2 ), args[3], args[4], args[5] );
return 0;
case CG_R_LOADWORLDMAP:
re.LoadWorld( VMA( 1 ) );
return 0;
case CG_R_REGISTERMODEL:
return re.RegisterModel( VMA( 1 ) );
case CG_R_REGISTERSKIN:
return re.RegisterSkin( VMA( 1 ) );
//----(SA) added
case CG_R_GETSKINMODEL:
return re.GetSkinModel( args[1], VMA( 2 ), VMA( 3 ) );
case CG_R_GETMODELSHADER:
return re.GetShaderFromModel( args[1], args[2], args[3] );
//----(SA) end
case CG_R_REGISTERSHADER:
return re.RegisterShader( VMA( 1 ) );
case CG_R_REGISTERFONT:
re.RegisterFont( VMA( 1 ), args[2], VMA( 3 ) );
return 0;
case CG_R_REGISTERSHADERNOMIP:
return re.RegisterShaderNoMip( VMA( 1 ) );
case CG_R_CLEARSCENE:
re.ClearScene();
return 0;
case CG_R_ADDREFENTITYTOSCENE:
re.AddRefEntityToScene( VMA( 1 ) );
return 0;
case CG_R_ADDPOLYTOSCENE:
re.AddPolyToScene( args[1], args[2], VMA( 3 ) );
return 0;
// Ridah
case CG_R_ADDPOLYSTOSCENE:
re.AddPolysToScene( args[1], args[2], VMA( 3 ), args[4] );
return 0;
// done.
// case CG_R_LIGHTFORPOINT:
// return re.LightForPoint( VMA(1), VMA(2), VMA(3), VMA(4) );
case CG_R_ADDLIGHTTOSCENE:
re.AddLightToScene( VMA( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), args[6] );
return 0;
// case CG_R_ADDADDITIVELIGHTTOSCENE:
// re.AddAdditiveLightToScene( VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
// return 0;
case CG_R_ADDCORONATOSCENE:
re.AddCoronaToScene( VMA( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), args[6], args[7] );
return 0;
case CG_R_SETFOG:
re.SetFog( args[1], args[2], args[3], VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ) );
return 0;
case CG_R_RENDERSCENE:
re.RenderScene( VMA( 1 ) );
return 0;
case CG_R_SETCOLOR:
re.SetColor( VMA( 1 ) );
return 0;
case CG_R_DRAWSTRETCHPIC:
re.DrawStretchPic( VMF( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ), VMF( 8 ), args[9] );
return 0;
case CG_R_DRAWROTATEDPIC:
re.DrawRotatedPic( VMF( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ), VMF( 8 ), args[9], VMF( 10 ) );
return 0;
case CG_R_DRAWSTRETCHPIC_GRADIENT:
re.DrawStretchPicGradient( VMF( 1 ), VMF( 2 ), VMF( 3 ), VMF( 4 ), VMF( 5 ), VMF( 6 ), VMF( 7 ), VMF( 8 ), args[9], VMA( 10 ), args[11] );
return 0;
case CG_R_MODELBOUNDS:
re.ModelBounds( args[1], VMA( 2 ), VMA( 3 ) );
return 0;
case CG_R_LERPTAG:
return re.LerpTag( VMA( 1 ), VMA( 2 ), VMA( 3 ), args[4] );
case CG_GETGLCONFIG:
CL_GetGlconfig( VMA( 1 ) );
return 0;
case CG_GETGAMESTATE:
CL_GetGameState( VMA( 1 ) );
return 0;
case CG_GETCURRENTSNAPSHOTNUMBER:
CL_GetCurrentSnapshotNumber( VMA( 1 ), VMA( 2 ) );
return 0;
case CG_GETSNAPSHOT:
return CL_GetSnapshot( args[1], VMA( 2 ) );
case CG_GETSERVERCOMMAND:
return CL_GetServerCommand( args[1] );
case CG_GETCURRENTCMDNUMBER:
return CL_GetCurrentCmdNumber();
case CG_GETUSERCMD:
return CL_GetUserCmd( args[1], VMA( 2 ) );
case CG_SETUSERCMDVALUE:
CL_SetUserCmdValue( args[1], args[2], VMF( 3 ), args[4], args[5] );
return 0;
case CG_SETCLIENTLERPORIGIN:
CL_SetClientLerpOrigin( VMF( 1 ), VMF( 2 ), VMF( 3 ) );
return 0;
case CG_MEMORY_REMAINING:
return Hunk_MemoryRemaining();
case CG_KEY_ISDOWN:
return Key_IsDown( args[1] );
case CG_KEY_GETCATCHER:
return Key_GetCatcher();
case CG_KEY_SETCATCHER:
// Don't allow the cgame module to close the console
Key_SetCatcher( args[1] | ( Key_GetCatcher( ) & KEYCATCH_CONSOLE ) );
return 0;
case CG_KEY_GETKEY:
return Key_GetKey( VMA( 1 ) );
case CG_MEMSET:
Com_Memset( VMA(1), args[2], args[3] );
return args[1];
case CG_MEMCPY:
Com_Memcpy( VMA(1), VMA(2), args[3] );
return args[1];
case CG_STRNCPY:
strncpy( VMA(1), VMA(2), args[3] );
return args[1];
case CG_SIN:
return FloatAsInt( sin( VMF( 1 ) ) );
case CG_COS:
return FloatAsInt( cos( VMF( 1 ) ) );
case CG_ATAN2:
return FloatAsInt( atan2( VMF( 1 ), VMF( 2 ) ) );
case CG_SQRT:
return FloatAsInt( sqrt( VMF( 1 ) ) );
case CG_FLOOR:
return FloatAsInt( floor( VMF( 1 ) ) );
case CG_CEIL:
return FloatAsInt( ceil( VMF( 1 ) ) );
case CG_ACOS:
return FloatAsInt( Q_acos( VMF( 1 ) ) );
case CG_PC_ADD_GLOBAL_DEFINE:
return botlib_export->PC_AddGlobalDefine( VMA( 1 ) );
case CG_PC_LOAD_SOURCE:
return botlib_export->PC_LoadSourceHandle( VMA( 1 ) );
case CG_PC_FREE_SOURCE:
return botlib_export->PC_FreeSourceHandle( args[1] );
case CG_PC_READ_TOKEN:
return botlib_export->PC_ReadTokenHandle( args[1], VMA( 2 ) );
case CG_PC_SOURCE_FILE_AND_LINE:
return botlib_export->PC_SourceFileAndLine( args[1], VMA( 2 ), VMA( 3 ) );
case CG_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack();
return 0;
case CG_REAL_TIME:
return Com_RealTime( VMA( 1 ) );
case CG_SNAPVECTOR:
Q_SnapVector(VMA(1));
return 0;
case CG_SENDMOVESPEEDSTOGAME:
SV_SendMoveSpeedsToGame( args[1], VMA( 2 ) );
return 0;
case CG_CIN_PLAYCINEMATIC:
return CIN_PlayCinematic( VMA( 1 ), args[2], args[3], args[4], args[5], args[6] );
case CG_CIN_STOPCINEMATIC:
return CIN_StopCinematic( args[1] );
case CG_CIN_RUNCINEMATIC:
return CIN_RunCinematic( args[1] );
case CG_CIN_DRAWCINEMATIC:
CIN_DrawCinematic( args[1] );
return 0;
case CG_CIN_SETEXTENTS:
CIN_SetExtents( args[1], args[2], args[3], args[4], args[5] );
return 0;
case CG_R_REMAP_SHADER:
re.RemapShader( VMA( 1 ), VMA( 2 ), VMA( 3 ) );
return 0;
case CG_TESTPRINTINT:
// Com_Printf( "%s%i\n", (const char*)VMA( 1 ), args[2] );
return 0;
case CG_TESTPRINTFLOAT:
// Com_Printf( "%s%f\n", (const char*)VMA( 1 ), VMF( 2 ) );
return 0;
case CG_LOADCAMERA:
return loadCamera( args[1], VMA( 2 ) );
case CG_STARTCAMERA:
startCamera( args[1], args[2] );
return 0;
case CG_GETCAMERAINFO:
return getCameraInfo( args[1], args[2], VMA( 3 ), VMA( 4 ), VMA( 5 ) );
case CG_GET_ENTITY_TOKEN:
return re.GetEntityToken( VMA( 1 ), args[2] );
case CG_INGAME_POPUP:
if ( clc.state == CA_ACTIVE && !clc.demoplaying ) {
// NERVE - SMF
if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "UIMENU_WM_PICKTEAM" ) ) {
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_WM_PICKTEAM );
} else if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "UIMENU_WM_PICKPLAYER" ) ) {
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_WM_PICKPLAYER );
} else if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "UIMENU_WM_QUICKMESSAGE" ) ) {
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_WM_QUICKMESSAGE );
} else if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "UIMENU_WM_QUICKMESSAGEALT" ) ) {
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_WM_QUICKMESSAGEALT );
} else if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "UIMENU_WM_LIMBO" ) ) {
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_WM_LIMBO );
} else if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "UIMENU_WM_AUTOUPDATE" ) ) {
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_WM_AUTOUPDATE );
}
// -NERVE - SMF
else if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "hbook1" ) ) { //----(SA)
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_BOOK1 );
} else if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "hbook2" ) ) { //----(SA)
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_BOOK2 );
} else if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "hbook3" ) ) { //----(SA)
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_BOOK3 );
} else {
VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_CLIPBOARD );
}
}
return 0;
// NERVE - SMF
case CG_INGAME_CLOSEPOPUP:
// if popup menu is up, then close it
if ( VMA( 1 ) && !Q_stricmp( VMA( 1 ), "UIMENU_WM_LIMBO" ) ) {
if ( VM_Call( uivm, UI_GET_ACTIVE_MENU ) == UIMENU_WM_LIMBO ) {
VM_Call( uivm, UI_KEY_EVENT, K_ESCAPE, qtrue );
VM_Call( uivm, UI_KEY_EVENT, K_ESCAPE, qtrue );
}
}
return 0;
case CG_LIMBOCHAT:
if ( VMA( 1 ) ) {
CL_AddToLimboChat( VMA( 1 ) );
}
return 0;
case CG_KEY_GETBINDINGBUF:
Key_GetBindingBuf( args[1], VMA( 2 ), args[3] );
return 0;
case CG_KEY_SETBINDING:
Key_SetBinding( args[1], VMA( 2 ) );
return 0;
case CG_KEY_KEYNUMTOSTRINGBUF:
Key_KeynumToStringBuf( args[1], VMA( 2 ), args[3] );
return 0;
case CG_TRANSLATE_STRING:
CL_TranslateString( VMA( 1 ), VMA( 2 ) );
return 0;
// - NERVE - SMF
default:
Com_Error( ERR_DROP, "Bad cgame system trap: %ld", (long int) args[0] );
}
return 0;
}
Camera loadCamera(int idFrame)
{
std::stringstream fileName;
fileName << ConfigManager::scene_output_directory << FILE_SEPARATOR_CHAR << CAMERA_FILE_NAME << idFrame << SERIAL_EXTENSION_FILENAME;
return loadCamera(fileName.str().c_str());
}
bool idCameraDef::getCameraInfo(long time, idVec3 &origin, idVec3 &direction, float *fv) {
char buff[1024];
if ((time - startTime) / 1000 > totalTime) {
return false;
}
for (int i = 0; i < events.Num(); i++) {
if (time >= startTime + events[i]->getTime() && !events[i]->getTriggered()) {
events[i]->setTriggered(true);
if (events[i]->getType() == idCameraEvent::EVENT_TARGET) {
setActiveTargetByName(events[i]->getParam());
getActiveTarget()->start(startTime + events[i]->getTime());
//Com_Printf("Triggered event switch to target: %s\n",events[i]->getParam());
} else if (events[i]->getType() == idCameraEvent::EVENT_TRIGGER) {
//idEntity *ent = NULL;
//ent = level.FindTarget( ent, events[i]->getParam());
//if (ent) {
// ent->signal( SIG_TRIGGER );
// ent->ProcessEvent( &EV_Activate, world );
//}
} else if (events[i]->getType() == idCameraEvent::EVENT_FOV) {
memset(buff, 0, sizeof(buff));
strcpy(buff, events[i]->getParam());
const char *param1 = strtok(buff, " \t,\0");
const char *param2 = strtok(NULL, " \t,\0");
float len = (param2) ? atof(param2) : 0;
float newfov = (param1) ? atof(param1) : 90;
fov.reset(fov.getFOV(time), newfov, time, len);
//*fv = fov = atof(events[i]->getParam());
} else if (events[i]->getType() == idCameraEvent::EVENT_FADEIN) {
float time = atof(events[i]->getParam());
Cbuf_AddText(va("fade 0 0 0 0 %f", time));
Cbuf_Execute();
} else if (events[i]->getType() == idCameraEvent::EVENT_FADEOUT) {
float time = atof(events[i]->getParam());
Cbuf_AddText(va("fade 0 0 0 255 %f", time));
Cbuf_Execute();
} else if (events[i]->getType() == idCameraEvent::EVENT_CAMERA) {
memset(buff, 0, sizeof(buff));
strcpy(buff, events[i]->getParam());
const char *param1 = strtok(buff, " \t,\0");
const char *param2 = strtok(NULL, " \t,\0");
if(param2) {
loadCamera(atoi(param1), va("cameras/%s.camera", param2));
startCamera(time);
} else {
loadCamera(0, va("cameras/%s.camera", events[i]->getParam()));
startCamera(time);
}
return true;
} else if (events[i]->getType() == idCameraEvent::EVENT_STOP) {
return false;
}
}
}
origin = *cameraPosition->getPosition(time);
*fv = fov.getFOV(time);
idVec3 temp = origin;
int numTargets = targetPositions.Num();
if (numTargets == 0) {
/*
// follow the path
if (cameraSpline.getActiveSegment() < count - 1) {
temp = *cameraSpline.splinePoints[cameraSpline.getActiveSegment()+1];
if (temp == origin) {
int index = cameraSpline.getActiveSegment() + 2;
while (temp == origin && index < count - 1) {
temp = *cameraSpline.splinePoints[index++];
}
}
}
*/
} else {
if( getActiveTarget()->numPoints() > 0 ) {
temp = *getActiveTarget()->getPosition(time);
}
}
temp -= origin;
temp.Normalize();
direction = temp;
return true;
}
//Create a CGLWin widget
CGLWin::CGLWin(void):
QMainWindow( 0, "View3D", WDestructiveClose),
m_pListViews(NULL)
{
int i;
// Data members;
CGLDrawParms tDraw;
_drawParms = tDraw;
m_nTimeDelay = 0;
for (i=0; i<VIEW3D_MAX_OBJ_COUNT; i++) _pCia3dObjs[i] = NULL;
// setup printer
m_pPrinter = new QPrinter;
// GUI members, create a toolbar;
m_pToolBar = _createToolBar();
// populate a menu with all actions
m_pMenuBar = menuBar();
assert(m_pMenuBar!=NULL);
//====================File options ==========================
{
QPopupMenu * file = new QPopupMenu( this );
menuBar()->insertItem( "&File ", file );
_fileNewAction->addTo( file );
_fileOpenAction->addTo( file );
_fileSaveAction->addTo( file );
file->insertSeparator();
file->insertItem( "Open Background", this, SLOT(openBackgroundImage()), NULL);
file->insertItem( "Load Camera", this, SLOT(loadCamera()), NULL);
file->insertItem( "Save Camera", this, SLOT(saveCamera()), NULL);
file->insertSeparator(); //===========================
file->insertItem( "Export Povray", this, SLOT(exportPovray()), NULL);
file->insertItem( "Export STL", this, SLOT(saveSTLFile()), NULL);
file->insertItem( "Export TXT", this, SLOT(saveTXTFile()), NULL);
file->insertItem( "Export EPS", this, SLOT(exportEps()), NULL);
file->insertSeparator(); //===========================
_filePrintAction->addTo( file );
file->insertSeparator(); //===========================
file->insertItem( "E&xit", qApp, SLOT(closeAllWindows()), NULL);
}
//================ Tools Options ================================
{
QPopupMenu * pMenuTools = new QPopupMenu( this );
menuBar()->insertItem( "&Tools", pMenuTools );
pMenuTools->insertItem( "Show Entire Scene", this, SLOT(show_entirescene()));
pMenuTools->insertItem( "Dupe Current Object", this, SLOT(dupe_currentobj()));
pMenuTools->insertItem( "Dupe Current Object N", this, SLOT(dupe_currentobjN()));
{// Animation options
pMenuTools->insertSeparator(); //=======================
QPopupMenu * pAnimOption = new QPopupMenu( this );
pMenuTools->insertItem( "&Prepare Animation", pAnimOption);
pAnimOption->insertItem( "Setup", this, SLOT(create_animation()));
QAction* startAction = new QAction(QPixmap(play_xpm), "&Start Animation", Qt::Key_F10, this);
connect(startAction, SIGNAL(activated()), this, SLOT(startAnimation()));
startAction->addTo( pAnimOption );
pAnimOption->insertItem( "Stop Animation", this, SLOT(stopAnimation()), Qt::Key_F11);
pAnimOption->insertItem( "Change Delay Time", this, SLOT(editDelayTime()));
{//toggle fast draw mode
m_pActRepeatPlay = new QAction("Repeat", CTRL+Key_T, this);
connect(m_pActRepeatPlay, SIGNAL(activated()), this, SLOT(toggleRepeatPlay()));
m_pActRepeatPlay->setToggleAction(true);
m_pActRepeatPlay->setOn(false);
m_pActRepeatPlay->addTo( pAnimOption );
}
}
pMenuTools->insertSeparator(); //=======================
{// Stereo options
QPopupMenu * pStereoOption = new QPopupMenu( this );
pMenuTools->insertItem( "&Stereo", pStereoOption);
QAction* m_pActToggleStereo = new QAction("Stereo Mode", Qt::Key_F12, this);
connect(m_pActToggleStereo, SIGNAL(activated()), this, SLOT(toggleStereo()));
m_pActToggleStereo->setToggleAction(true);
m_pActToggleStereo->setOn(false);
m_pActToggleStereo->addTo( pStereoOption );
pStereoOption->insertItem( "Increase Eye Distance", this, SLOT(incEyeDistance()), Qt::Key_Plus);
pStereoOption->insertItem( "Decrease Eye Distance", this, SLOT(decEyeDistance()), Qt::Key_Minus);
}
//pMenuTools->insertItem( "Rotation Axis", this, SLOT(InputRotationAxis()), NULL);
//pMenuTools->insertItem( "Mirror Plane", this, SLOT(InputMirrorPlane()), NULL);
//pMenuTools->insertSeparator();
//pMenuTools->insertItem( "Vector Hidden Line Removal", this, SLOT(hidden_line()), CTRL+Key_H);
//pMenuTools->insertSeparator(); //=======================
pMenuTools->insertSeparator(); //=======================
pMenuTools->insertItem( "Set Mirror Plane", this, SLOT(InputMirrorPlane()));
pMenuTools->insertItem( "Set Rotation Axis", this, SLOT(InputRotationAxis()));
}
//================ Rendering options ================================
{
QPopupMenu * pMenuOption = new QPopupMenu( this );
menuBar()->insertItem( "&Options", pMenuOption );
pMenuOption->insertItem( "Global Setting", this, SLOT(OptionGlobalSetting()));
pMenuOption->insertItem( "Surface Rendering", this, SLOT(OptionRendering()));
pMenuOption->insertItem( "Volume Rendering", this, SLOT(OptionVolumeRendering()));
pMenuOption->insertSeparator(); //=======================
{
QPopupMenu * pPickOption = new QPopupMenu( this );
pMenuOption->insertItem( "&Picking Types", pPickOption);
pPickOption->insertItem( "Pick an Object", this, SLOT(set_obj_picking()));
pPickOption->insertItem( "Pick a Polygon", this, SLOT(set_face_picking()));
pPickOption->insertItem( "Pick a Line", this, SLOT(set_line_picking()));
}
QAction* act_mirroring = new QAction("Mirroring", 0, this);
connect( act_mirroring, SIGNAL(activated()), this, SLOT(OptionMirroring()));
act_mirroring->setToggleAction(true);
act_mirroring->setOn(false);
act_mirroring->addTo( pMenuOption );
m_pMirroringAction = act_mirroring;
QPopupMenu * pRotOption = new QPopupMenu( this );
pMenuOption->insertItem( "&Rotation Types", pRotOption);
QAction* act_rot0obj = new QAction("Rotate 90 Degree", 0, this);
connect( act_rot0obj, SIGNAL(activated()), this, SLOT(OptionRotate90()));
act_rot0obj->addTo( pRotOption );
QAction* act_rot1obj = new QAction("Rotate 180 Degree", 0, this);
connect( act_rot1obj, SIGNAL(activated()), this, SLOT(OptionRotate180()));
act_rot1obj->addTo( pRotOption );
QAction* act_rot2obj = new QAction("Rotate 270 Degree", 0, this);
connect( act_rot2obj, SIGNAL(activated()), this, SLOT(OptionRotate270()));
act_rot2obj->addTo( pRotOption );
m_pRot90Action = act_rot0obj;
m_pRot180Action = act_rot1obj;
m_pRot270Action = act_rot2obj;
m_pRot90Action->setToggleAction(true);
m_pRot90Action->setOn(false);
m_pRot180Action->setToggleAction(true);
m_pRot180Action->setOn(false);
m_pRot270Action->setToggleAction(true);
m_pRot270Action->setOn(false);
//show background image buttion
QAction* act_showbgimg = new QAction("Background Image", 0, this);
connect( act_showbgimg, SIGNAL(activated()), this, SLOT(ShowBackgroundImage()));
act_showbgimg->setToggleAction(true);
act_showbgimg->setOn(false);
act_showbgimg->addTo( pMenuOption );
m_pBGImageAction = act_showbgimg;
//show floor plane buttion
QAction* act_showfloor = new QAction(QString::fromLocal8Bit("Floor Plane"), 0, this);
connect( act_showfloor, SIGNAL(activated()), this, SLOT(ShowFloor()));
act_showfloor->setToggleAction(true);
act_showfloor->setOn(false);
act_showfloor->addTo( pMenuOption );
m_pFloorAction = act_showfloor;
{//Toggle fast draw mode
m_pActFastDraw = new QAction("Fast Drawing", 0, this);
connect(m_pActFastDraw, SIGNAL(activated()), this, SLOT(toggleFastDraw()));
m_pActFastDraw->setToggleAction(true);
m_pActFastDraw->setOn(false);
m_pActFastDraw->addTo( pMenuOption );
}
}
//========change opengl window size ==========================
{
QPopupMenu * pMenuGLWinsize = new QPopupMenu( this );
menuBar()->insertItem( "&Window", pMenuGLWinsize );
pMenuGLWinsize->insertItem( "320x200", this, SLOT(setGLWinSize320x200()), CTRL+Qt::Key_3);
pMenuGLWinsize->insertItem( "400x400", this, SLOT(setGLWinSize400x400()), CTRL+Qt::Key_4);
pMenuGLWinsize->insertItem( "500x400", this, SLOT(setGLWinSize500x400()), CTRL+Qt::Key_5);
pMenuGLWinsize->insertItem( "500x500", this, SLOT(setGLWinSize500x500()), CTRL+Qt::Key_2 );
pMenuGLWinsize->insertItem( "640x480", this, SLOT(setGLWinSize640x480()), CTRL+Qt::Key_6);
pMenuGLWinsize->insertItem( "800x600", this, SLOT(setGLWinSize800x600()), CTRL+Qt::Key_8);
pMenuGLWinsize->insertItem( "1024x768", this, SLOT(setGLWinSize1024x768()), CTRL+Qt::Key_1);
pMenuGLWinsize->insertSeparator();
pMenuGLWinsize->insertItem( "Swap Width/Height", this, SLOT(swapWidthHeight()), CTRL+Key_W);
pMenuGLWinsize->insertItem( "Input Width/Height", this, SLOT(inputWidthHeight()), CTRL+Key_I);
}
/*
{
QPopupMenu * pPopMenu = new QPopupMenu( this );
menuBar()->insertItem( "&My Research", pPopMenu );
pPopMenu->insertItem( "Bar Recons", this, SLOT(detail_recon_bar()));
pPopMenu->insertItem( "Vase Recons", this, SLOT(detail_recon_vase()));
pPopMenu->insertSeparator();
pPopMenu->insertItem( "Letter Size Plate", this, SLOT(detail_recon_a4plate()));
pPopMenu->insertSeparator();
pPopMenu->insertItem( "Detail Recon Dialog", this, SLOT(detail_recon_anyobj()));
}
*/
//================ end Rendering options ================================
QGLFormat format;
format.setStereo( true );
m_pGLUIWin = new Viewer(format, this, "Viewer3D");
assert(m_pGLUIWin!=NULL);
statusBar()->setFixedHeight( fontMetrics().height() + 6 );
statusBar()->message( "Viewer ready", 3000 );
setCentralWidget(m_pGLUIWin);
m_pGLUIWin->setDrawingData(&_drawParms);
m_pGLUIWin->m_SceneGraph.hookObject(m_pGLUIWin);
m_pGLUIWin->m_SceneGraph.hookGLWindow(m_pGLUIWin);
//================ dock window==================
QString appDir;
m_pFemBar=_createDockWidgetBar(this, appDir);
}
