void DpadRestrictorModifier::update(int msec_delta, XboxGenericMsg& msg) { switch(m_mode) { case kRestrictFourWay: if (get_axis(msg, XBOX_AXIS_DPAD_X) && get_axis(msg, XBOX_AXIS_DPAD_Y)) { // a diagonal was pressed, thus we reset the axis that wasn't // pressed the last time the dpad was touched set_axis(msg, m_last_unpressed_axis, 0); } else if (get_axis(msg, XBOX_AXIS_DPAD_X)) { m_last_unpressed_axis = XBOX_AXIS_DPAD_Y; } else if (get_axis(msg, XBOX_AXIS_DPAD_Y)) { m_last_unpressed_axis = XBOX_AXIS_DPAD_X; } break; case kRestrictXAxis: set_axis(msg, XBOX_AXIS_DPAD_Y, 0); break; case kRestrictYAxis: set_axis(msg, XBOX_AXIS_DPAD_X, 0); break; } }
void UInputMessageProcessor::send(const XboxGenericMsg& msg_in, int msec_delta) { if (!m_config->empty()) { XboxGenericMsg msg = msg_in; if (m_rumble_test) { log_debug("rumble: " << get_axis(msg, XBOX_AXIS_LT) << " " << get_axis(msg, XBOX_AXIS_RT)); set_rumble(get_axis(msg, XBOX_AXIS_LT), get_axis(msg, XBOX_AXIS_RT)); } // handling switching of configurations if (m_config_toggle_button != XBOX_BTN_UNKNOWN) { bool last = get_button(m_oldmsg, m_config_toggle_button); bool cur = get_button(msg, m_config_toggle_button); if (cur && cur != last) { // reset old mapping to zero to not get stuck keys/axis m_config->get_config()->get_uinput().reset_all_outputs(); // switch to the next input mapping m_config->next_config(); log_info("switched to config: " << m_config->get_current_config()); } } // run the controller message through all modifier for(std::vector<ModifierPtr>::iterator i = m_config->get_config()->get_modifier().begin(); i != m_config->get_config()->get_modifier().end(); ++i) { (*i)->update(msec_delta, msg); } m_config->get_config()->get_uinput().update(msec_delta); // send current Xbox state to uinput if (memcmp(&msg, &m_oldmsg, sizeof(XboxGenericMsg)) != 0) { // Only send a new event out if something has changed, // this is useful since some controllers send events // even if nothing has changed, deadzone can cause this // too m_oldmsg = msg; m_config->get_config()->get_uinput().send(msg); } } }
void FourWayRestrictorModifier::update(int msec_delta, XboxGenericMsg& msg) { // left Stick if (abs(get_axis(msg, XBOX_AXIS_X1)) > abs(get_axis(msg, XBOX_AXIS_Y1))) { set_axis(msg, XBOX_AXIS_Y1, 0); } else if (abs(get_axis(msg, XBOX_AXIS_Y1)) > abs(get_axis(msg, XBOX_AXIS_X1))) { set_axis(msg, XBOX_AXIS_X1, 0); } else { set_axis(msg, XBOX_AXIS_X1, 0); } // right stick if (abs(get_axis(msg, XBOX_AXIS_X2)) > abs(get_axis(msg, XBOX_AXIS_Y2))) { set_axis(msg, XBOX_AXIS_Y2, 0); } else if (abs(get_axis(msg, XBOX_AXIS_Y2)) > abs(get_axis(msg, XBOX_AXIS_X2))) { set_axis(msg, XBOX_AXIS_X2, 0); } else { set_axis(msg, XBOX_AXIS_X2, 0); } }
static int set_display_axis(int recovery) { int fd; char *path = "/sys/class/display/axis"; char str[128]; int count, i; fd = open(path, O_CREAT|O_RDWR | O_TRUNC, 0644); if (fd >= 0) { if (!recovery) { read(fd, str, 128); printf("read axis %s, length %d\n", str, strlen(str)); count = get_axis(str, 8, axis); } if (recovery) { sprintf(str, "0 %d %d %d %d %d %d %d", axis[0],axis[1], axis[2], axis[3], axis[4], axis[5], axis[6], axis[7]); } else { sprintf(str, "2048 %d %d %d %d %d %d %d", axis[1], axis[2], axis[3], axis[4], axis[5], axis[6], axis[7]); } write(fd, str, strlen(str)); close(fd); return 0; } return -1; }
void quat::set_angle(float f) { vec3 axis = get_axis(); s = (float) cos( DEG2RAD( f ) / 2.0 ); v = axis * (float) sin(DEG2RAD(f) / 2.0); }
void Matrix3::orthonormalize() { // Gram-Schmidt Process Vector3 x=get_axis(0); Vector3 y=get_axis(1); Vector3 z=get_axis(2); x.normalize(); y = (y-x*(x.dot(y))); y.normalize(); z = (z-x*(x.dot(z))-y*(y.dot(z))); z.normalize(); set_axis(0,x); set_axis(1,y); set_axis(2,z); }
void Basis::orthonormalize() { ERR_FAIL_COND(determinant() == 0); // Gram-Schmidt Process Vector3 x=get_axis(0); Vector3 y=get_axis(1); Vector3 z=get_axis(2); x.normalize(); y = (y-x*(x.dot(y))); y.normalize(); z = (z-x*(x.dot(z))-y*(y.dot(z))); z.normalize(); set_axis(0,x); set_axis(1,y); set_axis(2,z); }
/* This is the entry-point for the game! */ void c_start(void) { /* TODO: You will need to initialize various subsystems here. This * would include the interrupt handling mechanism, and the various * systems that use interrupts. Once this is done, you can call * enable_interrupts() to start interrupt handling, and go on to * do whatever else you decide to do! */ seed_rand_with_time(); init_interrupts(); init_keyboard(); init_timer(); enable_interrupts(); int board[BOARD_SIZE][BOARD_SIZE] = { }; animation_descriptor descriptor = { }; initialize(board); int high_score = current_score(board); init_video(high_score); draw_board(board); /* Loop forever, so that we don't fall back into the bootloader code. */ while (1) { if (!isemptyqueue()) { key k = dequeue(); if (k == enter_key) { for (int *b = *board; b < *board + BOARD_SIZE * BOARD_SIZE; b++) *b = 0; initialize(board); init_video(high_score); draw_board(board); continue; } else { shift_direction direction = key_to_direction(k); // Setup animation copy_board(board, descriptor.board); descriptor.direction = direction; // Only add a box if the pieces actually move if (shift(board, direction, descriptor.offsets)) { add_random_box(board); int score = current_score(board); if (score > high_score) high_score = score; init_video(high_score); } } int num_frames = frame_count(descriptor.direction); int incr = get_axis(descriptor.direction) == horizontal_axis ? 12 : 2; int frame = 0; while (frame <= num_frames) { draw_board_frame(descriptor, frame); sleep(30); if (frame == num_frames) break; else frame = min(frame + incr, num_frames); } draw_board(board); if (!move_available(board)) { draw_failure_message(); } } } }
void AnimatedSprite3D::_draw() { RID immediate = get_immediate(); VS::get_singleton()->immediate_clear(immediate); if (!frames.is_valid() || !frames->get_frame_count(animation) || frame<0 || frame>=frames->get_frame_count(animation)) { return; } Ref<Texture> texture = frames->get_frame(animation,frame); if (!texture.is_valid()) return; //no texuture no life Vector2 tsize = texture->get_size(); if (tsize.x==0 || tsize.y==0) return; Size2i s=tsize; Rect2i src_rect; src_rect.size=s; Point2i ofs=get_offset(); if (is_centered()) ofs-=s/2; Rect2i dst_rect(ofs,s); Rect2 final_rect; Rect2 final_src_rect; if (!texture->get_rect_region(dst_rect,src_rect,final_rect,final_src_rect)) return; if (final_rect.size.x==0 || final_rect.size.y==0) return; Color color=_get_color_accum(); color.a*=get_opacity(); float pixel_size=get_pixel_size(); Vector2 vertices[4]={ (final_rect.pos+Vector2(0,final_rect.size.y)) * pixel_size, (final_rect.pos+final_rect.size) * pixel_size, (final_rect.pos+Vector2(final_rect.size.x,0)) * pixel_size, final_rect.pos * pixel_size, }; Vector2 uvs[4]={ final_src_rect.pos / tsize, (final_src_rect.pos+Vector2(final_src_rect.size.x,0)) / tsize, (final_src_rect.pos+final_src_rect.size) / tsize, (final_src_rect.pos+Vector2(0,final_src_rect.size.y)) / tsize, }; if (is_flipped_h()) { SWAP(uvs[0],uvs[1]); SWAP(uvs[2],uvs[3]); } if (is_flipped_v()) { SWAP(uvs[0],uvs[3]); SWAP(uvs[1],uvs[2]); } Vector3 normal; int axis = get_axis(); normal[axis]=1.0; RID mat = VS::get_singleton()->material_2d_get(get_draw_flag(FLAG_SHADED),get_draw_flag(FLAG_TRANSPARENT),get_alpha_cut_mode()==ALPHA_CUT_DISCARD,get_alpha_cut_mode()==ALPHA_CUT_OPAQUE_PREPASS); VS::get_singleton()->immediate_set_material(immediate,mat); VS::get_singleton()->immediate_begin(immediate,VS::PRIMITIVE_TRIANGLE_FAN,texture->get_rid()); int x_axis = ((axis + 1) % 3); int y_axis = ((axis + 2) % 3); if (axis!=Vector3::AXIS_Z) { SWAP(x_axis,y_axis); for(int i=0;i<4;i++) { //uvs[i] = Vector2(1.0,1.0)-uvs[i]; //SWAP(vertices[i].x,vertices[i].y); if (axis==Vector3::AXIS_Y) { vertices[i].y = - vertices[i].y; } else if (axis==Vector3::AXIS_X) { vertices[i].x = - vertices[i].x; } } } AABB aabb; for(int i=0;i<4;i++) { VS::get_singleton()->immediate_normal(immediate,normal); VS::get_singleton()->immediate_color(immediate,color); VS::get_singleton()->immediate_uv(immediate,uvs[i]); Vector3 vtx; vtx[x_axis]=vertices[i][0]; vtx[y_axis]=vertices[i][1]; VS::get_singleton()->immediate_vertex(immediate,vtx); if (i==0) { aabb.pos=vtx; aabb.size=Vector3(); } else { aabb.expand_to(vtx); } } set_aabb(aabb); VS::get_singleton()->immediate_end(immediate); }
int amvideo_utils_set_virtual_position(int32_t x, int32_t y, int32_t w, int32_t h, int rotation) { LOG_FUNCTION_NAME //for osd rotation, need convert the axis first int osd_rotation = amdisplay_utils_get_osd_rotation(); if(osd_rotation > 0) amvideo_convert_axis(&x,&y,&w,&h,&rotation,osd_rotation); int video_fd; int dev_fd = -1, dev_w, dev_h, disp_w, disp_h, video_global_offset; int dst_x, dst_y, dst_w, dst_h; char buf[SYSCMD_BUFSIZE]; int angle_fd = -1; int ret = -1; int axis[4]; char enable_p2p_play[8] = {0}; int video_on_vpp2 = is_video_on_vpp2(); int vertical_panel = is_vertical_panel(); int vertical_panel_reverse = is_vertical_panel_reverse(); if (video_on_vpp2) { int fb0_w, fb0_h, fb2_w, fb2_h; amdisplay_utils_get_size(&fb0_w, &fb0_h); amdisplay_utils_get_size_fb2(&fb2_w, &fb2_h); if (fb0_w > 0 && fb0_h > 0 && fb2_w > 0 && fb2_h > 0) { if (vertical_panel) { int x1, y1, w1, h1; if (vertical_panel_reverse) { x1 = (1.0 * fb2_w / fb0_h) * y; y1 = (1.0 * fb2_h / fb0_w) * x; w1 = (1.0 * fb2_w / fb0_h) * h; h1 = (1.0 * fb2_h / fb0_w) * w; } else { x1 = (1.0 * fb2_w / fb0_h) * y; y1 = (1.0 * fb2_h / fb0_w) * (fb0_w - x - w); w1 = (1.0 * fb2_w / fb0_h) * h; h1 = (1.0 * fb2_h / fb0_w) * w; } x = x1; y = y1; w = w1; h = h1; } else { int x1, y1, w1, h1; x1 = (1.0 * fb2_w / fb0_w) * x; y1 = (1.0 * fb2_h / fb0_h) * y; w1 = (1.0 * fb2_w / fb0_w) * w; h1 = (1.0 * fb2_h / fb0_h) * h; x = x1; y = y1; w = w1; h = h1; } } } LOGI("amvideo_utils_set_virtual_position:: x=%d y=%d w=%d h=%d\n", x, y, w, h); bzero(buf, SYSCMD_BUFSIZE); dst_x = x; dst_y = y; dst_w = w; dst_h = h; video_fd = open(VIDEO_PATH, O_RDWR); if (video_fd < 0) { goto OUT; } dev_fd = open(DISP_DEVICE_PATH, O_RDONLY); if (dev_fd < 0) { goto OUT; } read(dev_fd, buf, SYSCMD_BUFSIZE); if (sscanf(buf, "%dx%d", &dev_w, &dev_h) == 2) { LOGI("device resolution %dx%d\n", dev_w, dev_h); } else { ret = -2; goto OUT; } if (video_on_vpp2) amdisplay_utils_get_size_fb2(&disp_w, &disp_h); else amdisplay_utils_get_size(&disp_w, &disp_h); LOGI("amvideo_utils_set_virtual_position:: disp_w=%d, disp_h=%d\n", disp_w, disp_h); video_global_offset = amvideo_utils_get_global_offset(); int free_scale_enable = 0; int ppscaler_enable = 0; int freescale_mode_enable = 0; if (((disp_w != dev_w) || (disp_h / 2 != dev_h)) && (video_global_offset == 0)) { char val[256]; memset(val, 0, sizeof(val)); if (video_on_vpp2) { if (amsysfs_get_sysfs_str(FREE_SCALE_PATH_FB2, val, sizeof(val)) == 0) { /* the returned string should be "free_scale_enable:[0x%x]" */ free_scale_enable = (val[21] == '0') ? 0 : 1; } } else { if (amsysfs_get_sysfs_str(FREE_SCALE_PATH, val, sizeof(val)) == 0) { /* the returned string should be "free_scale_enable:[0x%x]" */ free_scale_enable = (val[21] == '0') ? 0 : 1; } } memset(val, 0, sizeof(val)); if (amsysfs_get_sysfs_str(PPSCALER_PATH, val, sizeof(val)) == 0) { /* the returned string should be "current ppscaler mode is disabled/enable" */ ppscaler_enable = (val[25] == 'd') ? 0 : 1; } memset(val, 0, sizeof(val)); if (amsysfs_get_sysfs_str(FREE_SCALE_MODE_PATH, val, sizeof(val)) == 0) { /* the returned string should be "free_scale_mode:new/default" */ freescale_mode_enable = (val[16] == 'd') ? 0 : 1; } } angle_fd = open(ANGLE_PATH, O_WRONLY); if (angle_fd >= 0) { if (video_on_vpp2 && vertical_panel) ioctl(angle_fd, PPMGR_IOC_SET_ANGLE, 0); else ioctl(angle_fd, PPMGR_IOC_SET_ANGLE, (rotation/90) & 3); LOGI("set ppmgr angle %d\n", (rotation/90) & 3); } /* this is unlikely and only be used when ppmgr does not exist * to support video rotation. If that happens, we convert the window * position to non-rotated window position. * On ICS, this might not work at all because the transparent UI * window is still drawn is it's direction, just comment out this for now. */ #if 0 if (((rotation == 90) || (rotation == 270)) && (angle_fd < 0)) { if (dst_h == disp_h) { int center = x + w / 2; if (abs(center - disp_w / 2) < 2) { /* a centered overlay with rotation, change to full screen */ dst_x = 0; dst_y = 0; dst_w = dev_w; dst_h = dev_h; LOGI("centered overlay expansion"); } } } #endif /*if (free_scale_enable == 0 && ppscaler_enable == 0) { OSD_DISP_MODE display_mode = OSD_DISP_1080P; int x_d=0,y_d=0,w_d=0,h_d=0; LOGI("set screen position:x[%d],y[%d],w[%d],h[%d]", dst_x, dst_y, dst_w, dst_h); display_mode = get_osd_display_mode(); get_device_win(display_mode, &x_d, &y_d, &w_d, &h_d); if(display_mode==OSD_DISP_720P) { if((dst_w >= 1279)||(dst_w==0)) { dst_x = x_d; dst_y = y_d; dst_w = w_d; dst_h = h_d; } else { dst_x = dst_x*w_d/1280+x_d; dst_y = dst_y*h_d/720+y_d; dst_w = dst_w*w_d/1280; dst_h = dst_h*h_d/720; } } else if((display_mode==OSD_DISP_1080I)||(display_mode==OSD_DISP_1080P)||(display_mode==OSD_DISP_LVDS1080P)) { if((dst_w >= 1919)||(dst_w == 0)) { dst_x = x_d; dst_y = y_d; dst_w = w_d; dst_h = h_d; } else {//scaled to 1080p dst_x = dst_x*w_d/1920+x_d; dst_y = dst_y*h_d/1080+y_d; dst_w = dst_w*w_d/1920; dst_h = dst_h*h_d/1080; LOGI("after scaled to 1080 ,set screen position:x[%d],y[%d],w[%d],h[%d]", dst_x, dst_y, dst_w, dst_h); } } else if((display_mode==OSD_DISP_480I)||(display_mode==OSD_DISP_480P)) { if((dst_w >= 719)||(dst_w == 0)) { dst_x = x_d; dst_y = y_d; dst_w = w_d; dst_h = h_d; } else {//scaled to 480p/480i dst_x = dst_x*w_d/720+x_d; dst_y = dst_y*h_d/480+y_d; dst_w = dst_w*w_d/720; dst_h = dst_h*h_d/480; LOGI("after scaled to 480,set screen position:x[%d],y[%d],w[%d],h[%d]", dst_x, dst_y, dst_w, dst_h); } } else if((display_mode==OSD_DISP_576I)||(display_mode==OSD_DISP_576P)) { if((dst_w >= 719)||(dst_w == 0)) { dst_x = x_d; dst_y = y_d; dst_w = w_d; dst_h = h_d; } else {//scaled to 576p/576i dst_x = dst_x*w_d/720+x_d; dst_y = dst_y*h_d/576+y_d; dst_w = dst_w*w_d/720; dst_h = dst_h*h_d/576; LOGI("after scaled to 576 ,set screen position:x[%d],y[%d],w[%d],h[%d]", dst_x, dst_y, dst_w, dst_h); } } }*/ if (free_scale_enable == 0 && ppscaler_enable == 0) { char val[256]; if (freescale_mode_enable == 1) { int left = 0, top = 0, right = 0, bottom = 0; int x = 0, y = 0, w = 0, h = 0; memset(val, 0, sizeof(val)); if (amsysfs_get_sysfs_str(WINDOW_AXIS_PATH, val, sizeof(val)) == 0) { /* the returned string should be "window axis is [a b c d]" */ if (sscanf(val + 15, "[%d %d %d %d]", &left, &top, &right, &bottom) == 4) { x = left; y = top; w = right - left + 1; h = bottom - top + 1; if ((dst_w >= dev_w - 1) || (dst_w == 0)) { dst_x = 0; dst_w = w; } if ((dst_h >= dev_h - 1) || (dst_h == 0)) { dst_y = 0; dst_h = h; } dst_x = dst_x * w / dev_w + x; dst_y = dst_y * h / dev_h + y; LOGI("after scaled, screen position: %d %d %d %d", dst_x, dst_y, dst_w, dst_h); } } } else { int x = 0, y = 0, w = 0, h = 0; int fb_w = 0, fb_h = 0; int req_2xscale = 0; memset(val, 0, sizeof(val)); if (amsysfs_get_sysfs_str(REQUEST_2XSCALE_PATH, val, sizeof(val)) == 0) { /* the returned string should be "a b c" */ if (sscanf(val, "%d", &req_2xscale) == 1) { if (req_2xscale == 7 || req_2xscale == 16) { if (sscanf(val, "%d %d %d", &req_2xscale, &w, &h) == 3) { if (req_2xscale == 7) w *= 2; get_axis(DISPLAY_AXIS_PATH, &x, &y, &fb_w, &fb_h); if (fb_w == 0 || fb_h == 0) { fb_w = 1280; fb_h = 720; } set_scale(x, y, w, h, &dst_x, &dst_y, &dst_w, &dst_h, fb_w, fb_h); LOGI("after scaled, screen position: %d %d %d %d", dst_x, dst_y, dst_w, dst_h); } } } } } } else if (free_scale_enable == 1 && ppscaler_enable == 0) { char val[256]; int left = 0, top = 0, right = 0, bottom = 0; int x = 0, y = 0, w = 0, h = 0; int freescale_x = 0, freescale_y = 0, freescale_w = 0, freescale_h = 0; if (amsysfs_get_sysfs_str(WINDOW_AXIS_PATH, val, sizeof(val)) == 0) { /* the returned string should be "window axis is [a b c d]" */ if (sscanf(val + 15, "[%d %d %d %d]", &left, &top, &right, &bottom) == 4) { x = left; y = top; w = right - left + 1; h = bottom - top + 1; get_axis(FREE_SCALE_AXIS_PATH, &freescale_x, &freescale_y, &freescale_w, &freescale_h); freescale_w = (freescale_w + 1) & (~1); freescale_h = (freescale_h + 1) & (~1); set_scale(x, y, w, h, &dst_x, &dst_y, &dst_w, &dst_h, freescale_w, freescale_h); LOGI("after scaled, screen position: %d %d %d %d", dst_x, dst_y, dst_w, dst_h); } } } axis[0] = dst_x; axis[1] = dst_y; axis[2] = dst_x + dst_w - 1; axis[3] = dst_y + dst_h - 1; ioctl(video_fd, AMSTREAM_IOC_SET_VIDEO_AXIS, &axis[0]); ret = 0; OUT: if (video_fd >= 0) { close(video_fd); } if (dev_fd >= 0) { close(dev_fd); } if (angle_fd >= 0) { close(angle_fd); } LOGI("amvideo_utils_set_virtual_position (corrected):: x=%d y=%d w=%d h=%d\n", dst_x, dst_y, dst_w, dst_h); return ret; }
void Sprite3D::_draw() { RID immediate = get_immediate(); VS::get_singleton()->immediate_clear(immediate); if (!texture.is_valid()) return; //no texuture no life Vector2 tsize = texture->get_size(); if (tsize.x==0 || tsize.y==0) return; Size2i s; Rect2i src_rect; if (region) { s=region_rect.size; src_rect=region_rect; } else { s = texture->get_size(); s=s/Size2i(hframes,vframes); src_rect.size=s; src_rect.pos.x+=(frame%hframes)*s.x; src_rect.pos.y+=(frame/hframes)*s.y; } Point2i ofs=get_offset(); if (is_centered()) ofs-=s/2; Rect2i dst_rect(ofs,s); Rect2 final_rect; Rect2 final_src_rect; if (!texture->get_rect_region(dst_rect,src_rect,final_rect,final_src_rect)) return; if (final_rect.size.x==0 || final_rect.size.y==0) return; Color color=_get_color_accum(); color.a*=get_opacity(); float pixel_size=get_pixel_size(); Vector2 vertices[4]={ (final_rect.pos+Vector2(0,final_rect.size.y)) * pixel_size, (final_rect.pos+final_rect.size) * pixel_size, (final_rect.pos+Vector2(final_rect.size.x,0)) * pixel_size, final_rect.pos * pixel_size, }; Vector2 uvs[4]={ final_src_rect.pos / tsize, (final_src_rect.pos+Vector2(final_src_rect.size.x,0)) / tsize, (final_src_rect.pos+final_src_rect.size) / tsize, (final_src_rect.pos+Vector2(0,final_src_rect.size.y)) / tsize, }; if (is_flipped_h()) { SWAP(uvs[0],uvs[1]); SWAP(uvs[2],uvs[3]); } if (is_flipped_v()) { SWAP(uvs[0],uvs[3]); SWAP(uvs[1],uvs[2]); } Vector3 normal; int axis = get_axis(); normal[axis]=1.0; RID mat = VS::get_singleton()->material_2d_get(get_draw_flag(FLAG_SHADED),get_draw_flag(FLAG_TRANSPARENT),get_alpha_cut_mode()==ALPHA_CUT_DISCARD,get_alpha_cut_mode()==ALPHA_CUT_OPAQUE_PREPASS); VS::get_singleton()->immediate_set_material(immediate,mat); VS::get_singleton()->immediate_begin(immediate,VS::PRIMITIVE_TRIANGLE_FAN,texture->get_rid()); int x_axis = ((axis + 1) % 3); int y_axis = ((axis + 2) % 3); AABB aabb; for(int i=0;i<4;i++) { VS::get_singleton()->immediate_normal(immediate,normal); VS::get_singleton()->immediate_color(immediate,color); VS::get_singleton()->immediate_uv(immediate,uvs[i]); Vector3 vtx; vtx[x_axis]=vertices[i][x_axis]; vtx[y_axis]=vertices[i][y_axis]; VS::get_singleton()->immediate_vertex(immediate,vtx); if (i==0) { aabb.pos=vtx; aabb.size=Vector3(); } else { aabb.expand_to(vtx); } } set_aabb(aabb); VS::get_singleton()->immediate_end(immediate); }
void Sprite3D::_draw() { RID immediate = get_immediate(); VS::get_singleton()->immediate_clear(immediate); if (!texture.is_valid()) return; //no texuture no life Vector2 tsize = texture->get_size(); if (tsize.x == 0 || tsize.y == 0) return; Size2i s; Rect2i src_rect; if (region) { s = region_rect.size; src_rect = region_rect; } else { s = texture->get_size(); s = s / Size2i(hframes, vframes); src_rect.size = s; src_rect.position.x += (frame % hframes) * s.x; src_rect.position.y += (frame / hframes) * s.y; } Point2i ofs = get_offset(); if (is_centered()) ofs -= s / 2; Rect2i dst_rect(ofs, s); Rect2 final_rect; Rect2 final_src_rect; if (!texture->get_rect_region(dst_rect, src_rect, final_rect, final_src_rect)) return; if (final_rect.size.x == 0 || final_rect.size.y == 0) return; Color color = _get_color_accum(); color.a *= get_opacity(); float pixel_size = get_pixel_size(); Vector2 vertices[4] = { (final_rect.position + Vector2(0, final_rect.size.y)) * pixel_size, (final_rect.position + final_rect.size) * pixel_size, (final_rect.position + Vector2(final_rect.size.x, 0)) * pixel_size, final_rect.position * pixel_size, }; Vector2 src_tsize = tsize; // Properly setup UVs for impostor textures (AtlasTexture). Ref<AtlasTexture> atlas_tex = texture; if (atlas_tex != NULL) { src_tsize[0] = atlas_tex->get_atlas()->get_width(); src_tsize[1] = atlas_tex->get_atlas()->get_height(); } Vector2 uvs[4] = { final_src_rect.position / src_tsize, (final_src_rect.position + Vector2(final_src_rect.size.x, 0)) / src_tsize, (final_src_rect.position + final_src_rect.size) / src_tsize, (final_src_rect.position + Vector2(0, final_src_rect.size.y)) / src_tsize, }; if (is_flipped_h()) { SWAP(uvs[0], uvs[1]); SWAP(uvs[2], uvs[3]); } if (is_flipped_v()) { SWAP(uvs[0], uvs[3]); SWAP(uvs[1], uvs[2]); } Vector3 normal; int axis = get_axis(); normal[axis] = 1.0; RID mat = SpatialMaterial::get_material_rid_for_2d(get_draw_flag(FLAG_SHADED), get_draw_flag(FLAG_TRANSPARENT), get_draw_flag(FLAG_DOUBLE_SIDED), get_alpha_cut_mode() == ALPHA_CUT_DISCARD, get_alpha_cut_mode() == ALPHA_CUT_OPAQUE_PREPASS); VS::get_singleton()->immediate_set_material(immediate, mat); VS::get_singleton()->immediate_begin(immediate, VS::PRIMITIVE_TRIANGLE_FAN, texture->get_rid()); int x_axis = ((axis + 1) % 3); int y_axis = ((axis + 2) % 3); if (axis != Vector3::AXIS_Z) { SWAP(x_axis, y_axis); for (int i = 0; i < 4; i++) { //uvs[i] = Vector2(1.0,1.0)-uvs[i]; //SWAP(vertices[i].x,vertices[i].y); if (axis == Vector3::AXIS_Y) { vertices[i].y = -vertices[i].y; } else if (axis == Vector3::AXIS_X) { vertices[i].x = -vertices[i].x; } } } AABB aabb; for (int i = 0; i < 4; i++) { VS::get_singleton()->immediate_normal(immediate, normal); VS::get_singleton()->immediate_color(immediate, color); VS::get_singleton()->immediate_uv(immediate, uvs[i]); Vector3 vtx; vtx[x_axis] = vertices[i][0]; vtx[y_axis] = vertices[i][1]; VS::get_singleton()->immediate_vertex(immediate, vtx); if (i == 0) { aabb.position = vtx; aabb.size = Vector3(); } else { aabb.expand_to(vtx); } } set_aabb(aabb); VS::get_singleton()->immediate_end(immediate); }
static int get_data(gboolean read_data_only, char *filename, char *datachannel_name, double *data[], int *dimensions[], char **unit, G_GNUC_UNUSED gboolean *scattered) { dataFormat format = UNKNOWN_DATAFORMAT; codingTypes coding = UNKNOWN_CODING; byteOrder byte_order = UNKNOWN_BYTEORDER; int ret, i; int state = 0; GArray *axes, *names, *units, *axis; const xmlChar *name, *value, *read_method_name; xmlChar *id; xmlTextReaderPtr reader; int data_dimension = -1; int out_len; int max_input_len = 1; gwy_debug("read only: %d, channel name==%s", read_data_only, datachannel_name); *dimensions = NULL; reader = xmlReaderForFile(filename, NULL, 0); if (reader != NULL) { ret = xmlTextReaderRead(reader); while (ret == 1) { /* process node */ name = xmlTextReaderConstName(reader); if (name == NULL) { /* no datachannels */ return -1; } if (state == 0 && xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT && strcmp(name, "DataChannel") == 0) { id = xmlTextReaderGetAttribute(reader, "name"); if (id && strcmp(id, datachannel_name) == 0) { format = get_data_format(xmlTextReaderGetAttribute (reader, "dataFormat")); coding = get_data_coding(xmlTextReaderGetAttribute (reader, "coding")); byte_order = get_byteorder(xmlTextReaderGetAttribute (reader, "byteOrder")); if (read_data_only == FALSE) { /* when read_data_only is true, we skip dimensions array to prevent infinite cycle when calling from get_axis to get non equidistant axis from datachannel */ read_method_name = xmlTextReaderGetAttribute(reader, "channelReadMethodName"); if (read_method_name == NULL) { /* sequence of one dimensional values */ *dimensions = NULL; } else { g_free((char *)read_method_name); /* get axes */ data_dimension = get_axis(filename, datachannel_name, &axes, &names, &units); if (data_dimension != 2) { g_warning ("SPML: get_data(): Input data are in %d dimension(s).", data_dimension); } /* one dimension array */ if (data_dimension > 0) { *dimensions = g_malloc(sizeof(int) * data_dimension); for (i = 0; i < data_dimension; i++) { axis = g_array_index(axes, GArray *, i); (*dimensions)[i] = axis[0].len; max_input_len *= axis[0].len; } } else { *dimensions = NULL; } /* free what get_axis allocated */ if (axes) { for (i = 0; i < axes->len; i++) { g_array_free(g_array_index (axes, GArray *, i), TRUE); } g_array_free(axes, TRUE); } if (names) g_array_free(names, TRUE); if (units) g_array_free(units, TRUE); }