void* init( const void* params){ xen::ModuleApiGraphics* mod_ren = xen::getModuleApi<xen::ModuleApiGraphics>(); xen::ModuleApiWindow* mod_win = xen::getModuleApi<xen::ModuleApiWindow>(); XenAssert(mod_ren != nullptr, "Graphics module must be loaded before cornell-box"); XenAssert(mod_win != nullptr, "Window module must be loaded before cornell-box"); state = (State*)xen::kernelAlloc(sizeof(State) + xen::kilobytes(1)); state->arena.start = xen::ptrGetAdvanced(state, sizeof(State)); state->arena.end = xen::ptrGetAdvanced(state->arena.start, xen::kilobytes(1)); state->arena.next_byte = state->arena.start; state->window = mod_win->createWindow({600, 600}, "cornell-box"); state->window_target = mod_ren->createWindowRenderTarget(state->window); initCamera(); initSceneLights(); initMeshes(mod_ren); initRenderCommands(mod_ren, state->arena); return state; }
//---------------------------------------------------------- // Begin main functions int GzNewRender(GzRender **render, GzDisplay *display) { /* - malloc a renderer struct - setup Xsp and anything only done once - save the pointer to display - init default camera */ //init a renderer struct if(render == NULL || display == NULL){ errorCall("GzNewRender" , "render == NULL or display == NULL"); return GZ_FAILURE; } *render = (GzRender*)malloc(sizeof(GzRender)); (*render)->display = display; //init default camera initCamera((*render) -> camera); return GZ_SUCCESS; }
void CameraSensor::threadMain() { if (cam == 0) return; threadInit(); robottime_t lastFrameTime = 0; // loop until we quit while (isRunning()) { // make sure we are still connected to a camera if (false == cam->isOpen()) { WARNING("Camera not active, trying to re-initiate"); if (false == initCamera()) { ERROR("No camera ..."); delay(250*milliseconds); continue; } } // update frame cs.enter(); bool imageCaptured = cam->capture(); cs.leave(); if (imageCaptured) { // notify any other objects that want to know about this new image for processing services.getEvents().trigger(EVT_IMAGE_CAPTURED, image); lastFrameTime = getCurrentTime(); // save image if required handleImageSaving(); } else if (lastFrameTime + 3000*milliseconds < getCurrentTime()) { ERROR("Did not receive image data for several seconds!"); // TODO: trigger watchdog in competition mode } } }
/*------------------------------------------------------------------------ * OpenGL main routine */ int main(int argc, char *argv[]) { int i; for (i = 1; i < argc; i++) { if (strcmp(argv[i], "-f") == 0) { if ( i+1 >= argc ) { printf("-f: missing data file.\n"); return 1; } datafile = GL_TRUE; break; } else { printf("Warrning: unknown parameter: %s\n", argv[i]); } } if ( datafile ) { if ( 0 != tubes.loadGeometry( argv[argc-1] ) ) { return 1; } tubes.getExtent( Xminmax, Yminmax, Zminmax ); } glutInit (&argc, argv); glutInitWindowPosition ( 0, 0 ); glutInitWindowSize ( 1920, 1080 ); glutInitDisplayMode ( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_STEREO ); glutCreateWindow ("brain stereoscopic rendering for visweek"); initCamera(); glutReshapeFunc(reshape); glutDisplayFunc(draw); glutKeyboardFunc(keyFunc); glutMainLoop(); return 0; }
int main() { srand(time(NULL)); if(!initCamera()) { fprintf(stderr, "Camera initialization failed.\n"); return EXIT_FAILURE; } pthread_t cameraThread; if(pthread_create(&cameraThread, NULL, cameraLoop, NULL)) { fprintf(stderr, "pthread_create failed.\n"); return EXIT_FAILURE; } usleep(30); /* We wait two frames for the camera to initialize itself. */ for(int i = 0; i < 2; i++) { pthread_mutex_lock(&kinectMutex); while(!colorUpdate || !depthUpdate) { pthread_cond_wait(&kinectSignal, &kinectMutex); } pthread_mutex_unlock(&kinectMutex); swapColorBuffers(); swapDepthBuffers(); } createModel(); pthread_t runThread; if(pthread_create(&runThread, NULL, runLoop, NULL)) { fprintf(stderr, "pthread_create failed.\n"); return EXIT_FAILURE; } renderLoop(); return EXIT_SUCCESS; }
void actionButtonsMenu(){ if(g_keys[' ']){ initCamera(); if(itemMenuSelect<5){ std::ostringstream oss; oss << itemMenuSelect; std::string result = oss.str(); if(result == "4"){//mode hardcore sélectionné loadSave("0"); initVarLevel(); loadPhysicsHardcore(); } else{//un des trois slots de sauvegarde loadSave(result); itemMenuDroiteSelect = 1; initVarLevel(); loadPhysicsNormal(); } } else if(itemMenuSelect == 5){ bestScores = true; } else if(itemMenuSelect == 6){ commandes = true; } else if(itemMenuSelect == 7){ credits = true; } menu = false; } else if(g_keys['z'] && itemMenuSelect >1){ itemMenuSelect -=1; Sleep(200); }else if(g_keys['s'] && itemMenuSelect <7){ itemMenuSelect +=1; Sleep(200); } }
bool photoController::checkCameraDetection() { START_CHRONOMETER(); CameraList *list; gp_list_new (&list); int ret = auto_detect_action(list, context); DEBUG_PRINTF(V_MESSAGE, "gp_camera_autodetect return %d wanted %d\n", ret, GP_OK); if(ret >= GP_OK) { int cameraCount = gp_list_count(list); DEBUG_PRINTF(V_MESSAGE, "Camera count: %d\n", cameraCount); if(cameraCount > 0) { DEBUG_PRINTF(V_MESSAGE, "Got a camera\n"); camera_detected = true; if(!camera && !initCamera()) { camera = NULL; } } } else { if(camera) { DEBUG_PRINTF(V_MESSAGE, "Exit camera\n"); gp_camera_exit(camera, context); camera = NULL; } camera_detected = false; DEBUG_PRINTF(V_MESSAGE, "Error while getting camera list\n"); } gp_list_unref (list); STOP_CHRONOMETER("Camera detection"); return camera_detected; }
void GLWidget::initializeGL() { ResourceLoader::initializeGlew(); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glClearColor(0.5f, 0.5f, 0.5f, 0.0f); // Initialize shader programs. for (auto program = m_programs.begin(); program != m_programs.end(); ++program) (*program)->create(); // Initialize textures. m_noiseTexture->createColorTexture(":/images/noise128.jpg", GL_LINEAR, GL_LINEAR); // Initialize framebuffers. int shadowMapRes = 2048; glm::vec2 finalSize = glm::vec2(2 * width(), 2 * height()); for (auto framebuffer = m_framebuffers.begin(); framebuffer != m_framebuffers.end(); ++framebuffer) (*framebuffer)->create(); m_hairShadowFramebuffer->generateDepthTexture(shadowMapRes, shadowMapRes, GL_NEAREST, GL_NEAREST); m_meshShadowFramebuffer->generateDepthTexture(shadowMapRes, shadowMapRes, GL_LINEAR, GL_LINEAR); m_opacityMapFramebuffer->generateColorTexture(shadowMapRes, shadowMapRes, GL_NEAREST, GL_NEAREST); m_opacityMapFramebuffer->generateDepthBuffer(shadowMapRes, shadowMapRes); m_finalFramebuffer->generateColorTexture(finalSize.x, finalSize.y, GL_LINEAR, GL_LINEAR); m_finalFramebuffer->generateDepthBuffer(finalSize.x, finalSize.y); m_depthPeel0Framebuffer->generateColorTexture(finalSize.x, finalSize.y, GL_LINEAR, GL_LINEAR); m_depthPeel0Framebuffer->generateDepthTexture(finalSize.x, finalSize.y, GL_NEAREST, GL_NEAREST); m_depthPeel1Framebuffer->generateColorTexture(finalSize.x, finalSize.y, GL_LINEAR, GL_LINEAR); m_depthPeel1Framebuffer->generateDepthBuffer(finalSize.x, finalSize.y); // Initialize simulation. initSimulation(); initCamera(); ErrorChecker::printGLErrors("end of initializeGL"); }
void init(int w, int h) { /* OpenGL setup */ glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); glClearColor(0.0, 0.0, 0.0, 0.0); /* low-level graphics setup */ initCanvas(w,h); /* raytracer setup */ initCamera(w,h); initScene(); initLight(); printf("DEPTH = %d. Computing the scene... ",depth); list = glGenLists(1); glNewList(list, GL_COMPILE); drawScene(); flushCanvas(); glEndList(); printf("Done\n"); }
void nextCameraType(void) { int i; int current_cam_type = getSettingi("camType"); int new_cam_type = (current_cam_type + 1) % CAM_COUNT; setSettingi("camType", new_cam_type); /* update the cached setting */ gSettingsCache.camType = new_cam_type; for (i = 0; i < game->players; i++) { if (game->player[i].ai->active == AI_HUMAN) { initCamera(&gPlayerVisuals[i].camera, game->player[i].data, new_cam_type); } } if (getSettingi("debug_output")) { switch (new_cam_type) { case 0 : displayMessage(TO_CONSOLE, "[camera] Circling Camera"); break; case 1 : displayMessage(TO_CONSOLE, "[camera] Behind Camera"); break; case 2 : displayMessage(TO_CONSOLE, "[camera] Cockpit Camera"); break; case 3 : displayMessage(TO_CONSOLE, "[camera] Mouse Camera"); break; case 4 : displayMessage(TO_CONSOLE, "[camera] Offset Camera"); break; } } }
/*! Set the camera format and video mode. This method has to be called before open(). \param format : Camera video format. \param mode : Camera video mode. See the following table for the correspondances between the input format and mode and the resulting video color coding. <TABLE BORDER="1"> <TR><TH> Format </TH><TH> Mode </TH><TH> (H) x (W) </TH><TH> Color </TH></TR> <TR><TD> 0 </TD><TD> 0 </TD><TD> 160 x 120 </TD><TD> YUV444 </TD></TR> <TR><TD> 0 </TD><TD> 1 </TD><TD> 320 x 240 </TD><TD> YUV422 </TD></TR> <TR><TD> 0 </TD><TD> 2 </TD><TD> 640 x 480 </TD><TD> YUV411 </TD></TR> <TR><TD> 0 </TD><TD> 3 </TD><TD> 640 x 480 </TD><TD> YUV422 </TD></TR> <TR><TD> 0 </TD><TD> 4 </TD><TD> 640 x 480 </TD><TD> RGB8 </TD></TR> <TR><TD> 0 </TD><TD> 5 </TD><TD> 640 x 480 </TD><TD> MONO8 </TD></TR> <TR><TD> 0 </TD><TD> 6 </TD><TD> 640 x 480 </TD><TD> MONO16 </TD></TR> <TR><TD> 1 </TD><TD> 0 </TD><TD> 800 x 600 </TD><TD> YUV422 </TD></TR> <TR><TD> 1 </TD><TD> 1 </TD><TD> 800 x 600 </TD><TD> RGB8 </TD></TR> <TR><TD> 1 </TD><TD> 2 </TD><TD> 800 x 600 </TD><TD> MONO8 </TD></TR> <TR><TD> 1 </TD><TD> 3 </TD><TD>1024 x 768 </TD><TD> YUV422 </TD></TR> <TR><TD> 1 </TD><TD> 4 </TD><TD>1024 x 768 </TD><TD> RGB8 </TD></TR> <TR><TD> 1 </TD><TD> 5 </TD><TD>1024 x 768 </TD><TD> MONO8 </TD></TR> <TR><TD> 1 </TD><TD> 6 </TD><TD> 800 x 600 </TD><TD> MONO16 </TD></TR> <TR><TD> 1 </TD><TD> 7 </TD><TD>1024 x 768 </TD><TD> MONO16 </TD></TR> <TR><TD> 2 </TD><TD> 0 </TD><TD>1280 x 960 </TD><TD> YUV422 </TD></TR> <TR><TD> 2 </TD><TD> 1 </TD><TD>1280 x 960 </TD><TD> RGB8 </TD></TR> <TR><TD> 2 </TD><TD> 2 </TD><TD>1280 x 960 </TD><TD> MONO8 </TD></TR> <TR><TD> 2 </TD><TD> 3 </TD><TD>1600 x 1200</TD><TD> YUV422 </TD></TR> <TR><TD> 2 </TD><TD> 4 </TD><TD>1600 x 1200</TD><TD> RGB8 </TD></TR> <TR><TD> 2 </TD><TD> 5 </TD><TD>1600 x 1200</TD><TD> MONO8 </TD></TR> <TR><TD> 2 </TD><TD> 6 </TD><TD>1280 x 960 </TD><TD> MONO16 </TD></TR> <TR><TD> 2 </TD><TD> 7 </TD><TD>1600 x 1200</TD><TD> MONO16 </TD></TR> </TABLE> */ void vp1394CMUGrabber::setVideoMode( unsigned long format, unsigned long mode ) { initCamera(); _format = format ; _mode = mode ; // Set format and mode if ((_format != -1) && (_mode != -1)) { if (!camera->HasVideoMode(_format, _mode)) { close(); vpERROR_TRACE("vp1394CMUGrabber error: The image format is not supported by the IEEE 1394 camera number %i",index); throw (vpFrameGrabberException(vpFrameGrabberException::settingError,"Video mode not supported") ); } if (camera->IsAcquiring()) { // stop acquisition if (camera->StopImageAcquisition() != CAM_SUCCESS) { close(); vpERROR_TRACE("vp1394CMUGrabber error: Can't stop image acquisition from IEEE 1394 camera number %i",index); throw (vpFrameGrabberException(vpFrameGrabberException::otherError, "Error while stopping image acquisition") ); } } if (camera->SetVideoFormat(_format) != CAM_SUCCESS) { close(); vpERROR_TRACE("vp1394CMUGrabber error: Can't set video format of IEEE 1394 camera number %i",index); throw (vpFrameGrabberException(vpFrameGrabberException::settingError,"Can't set video format") ); } if (camera->SetVideoMode(_mode) != CAM_SUCCESS) { close(); vpERROR_TRACE("vp1394CMUGrabber error: Can't set video mode of IEEE 1394 camera number %i",index); throw (vpFrameGrabberException(vpFrameGrabberException::settingError,"Can't set video mode") ); } // start acquisition if (camera->StartImageAcquisition() != CAM_SUCCESS) { close(); vpERROR_TRACE("vp1394CMUGrabber error: Can't start image acquisition from IEEE 1394 camera number %i",index); throw (vpFrameGrabberException(vpFrameGrabberException::otherError, "Error while starting image acquisition") ); } // Update Image dimension unsigned long w, h; camera->GetVideoFrameDimensions(&w, &h); this->width = w; this->height = h; // Update the color coding _color = getVideoColorCoding(); } }
/*! Enable auto shutter. \sa setShutter() */ void vp1394CMUGrabber::setAutoShutter() { initCamera(); camera->GetCameraControl(FEATURE_SHUTTER)->SetAutoMode(true); }
/*! Enable auto gain. \sa setGain() */ void vp1394CMUGrabber::setAutoGain() { initCamera(); camera->GetCameraControl(FEATURE_GAIN)->SetAutoMode(true); }
int main() { int width; char* bayer[] = {"RG","BG","GR","GB"}; char* controls[MAX_CONTROL] = {"Exposure", "Gain", "Gamma", "WB_R", "WB_B", "Brightness", "USB Traffic"}; int height; int i; char c; bool bresult; int time1,time2; int count=0; char buf[128]={0}; int CamNum=0; ///long exposure, exp_min, exp_max, exp_step, exp_flag, exp_default; //long gain, gain_min, gain_max,gain_step, gain_flag, gain_default; IplImage *pRgb; int numDevices = getNumberOfConnectedCameras(); if(numDevices <= 0) { printf("no camera connected, press any key to exit\n"); getchar(); return -1; } else printf("attached cameras:\n"); for(i = 0; i < numDevices; i++) printf("%d %s\n",i, getCameraModel(i)); printf("\nselect one to privew\n"); scanf("%d", &CamNum); bresult = openCamera(CamNum); if(!bresult) { printf("OpenCamera error,are you root?,press any key to exit\n"); getchar(); return -1; } printf("%s information\n",getCameraModel(CamNum)); int iMaxWidth, iMaxHeight; iMaxWidth = getMaxWidth(); iMaxHeight = getMaxHeight(); printf("resolution:%dX%d\n", iMaxWidth, iMaxHeight); if(isColorCam()) printf("Color Camera: bayer pattern:%s\n",bayer[getColorBayer()]); else printf("Mono camera\n"); for( i = 0; i < MAX_CONTROL; i++) { if(isAvailable((Control_TYPE)i)) printf("%s support:Yes\n", controls[i]); else printf("%s support:No\n", controls[i]); } printf("\nPlease input the <width height bin image_type> with one space, ie. 640 480 2 0. use max resolution if input is 0. Press ESC when video window is focused to quit capture\n"); int bin = 1, Image_type; scanf("%d %d %d %d", &width, &height, &bin, &Image_type); if(width == 0 || height == 0) { width = iMaxWidth; height = iMaxHeight; } initCamera(); //this must be called before camera operation. and it only need init once printf("sensor temperature:%02f\n", getSensorTemp()); // IMG_TYPE image_type; while(!setImageFormat(width, height, bin, (IMG_TYPE)Image_type))//IMG_RAW8 { printf("Set format error, please check the width and height\n ASI120's data size(width*height) must be integer multiple of 1024\n"); printf("Please input the width and height again£¬ie. 640 480\n"); scanf("%d %d %d %d", &width, &height, &bin, &Image_type); } printf("\nset image format %d %d %d %d success, start privew, press ESC to stop \n", width, height, bin, Image_type); if(Image_type == IMG_RAW16) pRgb=cvCreateImage(cvSize(getWidth(),getHeight()), IPL_DEPTH_16U, 1); else if(Image_type == IMG_RGB24) pRgb=cvCreateImage(cvSize(getWidth(),getHeight()), IPL_DEPTH_8U, 3); else pRgb=cvCreateImage(cvSize(getWidth(),getHeight()), IPL_DEPTH_8U, 1); setValue(CONTROL_EXPOSURE, 100*1000, false); //ms//auto setValue(CONTROL_GAIN,getMin(CONTROL_GAIN), false); setValue(CONTROL_BANDWIDTHOVERLOAD, getMin(CONTROL_BANDWIDTHOVERLOAD), false); //low transfer speed setValue(CONTROL_WB_B, 90, false); setValue(CONTROL_WB_R, 48, false); setAutoPara(getMax(CONTROL_GAIN)/2,10,150); //max auto gain and exposure and target brightness // EnableDarkSubtract("dark.bmp"); //dark subtract will be disabled when exposure set auto and exposure below 500ms startCapture(); //start privew bDisplay = 1; #ifdef _LIN pthread_t thread_display; pthread_create(&thread_display, NULL, Display, (void*)pRgb); #elif defined _WINDOWS HANDLE thread_setgainexp; thread_setgainexp = (HANDLE)_beginthread(Display, NULL, (void*)pRgb); #endif time1 = GetTickCount(); int iStrLen = 0, iTextX = 40, iTextY = 60; void* retval; // int time0, iWaitMs = -1; // bool bGetImg; while(bMain) { // time0 = GetTickCount(); getImageData((unsigned char*)pRgb->imageData, pRgb->imageSize, 200); // bGetImg = getImageData((unsigned char*)pRgb->imageData, pRgb->imageSize, iWaitMs); time2 = GetTickCount(); // printf("waitMs%d, deltaMs%d, %d\n", iWaitMs, time2 - time0, bGetImg); count++; if(time2-time1 > 1000 ) { sprintf(buf, "fps:%d dropped frames:%lu ImageType:%d",count, getDroppedFrames(), (int)getImgType()); count = 0; time1=GetTickCount(); printf(buf); printf("\n"); } if(Image_type != IMG_RGB24 && Image_type != IMG_RAW16) { iStrLen = strlen(buf); CvRect rect = cvRect(iTextX, iTextY - 15, iStrLen* 11, 20); cvSetImageROI(pRgb , rect); cvSet(pRgb, CV_RGB(180, 180, 180)); cvResetImageROI(pRgb); } cvText(pRgb, buf, iTextX,iTextY ); if(bChangeFormat) { bChangeFormat = 0; bDisplay = false; pthread_join(thread_display, &retval); cvReleaseImage(&pRgb); stopCapture(); switch(change) { case change_imagetype: Image_type++; if(Image_type > 3) Image_type = 0; break; case change_bin: if(bin == 1) { bin = 2; width/=2; height/=2; } else { bin = 1; width*=2; height*=2; } break; case change_size_smaller: if(width > 320 && height > 240) { width/= 2; height/= 2; } break; case change_size_bigger: if(width*2*bin <= iMaxWidth && height*2*bin <= iMaxHeight) { width*= 2; height*= 2; } break; } setImageFormat(width, height, bin, (IMG_TYPE)Image_type); if(Image_type == IMG_RAW16) pRgb=cvCreateImage(cvSize(getWidth(),getHeight()), IPL_DEPTH_16U, 1); else if(Image_type == IMG_RGB24) pRgb=cvCreateImage(cvSize(getWidth(),getHeight()), IPL_DEPTH_8U, 3); else pRgb=cvCreateImage(cvSize(getWidth(),getHeight()), IPL_DEPTH_8U, 1); bDisplay = 1; pthread_create(&thread_display, NULL, Display, (void*)pRgb); startCapture(); //start privew } } END: if(bDisplay) { bDisplay = 0; #ifdef _LIN pthread_join(thread_display, &retval); #elif defined _WINDOWS Sleep(50); #endif } stopCapture(); closeCamera(); cvReleaseImage(&pRgb); printf("main function over\n"); return 1; }
void resetPlayerData(void) { int i; Data *data; AI *ai; int not_playing = 0; int *startIndex; startIndex = malloc( game->players * sizeof(int) ); randomPermutation(game->players, startIndex); for(i = 0; i < game->players; i++) { float startpos[][2] = { { 0.5, 0.25 }, { 0.75, 0.5 }, { 0.5, 0.75 }, { 0.25, 0.5 } }; float x, y; data = game->player[i].data; ai = game->player[i].ai; /* init ai */ switch(i) { case 0: ai->active = getSettingi("ai_player1"); break; case 1: ai->active = getSettingi("ai_player2"); break; case 2: ai->active = getSettingi("ai_player3"); break; case 3: ai->active = getSettingi("ai_player4"); break; default: fprintf(stderr, "[error] player index #%d not caught!\n", i); ai->active = AI_NONE; } ai->tdiff = 0; /* arrange players in circle around center */ /* randomize position on the grid */ x = startpos[ startIndex[i] ][0] * getSettingi("grid_size"); y = startpos[ startIndex[i] ][1] * getSettingi("grid_size"); /* randomize starting direction */ data->dir = trand() & 3; /* data->dir = startdir[i]; */ data->last_dir = data->dir; /* if player is playing... */ if(ai->active != AI_NONE) { data->speed = getSettingf("speed"); data->booster = getSettingf("booster_max"); data->boost_enabled = 0; data->trail_height = TRAIL_HEIGHT; } else { data->speed = SPEED_GONE; data->trail_height = 0; not_playing++; } // data->trail = data->trails; data->trailOffset = 0; data->trails[ data->trailOffset ].vStart.v[0] = x; data->trails[ data->trailOffset ].vStart.v[1] = y; data->trails[ data->trailOffset ].vDirection.v[0] = 0; data->trails[ data->trailOffset ].vDirection.v[1] = 0; { int camType; Camera *cam = game->player[i].camera; camType = (game->player[i].ai->active == AI_COMPUTER) ? CAM_CIRCLE : gSettingsCache.camType; initCamera(cam, data, camType); } } free(startIndex); game->running = game->players - not_playing; /* not everyone is alive */ /* printf("starting game with %d players\n", game->running); */ game->winner = -1; }
int main(int argc, char** argv){ bool loadedScene = false; for(int i=1; i<argc; i++){ string header; string data; istringstream liness(argv[i]); getline(liness, header, '='); getline(liness, data, '='); if(strcmp(header.c_str(), "mesh")==0){ //renderScene = new scene(data); mesh = new obj(); objLoader* loader = new objLoader(data, mesh); mesh->buildVBOs(); delete loader; loadedScene = true; } } if(!loadedScene){ cout << "Usage: mesh=[obj file]" << endl; return 0; } frame = 0; seconds = time (NULL); fpstracker = 0; // Launch CUDA/GL #ifdef __APPLE__ // Needed in OSX to force use of OpenGL3.2 glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3); glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2); glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); init(); #else init(argc, argv); #endif initCamera(); initLights(); initCuda(); initVAO(); initTextures(); GLuint passthroughProgram; passthroughProgram = initShader("shaders/passthroughVS.glsl", "shaders/passthroughFS.glsl"); glUseProgram(passthroughProgram); glActiveTexture(GL_TEXTURE0); #ifdef __APPLE__ // send into GLFW main loop while(1){ display(); if (glfwGetKey(GLFW_KEY_ESC) == GLFW_PRESS || !glfwGetWindowParam( GLFW_OPENED )){ kernelCleanup(); cudaDeviceReset(); exit(0); } } glfwTerminate(); #else glutDisplayFunc(display); glutKeyboardFunc(keyboard); glutMouseFunc(mouseButton); glutMotionFunc(mouseMove); glutMainLoop(); #endif kernelCleanup(); return 0; }
void keyboardPause(int key, int unicode, int x, int y) { int i; #ifdef __NETWORK__ Packet packet; #endif switch(key) { case 27: #ifdef __NETWORK__ if( game2->mode == GAME_NETWORK_PLAY && isConnected ) { isConnected = 0; isLogged = 0; serverstate=preGameState; //We hope that next time server will be to preGameState Net_disconnect(); } #endif switchCallbacks(&guiCallbacks); break; case ' ': #ifdef __NETWORK__ //restart game if( game2->mode == GAME_NETWORK_PLAY && (serverstate == preGameState) && (isConnected && slots[me].isMaster == 1) ) { makeping(0); printf("\nAsk to start the game\n"); packet.which=me; packet.type=ACTION; packet.infos.action.type=STARTGAME; Net_sendpacket(&packet, Net_getmainsock()); } else { if( game2->mode == GAME_NETWORK_PLAY ) printf("\nOnly game master can start the game...\n"); else { #endif if(game->pauseflag & PAUSE_GAME_FINISHED) initData(); /* lasttime = SystemGetElapsedTime(); */ switchCallbacks(&gameCallbacks); #ifdef __NETWORK__ } } #endif break; /* case 'q': SystemExit(); break; */ case SYSTEM_KEY_F1: defaultDisplay(0); break; case SYSTEM_KEY_F2: defaultDisplay(1); break; case SYSTEM_KEY_F3: defaultDisplay(2); break; case SYSTEM_KEY_F4: defaultDisplay(3); break; /* doesn't really work on my box */ /* case SYSTEM_KEY_F6: Gamma -= 0.1; shutdownDisplay(game->screen); SystemSetGamma(Gamma, Gamma, Gamma); setupDisplay(game->screen); break; case SYSTEM_KEY_F7: Gamma += 0.1; shutdownDisplay(game->screen); SystemSetGamma(Gamma, Gamma, Gamma); setupDisplay(game->screen); break; */ case SYSTEM_KEY_F10: game->settings->camType = (game->settings->camType + 1) % CAM_COUNT; for(i = 0; i < game->players; i++) if(game->player[i].ai->active == 0) initCamera(game->player[i].camera, game->player[i].data, game->settings->camType); break; case SYSTEM_KEY_F12: doScreenShot(game->screen->vp_w, game->screen->vp_h); break; case SYSTEM_KEY_UP: consoleScrollBackward(1); break; case SYSTEM_KEY_DOWN: consoleScrollForward(1); break; case SYSTEM_KEY_F5: saveSettings(); break; case SYSTEM_KEY_TAB: switchCallbacks(&promptCallbacks); break; } }
void VideoDevice::startCapture(int deviceID) { initCamera(deviceID); captureThread = new std::thread(&VideoDevice::captureFromCamera, this); }
/** * @brief Flips the calibration vertically. */ void Camera::flip_vertical(){ initCamera(); cameraMatrix.col(1) *= -1.0; }
/** * @brief Flips the calibration horizontally. */ void Camera::flip_horizontal(){ initCamera(); cameraMatrix.col(0) *= -1.0; }
int initImageSync(){ sem_init(&FileQSem, 0, 1); sem_init(&NewFileSem, 0, 0); return initCamera(); }
/* new scene */ int createScene (pScene sc, int idmesh) { pMesh mesh; char data[128]; /* default */ mesh = cv.mesh[idmesh]; if (!quiet) fprintf(stdout, " Computing 3D scene\n"); /* set default mode */ sc->idmesh = idmesh; sc->par.xi = sc->par.yi = 10; if (option == SCHNAUZER) { sc->par.xs = schw; sc->par.ys = schh; } else { if (sc->par.xs == 0) sc->par.xs = 600; if (sc->par.ys == 0) sc->par.ys = 600; } if (!sc->mode) sc->mode = HIDDEN; sc->item = 0; sc->shrink = 1.0; sc->slave = sc->master = -1; sc->picked = 0; if (mesh->nvn == 0) sc->type ^= S_FLAT; if (mesh->ne == 0) sc->item |= S_GEOM; /* compute scene depth */ sc->dmax = sc->dmin = mesh->xmax - mesh->xmin; sc->dmax = max(sc->dmax, mesh->ymax - mesh->ymin); sc->dmin = min(sc->dmin, mesh->ymax - mesh->ymin); if (mesh->dim == 3) { sc->dmax = max(sc->dmax, mesh->zmax - mesh->zmin); sc->dmin = min(sc->dmin, mesh->zmax - mesh->zmin); } sc->dmax = fabs(sc->dmax); sc->dmin = fabs(sc->dmin); if (!sc->par.sunp) { sc->par.sunpos[0] *= 2.0 * sc->dmax; sc->par.sunpos[1] *= 2.0 * sc->dmax; sc->par.sunpos[2] *= 2.0 * sc->dmax; } sc->par.sunpos[3] = 1.0; /* create window */ glutInitWindowSize(sc->par.xs, sc->par.ys); sc->idwin = glutCreateWindow(""); assert(sc->idwin != 0); if (fullscreen) { glutFullScreen(); sc->par.xs = glutGet(GLUT_SCREEN_WIDTH); sc->par.ys = glutGet(GLUT_SCREEN_HEIGHT); } /* set window name */ sprintf(data, "Medit - [%s] #%d", mesh->name, sc->idwin); glutSetWindowTitle(data); glutSetIconTitle(data); /* required! to change background color */ glClearColor(sc->par.back[0], sc->par.back[1], sc->par.back[2], sc->par.back[3]); /* init perspective */ sc->persp = initPersp(0, sc->dmax); sc->camera = (pCamera)initCamera(sc, Y_AXIS); if (mesh->typ == 2) { sc->persp->pmode = CAMERA; sc->persp->depth *= 0.5; } /* create default view */ sc->view = (pTransform)createTransform(); if (!sc->view) return (0); sc->type |= S_RESET + S_DECO; sc->clip = (pClip)createClip(sc, mesh); if (!sc->clip) return (0); sc->cube = (pCube)createCube(sc, mesh); if (!sc->cube) return (0); /* create menus */ if (!createMenus(sc, mesh)) return (0); /* assign callbacks */ if (sc->type & S_SCISSOR) { glutDisplayFunc(scissorScene); } else if (option == SCHNAUZER) { glutDisplayFunc(redrawSchnauzer); } else if (sc->persp->pmode == CAMERA) { glutMouseFunc(mouseCamera); glutMotionFunc(motionCamera); glutDisplayFunc(redrawScene); } else { glutMouseFunc(mouse); glutMotionFunc(motion); glutDisplayFunc(redrawScene); } glutReshapeFunc(reshapeScene); glutKeyboardFunc(keyScene); glutSpecialFunc(special); glutAttachMenu(GLUT_RIGHT_BUTTON); /* create display lists by geom type */ glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); doLists(sc, mesh); sc->glist = geomList(sc, mesh); sc->type |= S_FOLLOW; /* local stack */ if (!pilmat) { pilmat = (int *)calloc(sc->par.nbmat + 2, sizeof(int)); if (!pilmat) return (0); } /* color list */ setupPalette(sc, mesh); sc->stream = NULL; initGrafix(sc, mesh); return (1); }
int main(int argc, char** argv) { /*Check arguments to make sure you got a file*/ //There must be at least some arguments to get a file if(errno != 0){ perror("Unknown Error at start"); errno = 0; } const char* filename = NULL; const char* outfile = NULL; bool gui = false; float nodeCharge = 3; bool output = true; bool isFile = true; layout_params* params = (layout_params*) malloc(sizeof(layout_params)); params->ke = 500; params->kh = 0.0005; params->kl = -0.05; params->width = 1920; params->height = 1080; params->iterations = 10000; params->mass = 1; params->time = 1; params->coefficientOfRestitution = -0.9; params->mus = 0.2; params->muk = 0.04; params->kw = 3; params->kg = 0.06; params->wellMass = 1; params->edgeCharge = nodeCharge; params->forcemode = COULOMBS_LAW | HOOKES_LAW_SPRING | FRICTION | DRAG | BOUNCY_WALLS; params->cpuLoop = false; if (argc < 2) { usage(); return EXIT_FAILURE; } for (int i = 1; i < argc; i++) { if(errno != 0){ fprintf(stderr, "On Iter: %d ", i); perror("Unknown Error"); errno = 0; } if (strcmp(argv[i], "-f") == 0) { if (filename != NULL) { printf( "An input directory has already been provided (%s).\nCan only use one of -f and -d.\n", filename); exit(-1); } filename = readString(argc, argv, ++i); isFile = true; } else if (strcmp(argv[i], "-d") == 0) { if (filename != NULL) { printf( "An input file has already been provided (%s).\nCan only use one of -f and -d.\n", filename); exit(-1); } filename = readString(argc, argv, ++i); isFile = false; } else if (strcmp(argv[i], "-o") == 0) { outfile = readString(argc, argv, ++i); } else if (strcmp(argv[i], "-Ke") == 0) { params->ke = readFloat(argc, argv, ++i); } else if (strcmp(argv[i], "-Kh") == 0) { params->kh = readFloat(argc, argv, ++i); } else if (strcmp(argv[i], "-Kl") == 0) { params->kl = readFloat(argc, argv, ++i); } else if (strcmp(argv[i], "-nodeCharge") == 0) { nodeCharge = readFloat(argc, argv, ++i); } else if (strcmp(argv[i], "-edgeCharge") == 0) { params->edgeCharge = readFloat(argc, argv, ++i); } else if (strcmp(argv[i], "-Kg") == 0) { params->kg = readFloat(argc, argv, ++i); } else if (strcmp(argv[i], "-nm") == 0) { params->wellMass = readFloat(argc, argv, ++i); } else if (strcmp(argv[i], "-mus") == 0) { params->mus = readFloat(argc, argv, ++i); } else if (strcmp(argv[i], "-muk") == 0) { params->muk = readFloat(argc, argv, ++i); } else if (strcmp(argv[i], "-i") == 0) { params->iterations = readInt(argc, argv, ++i); } else if (strcmp(argv[i], "-width") == 0) { params->width = readInt(argc, argv, ++i); } else if (strcmp(argv[i], "-height") == 0) { params->height = readInt(argc, argv, ++i); } else if (strcmp(argv[i], "-gui") == 0) { gui = true; } else if (strcmp(argv[i], "-cpuLoop") == 0) { params->cpuLoop = true; } else if (strcmp(argv[i], "-noOutput") == 0) { output = false; } else if (strcmp(argv[i], "-t") == 0) { params->time = readFloat(argc, argv, ++i); } else if (strcmp(argv[i], "-m") == 0) { params->mass = readFloat(argc, argv, ++i); } else if (strcmp(argv[i], "-cRest") == 0) { params->coefficientOfRestitution = readFloat(argc, argv, ++i); } else if (strcmp(argv[i], "-friction") == 0) { int fricForce = readInt(argc, argv, ++i); params->forcemode = params->forcemode & ~(FRICTION | DRAG); params->forcemode = params->forcemode | (fricForce << 2); } else if (strcmp(argv[i], "-spring") == 0) { int springForce = readInt(argc, argv, ++i); params->forcemode = params->forcemode & ~(HOOKES_LAW_SPRING | LOG_SPRING); params->forcemode = params->forcemode | (springForce); } else if (strcmp(argv[i], "-walls") == 0) { int wallForce = readInt(argc, argv, ++i); params->forcemode = params->forcemode & ~(BOUNCY_WALLS | CHARGED_WALLS | GRAVITY_WELL); params->forcemode = params->forcemode | (wallForce << 4); } else if (strcmp(argv[i], "-forces") == 0) { int primForce = readInt(argc, argv, ++i); params->forcemode = params->forcemode & ~(COULOMBS_LAW | DEGREE_BASED_CHARGE | CHARGED_EDGE_CENTERS | WRAP_AROUND_FORCES); params->forcemode = params->forcemode | (primForce << 7); } else { fprintf(stderr, "Unknown option %s\n", argv[i]); return EXIT_FAILURE; } } if (filename == NULL) { fprintf(stderr, "You must include a filename\n"); usage(); return EXIT_FAILURE; } graph** g; int graphCount = 0; if (isFile) { debug("Reading graph: %s\n", filename); g = (graph**) malloc(sizeof(graph*)); g[0] = readFile(filename); graphCount = 1; } else { g = readDir(filename, &graphCount); } if (g == NULL || graphCount < 1) { fprintf(stderr, "Creating a graph failed. Terminating\n"); usage(); return EXIT_FAILURE; } for (int i = 0; i < graphCount; i++) { graph_initRandom(g[i], 20, 10, params->width, params->height, nodeCharge); } if (gui && isFile) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); glutInitWindowSize(params->width, params->height); glutCreateWindow("Force Directed Layout"); glutDisplayFunc(display); //glutReshapeFunc(reshape); glutIdleFunc(idle); setLight(); initCamera(params->width, params->height); glGraph = g; glParams = params; glutMainLoop(); } else if (gui) { printf("Cannot use gui mode with a directory.\n"); exit(-1); } /* The graph is now is a legal state. * It is not using the GUI. * It is possible to lay it out now */ struct timeval tstart, tend; gettimeofday(&tstart, NULL); graph_layout(g, graphCount, params); gettimeofday(&tend, NULL); long start = tstart.tv_sec * 1000000 + tstart.tv_usec; long end = tend.tv_sec * 1000000 + tend.tv_usec; long msElapsed = end - start; debug("Elapsed Time (us): %ld\n", msElapsed); if (outfile == NULL && isFile) { outfile = "after.svg"; } if (output && (outfile != NULL)) { for (int i = 0; i < graphCount; i++) { #define BUFF_SIZE 1024 char thisOutFile[BUFF_SIZE]; strncpy(thisOutFile,outfile,BUFF_SIZE); if(!isFile){ //Does it end on a / int len = strlen(thisOutFile); if(thisOutFile[len-1] != '/'){ if(len < BUFF_SIZE - 2){ //Keep enough space for the '\0' thisOutFile[len++] = '/'; thisOutFile[len] = '\0'; }else{ fprintf(stderr,"File name too long (%s [/] %s [/] %s)\n. Not creating svg.\n", outfile, (g[i])->dir, g[i]->filename); continue; } } //Now concatenate the dir name if(g[i]->dir != NULL){ int len2 = strlen(g[i]->dir); if(len + len2 +1 > BUFF_SIZE){ fprintf(stderr,"File name too long (%s [/] %s [/] %s)\n. Not creating svg.\n", outfile, (g[i])->dir, g[i]->filename); continue; } strcat(thisOutFile, g[i]->dir + (g[i]->dir[0]=='/'? 1: 0)); } //Now the file name int len2 = strlen(g[i]->filename); if(len + len2 + 1 > BUFF_SIZE){ fprintf(stderr,"File name too long (%s [/] %s [/] %s)\n. Not creating svg.\n", outfile, (g[i])->dir, g[i]->filename); continue; } strcat(thisOutFile,g[i]->filename); char* extension = strstr(thisOutFile, ".graphml"); if(extension ==NULL){ fprintf(stderr,"Something went wrong. Could not find .graphml in %s\nTerminating\n", thisOutFile); exit(EXIT_FAILURE); } strcpy(extension, ".svg"); //Now the filename is finally right! } graph_toSVG(g[i], thisOutFile, params->width, params->height, (params->forcemode & (BOUNCY_WALLS | CHARGED_WALLS)) != 0, msElapsed, params); } } //Free all the graphs and the structure that holds it free(g[0]->nodes); bitarray_free(g[0]->edges); for (int i = 0; i < graphCount; i++) { graph_free(g[i]); } free(g); free(params); return EXIT_SUCCESS; }
CameraModel::CameraModel(Vec3 _camPosition, Vec3 _camDirection, double _fov, double _focalDistance, double _apertureRadius, unsigned int _width, unsigned int _height): camPosition(_camPosition), camDirection(_camDirection), fov(_fov), focalDistance(_focalDistance), apertureRadius(_apertureRadius), width(_width), height(_height) { initCamera(); }
void vkeGameRendererDynamic::initDescriptorSets(){ VulkanDC *dc = VulkanDC::Get(); VulkanDC::Device *device = dc->getDefaultDevice(); uint32_t count = 1; if (!dc) return; initCamera(); vkResetDescriptorPool(device->getVKDevice(), getDescriptorPool(), 0); VkWriteDescriptorSet writes[5]; /*---------------------------------------------------------- Get the resource data for the bindings. ----------------------------------------------------------*/ /* Terrain textures. */ VkeTexture::Data terrain = m_textures.getTexture(0)->getData(); /* Camera and Light uniforms */ VkDescriptorBufferInfo camInfo = m_camera->getDescriptor(); VkDescriptorBufferInfo lightInfo = m_light->getDescriptor(); /* Cube map texture. */ VkeCubeTexture::Data cube = m_cube_textures.getTexture(1)->getData(); /* Create descriptor image info array for the terrain textures. */ VkDescriptorImageInfo fpSampler = { terrain.sampler, terrain.view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL }; VkeMaterial *material = m_materials->getMaterial(0); /* Create descriptor image info array for the scene textures. */ uint32_t texCount = m_materials->count(); VkDescriptorImageInfo *texImageInfo = (VkDescriptorImageInfo*)malloc(texCount * sizeof(VkDescriptorImageInfo)); for (uint32_t i = 0; i < texCount; ++i){ VkeMaterial *mtrl = m_materials->getMaterial(i); VkeTexture::Data texData = mtrl->getTextures().getTexture(0)->getData(); texImageInfo[i].imageView = texData.view; texImageInfo[i].sampler = texData.sampler; } /* Create descriptor image info for the cube map texture. */ VkDescriptorImageInfo cubeTexture; cubeTexture.sampler = cube.sampler; cubeTexture.imageView = cube.view; cubeTexture.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; /* Capture the layouts for the scene descriptor sets and the texture descriptor sets. */ VkDescriptorSetLayout *textureLayouts = (VkDescriptorSetLayout*)malloc(sizeof(VkDescriptorSetLayout) * texCount); for (uint32_t i = 0; i < texCount; ++i){ textureLayouts[i] = m_texture_descriptor_set_layout; } /* Allocate storage for the scene and texture descriptor sets. */ /*---------------------------------------------------------- Allocate the descriptor sets. ----------------------------------------------------------*/ m_texture_descriptor_sets = (VkDescriptorSet*)malloc(sizeof(VkDescriptorSet)); /* Set up the alocate info structure for the descriptor sets. */ VkDescriptorSetAllocateInfo descAlloc; memset(&descAlloc, 0, sizeof(descAlloc)); descAlloc.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; descAlloc.descriptorPool = getDescriptorPool(); descAlloc.pSetLayouts = &m_scene_descriptor_layout; descAlloc.descriptorSetCount = 1; VKA_CHECK_ERROR(vkAllocateDescriptorSets(device->getVKDevice(), &descAlloc, &m_scene_descriptor_set), "Could not allocate descriptor sets.\n"); /* Set up the texture descriptor sets. */ descAlloc.pSetLayouts = &m_texture_descriptor_set_layout; descAlloc.descriptorSetCount = 1; VKA_CHECK_ERROR(vkAllocateDescriptorSets(device->getVKDevice(), &descAlloc, m_texture_descriptor_sets), "Could not allocate texture descriptor sets.\n"); /* Set up the skybox descriptor sets. */ descAlloc.pSetLayouts = &m_quad_descriptor_set_layout; descAlloc.descriptorSetCount = 1; VKA_CHECK_ERROR(vkAllocateDescriptorSets(device->getVKDevice(), &descAlloc, &m_quad_descriptor_set), "Could not allocate descriptor sets.\n"); /* Set up the terrian descriptor sets. */ descAlloc.pSetLayouts = &m_terrain_descriptor_set_layout; descAlloc.descriptorSetCount = 1; VKA_CHECK_ERROR(vkAllocateDescriptorSets(device->getVKDevice(), &descAlloc, &m_terrain_descriptor_set), "Could not allocate descriptor sets.\n"); /* Set up the transforms descriptor sets. */ descAlloc.pSetLayouts = &m_transform_descriptor_layout; descAlloc.descriptorSetCount = 1; VKA_CHECK_ERROR(vkAllocateDescriptorSets(device->getVKDevice(), &descAlloc, &m_transform_descriptor_set), "Could not allocate descriptor sets.\n"); /*---------------------------------------------------------- Update the descriptor sets with resource bindings. ----------------------------------------------------------*/ /* Scene layout bindings (set 0) Binding 0: Environment Cube Map Binding 1: Camera Matrix Binding 2: Model Matrix Binding 3: Material */ descriptorSetWrite(&writes[0], 0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_NULL_HANDLE, &cubeTexture, 0, m_scene_descriptor_set);//cubemap descriptorSetWrite(&writes[1], 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, &camInfo, VK_NULL_HANDLE, 0, m_scene_descriptor_set); //Camera descriptorSetWrite(&writes[2], 2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, &m_uniforms_descriptor, VK_NULL_HANDLE, 0, m_scene_descriptor_set);//modelview descriptorSetWrite(&writes[3], 3, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, &material->getDescriptor(), VK_NULL_HANDLE, 0, m_scene_descriptor_set);//material vkUpdateDescriptorSets(device->getVKDevice(), 4, writes, 0, NULL); /* Transform layout bindings (set 0) Binding 0: Transform */ descriptorSetWrite(&writes[0], 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, &m_transforms_descriptor, VK_NULL_HANDLE, 0, m_transform_descriptor_set);//transform vkUpdateDescriptorSets(device->getVKDevice(), 1, writes, 0, NULL); /* Scene layout bindings (set 1) Binding 0: Scene texture array */ descriptorSetWrite(&writes[0], 0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, texCount, VK_NULL_HANDLE, texImageInfo, 0, m_texture_descriptor_sets[0]);//cubemap vkUpdateDescriptorSets(device->getVKDevice(), (uint32_t)1, writes, 0, NULL); //Free the texture image info allocated earlier. free(texImageInfo); /* Skybox layout bindings (set 0) Binding 0: Skybox Uniforms Binding 1: Skybox Textures Binding 2: Camera uniforms */ descriptorSetWrite(&writes[0], 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, &m_screen_quad.getData().descriptor, VK_NULL_HANDLE, 0, m_quad_descriptor_set); descriptorSetWrite(&writes[1], 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_NULL_HANDLE, &cubeTexture, 0, m_quad_descriptor_set); descriptorSetWrite(&writes[2], 2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, &camInfo, VK_NULL_HANDLE, 0, m_quad_descriptor_set); vkUpdateDescriptorSets(device->getVKDevice(), 3, writes, 0, NULL); /* Terrain layout bindings (set 0) Binding 0: Terrain Uniforms Binding 1: Camera Uniforms Binding 2: Terrain texture array */ descriptorSetWrite(&writes[0], 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, &m_terrain_quad.getData().descriptor, VK_NULL_HANDLE, 0, m_terrain_descriptor_set); descriptorSetWrite(&writes[1], 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, &camInfo, VK_NULL_HANDLE, 0, m_terrain_descriptor_set); descriptorSetWrite(&writes[2], 2, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1, VK_NULL_HANDLE, &fpSampler, 0, m_terrain_descriptor_set); descriptorSetWrite(&writes[3], 3, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1, VK_NULL_HANDLE, &cubeTexture, 0, m_terrain_descriptor_set); vkUpdateDescriptorSets(device->getVKDevice(), 4, writes, 0, NULL); /*---------------------------------------------------------- Initialise the terrain and scene command buffers. ----------------------------------------------------------*/ initTerrainCommand(); for (uint32_t i = 0; i < m_max_draw_calls; ++i){ m_draw_calls[i]->initDescriptor(); } //m_test_drawcall->initDrawCommands(m_node_data->count()); //this needs to happen in the thread. //m_draw_calls[0]->initDrawCommands(m_node_data->count()); }
/*! Initialization of the grabber using a greyscale image. \param I : gray level image. */ void vp1394CMUGrabber::open(vpImage<unsigned char> &I) { initCamera(); I.resize(this->height, this->width); }
void ofxLibdc::setup(int cameraNumber) { initCamera(cameraNumber); applySettings(); }
/*! Initialization of the grabber using a color image. \param I : color image. */ void vp1394CMUGrabber::open(vpImage<vpRGBa> &I) { initCamera(); I.resize(this->height, this->width); }
int initPositionnement(){ pthread_t thread; threadArg arg; char message[32]; string messageEnvoi, messageRecu; short angleRotationR = 0; // Faire l'initialisation de la caméra: initCamera(); //Initialisation du magnétomètre: sem_wait(Arg.verrou_I2C); if (i2c_w(ADDR_MAGNETOMETRE, CALIBRATION_START, NULL) != 0){ puts("Magnétomètre failed"); // Arrêt du programme finProgramme = true; pthread_exit(NULL); } robot.pivotRight(20); sleep(20); if (i2c_w(ADDR_MAGNETOMETRE, CALIBRATION_END, NULL) != 0){ puts("Magnétomètre failed"); // Arrêt du programme finProgramme = true; pthread_exit(NULL); } if (i2c_w(ADDR_MAGNETOMETRE, CMD_A, NULL) != 0){ puts("Magnétomètre failed"); // Arrêt du programme finProgramme = true; pthread_exit(NULL); } sem_post(Arg.verrou_I2C); // Initialisation des variables indiquant l'état dans lequel on se trouve robotTourne = false; robotAvance = true; flagVirage = 0; flagStop = true; taskDone = false; // On tente de trouver la personne en activant la caméra puis en vérifiant que la personne et le robot // soient dans la même direction. -> Si la caméra détecte une personne on va lancer la prise de photo. do{ // On regarde dans quelles positions se trouvent la personne par rapport au robot avec les magnéto. taskDone = false; pthread_create(&thread, NULL, magnetometre, (void *) &arg); while(taskDone != true){/* On attend la fin de ta tache */} pthread_join(thread, NULL); // Si c'est dans le thread magnéto qu'on a reçu l'ordre d'arrêt if (finProgramme == true){ // Fin du thread pthread_exit(NULL); } // Lance la vérif avec le magnétomètre et la caméra sur 360° par palier de 30°: while (abs(differenceAngle) > ANGLE_LIMITE){ sprintf(message, "A: %d", differenceAngle); messageEnvoi = message; zigbee_w(messageEnvoi); // Petite tempo pour laisser le temps à la beagle de la personne de faire des modifs usleep(100000); // On refait une acquisition des magnéto taskDone = false; pthread_create(&thread, NULL, magnetometre, NULL); while(taskDone != true){/* On attend la fin de ta tache */} pthread_join(thread, NULL); // Si c'est dans le thread magnéto qu'on a reçu l'ordre d'arrêt if (finProgramme == true){ // Fin du thread pthread_exit(NULL); } } // Message indiquant que la personne et le robot sont dans la même direction zigbee_w("M: magneto_success"); // On attend que le son est bien été joué zigbee_r(messageRecu); if (strcmp(messageRecu.c_str(), "need_synchro") == 0){ string synchro = ""; while (strcmp(synchro.c_str(), "synchro_success") != 0){ zigbee_w("synchronize"); zigbee_r(synchro); } } else if (strcmp(messageRecu.c_str(), "end_program") == 0){ // Arrêt du programme finProgramme = true; pthread_exit(NULL); } // Mnt que le robot et la personne sont dans la même direction on va pouvoir faire une acquisition // pour voir si on trouve quelqu'un. cameraInformation = camera(); if (cameraInformation.flagDetect == false){ // Si on ne détecte toujours pas la personne on va alors faire pivoter le robot sur lui même de 30° // Et ainsi de suite jusqu'à balayer un angle de 180° permettant de vérifier la zone se trouvant à // l'arrière du robot au moment où on s'est rendu compte de la perte de la personne zigbee_w("M: detection_failed"); // On attend que le son est bien été joué zigbee_r(messageRecu); if (strcmp(messageRecu.c_str(), "need_synchro") == 0){ string synchro = ""; while (strcmp(synchro.c_str(), "synchro_success") != 0){ zigbee_w("synchronize"); zigbee_r(synchro); } } else if (strcmp(messageRecu.c_str(), "end_program") == 0){ // Arrêt du programme finProgramme = true; pthread_exit(NULL); } angleRotationR += 30; if (angleRotationR >= 360) { puts("Aucune personne n'a été détectée, arrêt du programme"); zigbee_w("I: not_found"); // Arrêt du programme finProgramme = true; pthread_exit(NULL); } // Modifier la direction du robot: robot.pivotRight(100, 30); } // Petite tempo pour laisser le temps à la personne de se replacer usleep(1500000); }while (cameraInformation.flagDetect == false); // Si on détecte un visage, on va supposer que c'est la personne qui veut être guidée. // On va lancer la prise de photo takePicture(); // Initialisation des ultrasons: if (i2c_w(ADDR_ULTRASON_3, REGISTRE_W_RANGE, DETECTION_MAX, NULL) != 0){ finProgramme = true; pthread_exit(NULL); } if (i2c_w(ADDR_ULTRASON_2, REGISTRE_W_RANGE, DETECTION_MAX, NULL) != 0){ finProgramme = true; pthread_exit(NULL); } if (i2c_w(ADDR_ULTRASON_4, REGISTRE_W_RANGE, DETECTION_MAX, NULL) != 0){ finProgramme = true; pthread_exit(NULL); } if (i2c_w(ADDR_ULTRASON_1, REGISTRE_W_RANGE, DETECTION_MAX, NULL) != 0){ finProgramme = true; pthread_exit(NULL); } if (i2c_w(ADDR_ULTRASON_5, REGISTRE_W_RANGE, DETECTION_MAX, NULL) != 0){ finProgramme = true; pthread_exit(NULL); } flagInit = true; return 0; }
void initGame(void) { lcdMainOnTop(); int oldv=getMemFree(); NOGBA("mem free : %dko (%do)",getMemFree()/1024,getMemFree()); NOGBA("initializing..."); videoSetMode(MODE_5_3D | DISPLAY_BG3_ACTIVE); videoSetModeSub(MODE_5_2D | DISPLAY_BG3_ACTIVE); glInit(); vramSetPrimaryBanks(VRAM_A_TEXTURE,VRAM_B_TEXTURE,VRAM_C_LCD,VRAM_D_MAIN_BG_0x06000000); vramSetBankH(VRAM_H_SUB_BG); vramSetBankI(VRAM_I_SUB_BG_0x06208000); glEnable(GL_TEXTURE_2D); // glEnable(GL_ANTIALIAS); glDisable(GL_ANTIALIAS); glEnable(GL_BLEND); glEnable(GL_OUTLINE); glSetOutlineColor(0,RGB15(0,0,0)); //TEMP? glSetOutlineColor(1,RGB15(0,0,0)); //TEMP? glSetOutlineColor(7,RGB15(31,0,0)); //TEMP? glSetToonTableRange(0, 15, RGB15(8,8,8)); //TEMP? glSetToonTableRange(16, 31, RGB15(24,24,24)); //TEMP? glClearColor(31,31,0,31); glClearPolyID(63); glClearDepth(0x7FFF); glViewport(0,0,255,191); // initVramBanks(1); initVramBanks(2); initTextures(); initSound(); initCamera(NULL); initPlayer(NULL); initLights(); initParticles(); initMaterials(); loadMaterialSlices("slices.ini"); loadMaterials("materials.ini"); loadControlConfiguration("config.ini"); initElevators(); initWallDoors(); initTurrets(); initBigButtons(); initTimedButtons(); initEnergyBalls(); initPlatforms(); initCubes(); initEmancipation(); initDoors(); initSludge(); initPause(); initText(); NOGBA("lalala"); getPlayer()->currentRoom=&gameRoom; currentBuffer=false; getVramStatus(); fadeIn(); mainBG=bgInit(3, BgType_Bmp16, BgSize_B16_256x256, 0, 0); bgSetPriority(mainBG, 0); REG_BG0CNT=BG_PRIORITY(3); #ifdef DEBUG_GAME consoleInit(&bottomScreen, 3, BgType_Text4bpp, BgSize_T_256x256, 16, 0, false, true); consoleSelect(&bottomScreen); #endif // glSetToonTableRange(0, 14, RGB15(16,16,16)); // glSetToonTableRange(15, 31, RGB15(26,26,26)); initPortals(); //PHYSICS initPI9(); strcpy(&mapFilePath[strlen(mapFilePath)-3], "map"); newReadMap(mapFilePath, NULL, 255); transferRectangles(&gameRoom); makeGrid(); generateRoomGrid(&gameRoom); gameRoom.displayList=generateRoomDisplayList(&gameRoom, vect(0,0,0), vect(0,0,0), false); getVramStatus(); startPI(); NOGBA("START mem free : %dko (%do)",getMemFree()/1024,getMemFree()); NOGBA("vs mem free : %dko (%do)",oldv/1024,oldv); levelInfoCounter=60; }