CameraOrtho2::CameraOrtho2 (const string& name="default") { _mvid = SGR::SeedGenerator::getInst().maxseed(); _invmvid = SGR::SeedGenerator::getInst().maxseed(); _projid = SGR::SeedGenerator::getInst().maxseed(); _invprojid = SGR::SeedGenerator::getInst().maxseed(); camera_create ( _mvid ); camera_create ( _invmvid ); projection_create ( _projid ); projection_create ( _invprojid ); }
void scene_load(void) { load_bitmaps(); scene.realImages = 0; scene.camera = camera_create(); scene.octree = octree_init(input_path_concat("galaxies.txt"), 20000); scene.galaxies = galaxylist_create(); }
static void startup(void) { fprintf(stderr, "%s test\n", __func__); /* start of TC */ int ret; ret = camera_create(CAMERA_DEVICE_CAMERA0, &camera); if( ret != 0 ) dts_fail("camera_create", "Could not create camera"); }
void init() { heightfield hf; heightfieldinfo hfi; skybox sb; object3d plan = create_plan_xy(100, 100, 1, 1); material mat = material_create(NULL, 0, &color_red, 0, 0); matrix4 tmp; vector3 cam_pos = {0,50,0}; vector3 cam_up = {0,1,0}; vector3 cam_look = {0,50,-1}; viewport vp = viewport_create(0, 0, display_width(screen), display_height(screen)); /* Camera */ camfps = camera_create(60, ZFAR, ZNEAR, &cam_pos, &cam_look, &cam_up, vp); /* Heightfied creation */ hf = heightfield_create_from_file("data/height.png", 1000, 1000, 100); heightfield_set_textures_from_file(hf, "data/land.jpg", "data/detail.jpg"); heightfield_set_detail_scale(hf, 50, 50); matrix4_to_rot_x(tmp, -90); heightfield_set_world_matrix(hf, tmp); /* Heightfield infos*/ hfi = heightfieldinfo_create("data/land.jpg", hf, camfps, screen, 250, 250); /* Skybox */ sb = skybox_create(camfps, "data/left.jpg", "data/right.jpg", "data/front.jpg", "data/back.jpg", "data/top.jpg", "data/bottom.jpg", 10); /* Test plane */ object3d_set_material(plan, mat); /* Populate the scene */ scn = scene_create(); scene_set_camera(scn, camfps); scene_set_display(scn, screen); scene_add_object(scn, sb, (void *)skybox_to_opengl, NULL); scene_add_object(scn, hf, (void *)heightfield_to_opengl, NULL); scene_add_object(scn, plan, (void *)object3d_to_opengl, NULL); scene_add_object2d(scn, hfi, (void *)heightfieldinfo_to_opengl, NULL); fontgl_init(); font = fontgl_create("data/vera.ttf", 800, 600, 16); fontgl_set_color(font, 1,0,0); glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); SDL_WarpMouse(CENTERX,CENTERY); SDL_WM_GrabInput(SDL_GRAB_ON); SDL_ShowCursor(SDL_DISABLE); }
TrayObject *camera(TrayLangState *state, int arg_num) { TrayObject *fov = traylang_get_obj(state); check(fov, "camera fov arg error"); TrayObject *pos = traylang_get_obj(state); check(pos, "camera position arg error"); TrayObject *look = traylang_get_obj(state); check(look, "camera look_at arg error"); return traylang_new_cdata( state, camera_create(fov->number, *(Vector3D*)pos->cdata, *(Vector3D*)look->cdata) ); error: return NULL; }
static Eina_Bool _main_view_init_camera(main_view *main_view_data) { camera_state_e cur_state = CAMERA_STATE_NONE; int result = camera_create(CAMERA_DEVICE_CAMERA0, &main_view_data->camera); if (CAMERA_ERROR_NONE == result) { if (main_view_data->preview_canvas) { int result = camera_get_state(main_view_data->camera, &cur_state); if(cur_state == CAMERA_STATE_CREATED) { result = camera_set_display(main_view_data->camera, CAMERA_DISPLAY_TYPE_EVAS, GET_DISPLAY(main_view_data->preview_canvas)); if (CAMERA_ERROR_NONE == result) { /* Camera Disply Set */ camera_set_display_mode(main_view_data->camera, CAMERA_DISPLAY_MODE_LETTER_BOX); //camera_set_display_flip(main_view_data->camera, CAMERA_FLIP_VERTICAL); camera_set_display_visible(main_view_data->camera, true); camera_foreach_supported_capture_format (main_view_data->camera, _camera_supported_capture_format_callback, main_view_data); _get_screen_resolution(); camera_foreach_supported_preview_resolution ( main_view_data->camera, _camera_supported_preview_resolution_callback, main_view_data); camera_foreach_supported_capture_resolution ( main_view_data->camera, _camera_supported_capture_resolution_callback, main_view_data); result = camera_get_preview_resolution(main_view_data->camera, &height , &width); INF("camera preview resolution width %d, height %d", width, height); result = camera_get_capture_resolution(main_view_data->camera, &height , &width); INF("camera capture resolution width %d, height %d", width, height); return _main_view_start_camera_preview(main_view_data->camera); } } } } return !result; }
static int load_camera(scene_t *scene,FILE *file,char *path) { char buffer[128],pathname[256]; float length = 0; camera_config_t config; memset(&config,0,sizeof(camera_config_t)); config.aspect = 4.0 / 3.0; fscanf(file,"%s",buffer); while(fscanf(file,"%s",buffer) != EOF) { if(buffer[0] == '#') skeep_comment(file); else if(!strcmp(buffer,"start")) scene->start = load_float(file); else if(!strcmp(buffer,"end")) scene->end = load_float(file); else if(!strcmp(buffer,"length")) length = load_float(file); else if(!strcmp(buffer,"pathpos")) { load_name(file,path,pathname); if(length <= scene->end - scene->start) scene->pathpos = spline_close_load(pathname,length,0,0,0); else scene->pathpos = spline_load(pathname,length,0,0,0); if(!scene->pathpos) return 0; } else if(!strcmp(buffer,"pathdir")) { load_name(file,path,pathname); if(length <= scene->end - scene->start) scene->pathdir = spline_close_load(pathname,length,0,0,0); else scene->pathdir = spline_load(pathname,length,0,0,0); if(!scene->pathdir) return 0; } else if(!strcmp(buffer,"fov")) config.fov = load_float(file); else if(!strcmp(buffer,"aspect")) config.aspect = load_float(file); else if(!strcmp(buffer,"clipnear")) config.clipnear = load_float(file); else if(!strcmp(buffer,"clipfar")) config.clipfar = load_float(file); else if(!strcmp(buffer,"fogcolor")) load_color(file,config.fogcolor); else if(!strcmp(buffer,"fogstart")) config.fogstart = load_float(file); else if(!strcmp(buffer,"fogend")) config.fogend = load_float(file); else if(!strcmp(buffer,"}")) { scene->camera = camera_create(&config); break; } else return 0; } if(!scene->camera) return 0; return 1; }
void arcball_create(SDL_Window* window, Vec4f eye, Vec4f target, float z_near, float z_far, struct Arcball* arcball) { int32_t width,height; sdl2_debug( SDL_GL_GetDrawableSize(window, &width, &height) ); // - if the user specifies an eye and target so that we are looking along the y-axis (like 0,1,0 and 0,0,0), // then we just adjust the eye a tiny bit upwards to prevent a black screen because the up_axis used in // arcball_event is the y axis, and two parallel axis have no cross product and things become 0 and everything // gets messy, so just add FLOAT_EPSILON to the z coord and be done with it if( eye[0] == target[0] && eye[2] == target[2] ) { bool assert_test = eye[1] != target[1]; log_assert( assert_test == true ); eye[2] += CUTE_EPSILON; } if( z_near < 0.01f ) { log_warn(__FILE__, __LINE__, "you are trying to create a camera with a very small z_near value, " "this would cause problems when rendering vbomeshes with a z_offset, " "this function (arcball_create) will clamp the z_near value to 0.01f\n"); z_near = 0.01f; } camera_create(width, height, CAMERA_PERSPECTIVE, &arcball->camera); float top = (z_near/width) * height/2.0f; float bottom = -top; camera_set_frustum(&arcball->camera, -z_near/2.0f, z_near/2.0f, bottom, top, z_near, z_far); vec_copy4f(eye, arcball->camera.pivot.position); arcball->flipped = pivot_lookat(&arcball->camera.pivot, target); arcball->rotate_button = INPUT_MOUSE_ARCBALL_ROTATE; arcball->translate_button = INPUT_MOUSE_ARCBALL_TRANSLATE; arcball->translate_factor = 500.0f; arcball->zoom_factor = 10.0f; vec_copy4f(target, arcball->target); }
void camera_start(void) { MMAL_STATUS_T status; motion_init(); circular_buffer_init(); camera_create(); /* ====== Create the camera preview port path ====== : | preview --(tunnel)--> resizer --> I420_callback --> jpeg_encoder --> mjpeg_callback | (draws on frame) (writes stream mjpeg.jpg) */ pikrellcam.mjpeg_height = pikrellcam.mjpeg_width * pikrellcam.camera_config.video_height / pikrellcam.camera_config.video_width; pikrellcam.mjpeg_width &= ~0xf; /* Make resize multiple of 16 */ pikrellcam.mjpeg_height &= ~0xf; resizer_create("stream_resizer", &stream_resizer, camera.component->output[CAMERA_PREVIEW_PORT], pikrellcam.mjpeg_width, pikrellcam.mjpeg_height); ports_tunnel_connect(&camera, CAMERA_PREVIEW_PORT, &stream_resizer); jpeg_encoder_create("mjpeg_encoder", &mjpeg_encoder, stream_resizer.component->output[0], pikrellcam.mjpeg_quality); ports_callback_connect(&stream_resizer, 0, &mjpeg_encoder, I420_video_callback); out_port_callback(&mjpeg_encoder, 0, mjpeg_callback); /* ====== Create the camera still port path ====== : | camera_capture --(tunnel)--> jpeg_encoder --> still_jpeg__callback | (writes stills and timelapse jpegs) */ jpeg_encoder_create("still_jpeg_encoder", &still_jpeg_encoder, NULL, pikrellcam.camera_adjust.still_quality); ports_tunnel_connect(&camera, CAMERA_CAPTURE_PORT, &still_jpeg_encoder); out_port_callback(&still_jpeg_encoder, 0, still_jpeg_callback); /* ====== Create the camera video port path ====== : | camera_video--(tunnel)-->h264 encoder-->video_h264_encoder_callback | (writes data into video circular buffer) | (records video / checks motion vectors) | (schedules mjpeg.jpg copy into previews) */ h264_encoder_create("video_h264_encoder", &video_h264_encoder, NULL); ports_tunnel_connect(&camera, CAMERA_VIDEO_PORT, &video_h264_encoder); out_port_callback(&video_h264_encoder, 0, video_h264_encoder_callback); time(&pikrellcam.t_start); /* Turn on the video stream. It free runs into the video circular buffer. */ if ((status = mmal_port_parameter_set_boolean( camera.component->output[CAMERA_VIDEO_PORT], MMAL_PARAMETER_CAPTURE, 1)) != MMAL_SUCCESS) log_printf("Video capture startup failed. Status %s\n", mmal_status[status]); /* With everything created and running, set the config'ed camera params. */ mmalcam_config_parameters_set_camera(); display_init(); video_circular_buffer.state = VCB_STATE_NONE; video_circular_buffer.pause = FALSE; }
int main(int argc, char *argv[]) { lapis_init(); engine_t *engine = lapis_get_engine(); set_ticks_per_second(30); game_state_t *state = game_state_create(0); state->num_render_levels = RL_NUM; engine_switch_state(engine, state); /* initialize video */ lsdl_set_video_mode(engine->sdl_driver, WIDTH, HEIGHT, 0, 1); SDL_EnableKeyRepeat(500, 50); SDL_WM_SetCaption( "Open DM v. 0.1", NULL ); glMatrixMode( GL_PROJECTION ); glLoadIdentity( ); gluPerspective(FIELD_OF_VISION, 1, 0.1, 100); // glEnable(GL_TEXTURE_2D); glClearColor( 0.0f, 0.0f, 0.0f, 0.0f ); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_DEPTH_TEST); // glDisable(GL_LIGHTING); // glEnable(GL_LIGHTING); glViewport(0, 0, WIDTH, HEIGHT); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(0,0,0, 0, 0, -10, 0, 1.0, 0); /* test */ /* load graphics */ // lapis_lua_t *lua = lua_scripting_init(); // if( lua_scripting_run_file(lua, "main.lua") != 0 ) // return 0; /* end test */ /* create objects */ game_object_t * global_object = game_object_create("global", NULL); game_state_append_object(state, global_object); game_object_set_recv_callback_c_func(global_object, global_message_handler); game_state_append_bcast_recvr(state, global_object, "sdl-event"); block_t *block = block_create(1, 1); game_state_append_object(state, block->go); camera_t *camera = camera_create(0, 0, 0); game_state_append_object(state, camera->go); lapis_mainloop(); /* this will be cleaned up by the OS */ //game_state_destroy(state); //lapis_deinit(); return 0; }
// Create the appropriate GUI proxy for a given set of device info. void create_proxy(device_t *device, opt_t *opt, mainwnd_t *mainwnd, playerc_client_t *client) { switch (device->addr.interf) { case PLAYER_ACTARRAY_CODE: device->proxy = actarray_create(mainwnd, opt, client, device->addr.index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) actarray_destroy; device->fnupdate = (fnupdate_t) actarray_update; break; case PLAYER_AIO_CODE: device->proxy = aio_create(mainwnd, opt, client, device->addr.index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) aio_destroy; device->fnupdate = (fnupdate_t) aio_update; break; case PLAYER_BUMPER_CODE: device->proxy = bumper_create(mainwnd, opt, client, device->addr.index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) bumper_destroy; device->fnupdate = (fnupdate_t) bumper_update; break; case PLAYER_DIO_CODE: device->proxy = dio_create(mainwnd, opt, client, device->addr.index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) dio_destroy; device->fnupdate = (fnupdate_t) dio_update; break; case PLAYER_IR_CODE: device->proxy = ir_create(mainwnd, opt, client, device->addr.index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) ir_destroy; device->fnupdate = (fnupdate_t) ir_update; break; case PLAYER_LASER_CODE: device->proxy = laser_create(mainwnd, opt, client, device->addr.index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) laser_destroy; device->fnupdate = (fnupdate_t) laser_update; break; case PLAYER_POWER_CODE: device->proxy = power_create(mainwnd, opt, client, device->addr.index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) power_destroy; device->fnupdate = (fnupdate_t) power_update; break; case PLAYER_POSITION2D_CODE: device->proxy = position2d_create(mainwnd, opt, client, device->addr.index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) position2d_destroy; device->fnupdate = (fnupdate_t) position2d_update; break; case PLAYER_PTZ_CODE: device->proxy = ptz_create(mainwnd, opt, client, device->addr.index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) ptz_destroy; device->fnupdate = (fnupdate_t) ptz_update; break; case PLAYER_RANGER_CODE: device->proxy = ranger_create(mainwnd, opt, client, device->addr.index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) ranger_destroy; device->fnupdate = (fnupdate_t) ranger_update; break; case PLAYER_SONAR_CODE: device->proxy = sonar_create(mainwnd, opt, client, device->addr.index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) sonar_destroy; device->fnupdate = (fnupdate_t) sonar_update; break; case PLAYER_WIFI_CODE: device->proxy = wifi_create(mainwnd, opt, client, device->addr.index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) wifi_destroy; device->fnupdate = (fnupdate_t) wifi_update; break; case PLAYER_BLOBFINDER_CODE: device->proxy = blobfinder_create(mainwnd, opt, client, device->addr.index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) blobfinder_destroy; device->fnupdate = (fnupdate_t) blobfinder_update; break; case PLAYER_CAMERA_CODE: device->proxy = camera_create(mainwnd, opt, client, device->addr.index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) camera_destroy; device->fnupdate = (fnupdate_t) camera_update; break; case PLAYER_FIDUCIAL_CODE: device->proxy = fiducial_create(mainwnd, opt, client, device->addr.index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) fiducial_destroy; device->fnupdate = (fnupdate_t) fiducial_update; break; case PLAYER_GRIPPER_CODE: device->proxy = gripper_create(mainwnd, opt, client, device->addr.index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) gripper_destroy; device->fnupdate = (fnupdate_t) gripper_update; break; case PLAYER_MAP_CODE: device->proxy = map_create(mainwnd, opt, client, device->addr.index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) map_destroy; device->fnupdate = (fnupdate_t) map_update; break; case PLAYER_VECTORMAP_CODE: device->proxy = vectormap_create(mainwnd, opt, client, device->addr.index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) vectormap_destroy; device->fnupdate = (fnupdate_t) vectormap_update; break; #if 0 case PLAYER_LOCALIZE_CODE: device->proxy = localize_create(mainwnd, opt, client, device->index, device->drivername, device->subscribe); device->fndestroy = (fndestroy_t) localize_destroy; device->fnupdate = (fnupdate_t) localize_update; break; #endif default: device->proxy = NULL; device->fndestroy = NULL; device->fnupdate = NULL; break; } return; }
int main(int argc, char* argv[]) { // our demo variables World* demoworld = 0; Camera* democamera = 0; Tileset* demotileset = 0; Renderer* demorenderer = 0; // init SDL if (SDL_Init(SDL_INIT_EVERYTHING) < 0) { fprintf(stderr, "SDL Library Initialization Failed!\n\tSDL Error: %s\n", SDL_GetError()); exit(1); } atexit(SDL_Quit); // create the window if (!SDL_SetVideoMode(SCREEN_W, SCREEN_H, SCREEN_BPP, SDL_HWSURFACE | SDL_DOUBLEBUF)) { fprintf(stderr, "SDL Screen Initialization Failed! %dx%d@%dbpp\nSDL Error: %s\n", SCREEN_W, SCREEN_H, SCREEN_BPP, SDL_GetError()); exit(1); } // set the window caption SDL_WM_SetCaption("Basic SDL Map Editor Example Demo -- by Richard Marks <*****@*****.**>", 0); // create our keyboard handler Keyboard* keyboard = keyboard_create(); // load the world demoworld = world_load("example_demo.map"); if (!demoworld) { fprintf(stderr, "unable to load the world file!\n"); exit(1); } // load the tileset demotileset = tileset_load("example_demo.png", 32, 32); if (!demotileset) { fprintf(stderr, "unable to load the tileset file!\n"); exit(1); } // create the camera democamera = camera_create( // anchor position of the camera is at 32,32 on the screen 32, 32, // the camera view is 30 x 22 tiles 30, 22, // need to tell the camera the size of the tiles demotileset->width, demotileset->height); // create the renderer demorenderer = renderer_create(demoworld, demotileset, democamera); // pre-render the scene renderer_pre_render(demorenderer); fprintf(stderr, "\nstarting main loop...\n\n"); // start the main loop SDL_Event event; bool running = true; int startticks = SDL_GetTicks(); int mainlooptimer = SDL_GetTicks(); while(running) { // check for our window being closed while(SDL_PollEvent(&event)) { if (SDL_QUIT == event.type) { running = false; } } // update our keyboard handler keyboard_update(keyboard); // start timing our code startticks = SDL_GetTicks(); // check for our controls // ESC and Q quits if (keyboard->key[SDLK_ESCAPE] || keyboard->key[SDLK_q]) { running = false; } const unsigned int CAMERASPEED = 16; // W and up arrow if (keyboard->key[SDLK_w] || keyboard->key[SDLK_UP]) { if (democamera->inpixels->y > 0) { democamera->inpixels->y -= CAMERASPEED; } } // S and down arrow if (keyboard->key[SDLK_s] || keyboard->key[SDLK_DOWN]) { if (democamera->inpixels->y < demorenderer->scene->h - democamera->inpixels->h) { democamera->inpixels->y += CAMERASPEED; } } // A and left arrow if (keyboard->key[SDLK_a] || keyboard->key[SDLK_LEFT]) { if (democamera->inpixels->x > 0) { democamera->inpixels->x -= CAMERASPEED; } } // D and right arrow if (keyboard->key[SDLK_d] || keyboard->key[SDLK_RIGHT]) { if (democamera->inpixels->x < demorenderer->scene->w - democamera->inpixels->w) { democamera->inpixels->x += CAMERASPEED; } } // render our scene renderer_render(demorenderer); // flip our double buffer SDL_Flip(SDL_GetVideoSurface()); // lock our framerate to roughly 30 FPS int tickdiff = SDL_GetTicks() - startticks; if (tickdiff < 33) { SDL_Delay(33 - tickdiff); } } int tickdiff = SDL_GetTicks() - mainlooptimer; fprintf(stderr, "finished after %d ticks!\n\n", tickdiff); // destroy our pointers tileset_destroy(demotileset); renderer_destroy(demorenderer); world_destroy(demoworld); camera_destroy(democamera); keyboard_destroy(keyboard); return 0; }