// if colornum==-1, create new color int GFX_MakeRandomCustomColor(int colornum){ static int num_colors = first_custom_colornum; if (colornum==-1) colornum = num_colors++; custom_colors[colornum] = mix_colors(QColor(qrand()%255,qrand()%255,qrand()%255), get_qcolor(HIGH_EDITOR_BACKGROUND_COLOR_NUM), 0.10f); return colornum; }
// if colornum==-1, create new color int GFX_MakeRandomCustomColor(struct Tracker_Windows *tvisual, int colornum){ static int num_colors = first_custom_colornum; if (colornum==-1) colornum = num_colors++; EditorWidget *editor=(EditorWidget *)tvisual->os_visual.widget; custom_colors[colornum] = mix_colors(QColor(qrand()%255,qrand()%255,qrand()%255), editor->colors[15], 0.10f); return colornum; }
static void configure_note_colors(void){ for(int i=0;i<NUM_NOTE_COLOR_CONF;i++){ QColor start_color = get_custom_qcolor(note_color_conf[i][1]); QColor end_color = get_custom_qcolor(note_color_conf[i+1][1]); int start_note = note_color_conf[i][0]; int end_note = note_color_conf[i+1][0]; if(start_note<64) start_color = get_qcolor(TEXT_COLOR_NUM); else end_color = get_qcolor(WAVEFORM_COLOR_NUM); for(int note=start_note;note<end_note;note++){ //printf("setting %d (%d-%d) to %d %d %f\n",note,start_note,end_note,note_color_conf[i][1], note_color_conf[i+1][1], (float)(note-start_note)/(end_note-start_note)); g_note_colors[note] = mix_colors(end_color, start_color, (float)(note-start_note)/(end_note-start_note)); } } }
static void configure_note_colors(EditorWidget *editor){ for(int i=0;i<NUM_NOTE_COLOR_CONF;i++){ QColor start_color = editor->colors[note_color_conf[i][1]]; QColor end_color = editor->colors[note_color_conf[i+1][1]]; int start_note = note_color_conf[i][0]; int end_note = note_color_conf[i+1][0]; if(start_note<64) start_color = editor->colors[1]; else end_color = editor->colors[2]; for(int note=start_note;note<end_note;note++){ //printf("setting %d (%d-%d) to %d %d %f\n",note,start_note,end_note,note_color_conf[i][1], note_color_conf[i+1][1], (float)(note-start_note)/(end_note-start_note)); g_note_colors[note] = mix_colors(end_color, start_color, (float)(note-start_note)/(end_note-start_note)); } } }
void ProcessController::DefaultColors() { swap_color.red = 203; swap_color.green = 0; swap_color.blue = 0; swap_color.alpha = 255; bool set = false; if (!set) { active_color = kKernelBlue; active_color = tint_color (active_color, B_LIGHTEN_2_TINT); idle_color = active_color; idle_color.green /= 3; idle_color.red /= 3; idle_color.blue /= 3; frame_color = kBlack; mix_colors (memory_color, active_color, swap_color, 0.2); } }
/* * op == 0 - draw * op < 0 - redraw * op > 0 - reset */ static void draw_wild_menu(int op) { static int last_pos; const char ** list = get_completion_list(); int pos = get_completion_pos(); int count = get_completion_count() - 1; int i; int len = getmaxx(stdscr); if(sub_mode == MENU_CMD_SUBMODE || input_stat.complete == NULL) return; if(count < 2) return; if(op > 0) { last_pos = 0; return; } if(pos == 0 || pos == count) last_pos = 0; if(last_pos == 0 && pos == count - 1) last_pos = count; if(pos < last_pos) { int l = len; while(last_pos > 0 && l > 2) { last_pos--; l -= strlen(list[last_pos]); if(last_pos != 0) l -= 2; } if(l < 2) last_pos++; } werase(stat_win); wmove(stat_win, 0, 0); for(i = last_pos; i < count && len > 0; i++) { len -= strlen(list[i]); if(i != 0) len -= 2; if(i == last_pos && last_pos > 0) { wprintw(stat_win, "< "); } else if(i > last_pos) { if(len < 2) { wprintw(stat_win, " >"); break; } wprintw(stat_win, " "); } if(i == pos) { col_attr_t col; col = cfg.cs.color[STATUS_LINE_COLOR]; mix_colors(&col, &cfg.cs.color[MENU_COLOR]); init_pair(DCOLOR_BASE + MENU_COLOR, col.fg, col.bg); wbkgdset(stat_win, COLOR_PAIR(DCOLOR_BASE + MENU_COLOR) | col.attr); } wprint(stat_win, list[i]); if(i == pos) { wbkgdset(stat_win, COLOR_PAIR(DCOLOR_BASE + STATUS_LINE_COLOR) | cfg.cs.color[STATUS_LINE_COLOR].attr); pos = -pos; } } if(pos > 0 && pos != count) { last_pos = pos; draw_wild_menu(op); return; } if(op == 0 && len < 2 && i - 1 == pos) last_pos = i; wrefresh(stat_win); }
static void decorate_text (GimpAboutDialog *dialog, gint anim_type, gdouble time) { GtkStyle *style = gtk_widget_get_style (dialog->anim_area); const gchar *text; const gchar *ptr; gint letter_count = 0; gint text_length = 0; gint text_bytelen = 0; gint cluster_start, cluster_end; gunichar unichr; PangoAttrList *attrlist = NULL; PangoAttribute *attr; PangoRectangle irect = {0, 0, 0, 0}; PangoRectangle lrect = {0, 0, 0, 0}; GdkColor mix; mix_colors (style->bg + GTK_STATE_NORMAL, style->fg + GTK_STATE_NORMAL, &mix, time); text = pango_layout_get_text (dialog->layout); g_return_if_fail (text != NULL); text_length = g_utf8_strlen (text, -1); text_bytelen = strlen (text); attrlist = pango_attr_list_new (); dialog->textrange[0] = 0; dialog->textrange[1] = text_bytelen; switch (anim_type) { case 0: /* Fade in */ attr = pango_attr_foreground_new (mix.red, mix.green, mix.blue); attr->start_index = 0; attr->end_index = text_bytelen; pango_attr_list_insert (attrlist, attr); break; case 1: /* Fade in, spread */ attr = pango_attr_foreground_new (mix.red, mix.green, mix.blue); attr->start_index = 0; attr->end_index = text_bytelen; pango_attr_list_change (attrlist, attr); ptr = text; cluster_start = 0; while ((unichr = g_utf8_get_char (ptr))) { ptr = g_utf8_next_char (ptr); cluster_end = (ptr - text); if (unichr == 0x200b) { lrect.width = (1.0 - time) * 15.0 * PANGO_SCALE + 0.5; attr = pango_attr_shape_new (&irect, &lrect); attr->start_index = cluster_start; attr->end_index = cluster_end; pango_attr_list_change (attrlist, attr); } cluster_start = cluster_end; } break; case 2: /* Fade in, sinewave */ attr = pango_attr_foreground_new (mix.red, mix.green, mix.blue); attr->start_index = 0; attr->end_index = text_bytelen; pango_attr_list_change (attrlist, attr); ptr = text; cluster_start = 0; while ((unichr = g_utf8_get_char (ptr))) { if (unichr == 0x200b) { cluster_end = ptr - text; attr = pango_attr_rise_new ((1.0 -time) * 18000 * sin (4.0 * time + (float) letter_count * 0.7)); attr->start_index = cluster_start; attr->end_index = cluster_end; pango_attr_list_change (attrlist, attr); letter_count++; cluster_start = cluster_end; } ptr = g_utf8_next_char (ptr); } break; case 3: /* letterwise Fade in */ ptr = text; letter_count = 0; cluster_start = 0; while ((unichr = g_utf8_get_char (ptr))) { gint border = (text_length + 15) * time - 15; gdouble pos; if (letter_count < border) pos = 0; else if (letter_count > border + 15) pos = 1; else pos = ((gdouble) (letter_count - border)) / 15; mix_colors (style->fg + GTK_STATE_NORMAL, style->bg + GTK_STATE_NORMAL, &mix, pos); ptr = g_utf8_next_char (ptr); cluster_end = ptr - text; attr = pango_attr_foreground_new (mix.red, mix.green, mix.blue); attr->start_index = cluster_start; attr->end_index = cluster_end; pango_attr_list_change (attrlist, attr); if (pos < 1.0) dialog->textrange[1] = cluster_end; letter_count++; cluster_start = cluster_end; } break; default: g_printerr ("Unknown animation type %d\n", anim_type); } pango_layout_set_attributes (dialog->layout, attrlist); pango_attr_list_unref (attrlist); }
static void status_bar_message_i(const char message[], int error) { /* TODO: Refactor this function status_bar_message_i() */ static char *msg; static int err; int len; const char *p, *q; int lines; int status_bar_lines; size_t screen_length; const char *out_msg; char truncated_msg[2048]; if(curr_stats.load_stage == 0) { return; } if(message != NULL) { if(replace_string(&msg, message)) { return; } err = error; save_status_bar_msg(msg); } if(msg == NULL || vle_mode_is(CMDLINE_MODE)) { return; } p = msg; q = msg - 1; status_bar_lines = 0; len = getmaxx(stdscr); while((q = strchr(q + 1, '\n')) != NULL) { status_bar_lines += DIV_ROUND_UP(q - p, len ); if(q == p) { ++status_bar_lines; } p = q + 1; } if(*p == '\0') { ++status_bar_lines; } screen_length = utf8_strsw(p); status_bar_lines += DIV_ROUND_UP(screen_length, len); if(status_bar_lines == 0) { status_bar_lines = 1; } lines = status_bar_lines; if(status_bar_lines > 1 || screen_length > (size_t)getmaxx(status_bar)) { ++lines; } out_msg = msg; if(lines > 1) { if(cfg.trunc_normal_sb_msgs && !err && curr_stats.allow_sb_msg_truncation) { truncate_with_ellipsis(msg, getmaxx(stdscr) - FIELDS_WIDTH(), truncated_msg); out_msg = truncated_msg; lines = 1; } else { const int extra = DIV_ROUND_UP(ARRAY_LEN(PRESS_ENTER_MSG) - 1, len) - 1; lines += extra; } } if(lines > getmaxy(stdscr)) { lines = getmaxy(stdscr); } (void)ui_stat_reposition(lines); mvwin(status_bar, getmaxy(stdscr) - lines, 0); if(lines == 1) { wresize(status_bar, lines, getmaxx(stdscr) - FIELDS_WIDTH()); } else { wresize(status_bar, lines, getmaxx(stdscr)); } checked_wmove(status_bar, 0, 0); if(err) { col_attr_t col = cfg.cs.color[CMD_LINE_COLOR]; mix_colors(&col, &cfg.cs.color[ERROR_MSG_COLOR]); wattron(status_bar, COLOR_PAIR(colmgr_get_pair(col.fg, col.bg)) | col.attr); } else { int attr = cfg.cs.color[CMD_LINE_COLOR].attr; wattron(status_bar, COLOR_PAIR(cfg.cs.pair[CMD_LINE_COLOR]) | attr); } werase(status_bar); wprint(status_bar, out_msg); multiline_status_bar = lines > 1; if(multiline_status_bar) { checked_wmove(status_bar, lines - DIV_ROUND_UP(ARRAY_LEN(PRESS_ENTER_MSG), len), 0); wclrtoeol(status_bar); if(lines < status_bar_lines) wprintw(status_bar, "%d of %d lines. ", lines, status_bar_lines); wprintw(status_bar, "%s", PRESS_ENTER_MSG); } wattrset(status_bar, 0); update_all_windows(); /* This is needed because update_all_windows() doesn't call doupdate() if * curr_stats.load_stage == 1. */ doupdate(); }
void draw_sprite(TileSet * tileset, s_sprite sprite, s_map_block * block, float x, float y, int shrink, bool flip = 0, int offset = 0, bool shiftup = false) { if(offset < 0) return; int target_width = al_get_bitmap_width(al_get_target_bitmap()); int target_height = al_get_bitmap_height(al_get_target_bitmap()); if((x + sprite.origin_x > target_width) || (y + sprite.origin_y > target_height) || ((x + sprite.origin_x + sprite.width) < 0) || ((y + sprite.origin_y + (sprite.height - shrink)) < 0))return; int flags = 0; if(flip) flags = ALLEGRO_FLIP_HORIZONTAL; ALLEGRO_COLOR color; switch(sprite.color_by) { case COLOR_NONE: color = block->light; break; case COLOR_INI: color = mix_colors(sprite.color, block->light); break; case COLOR_BIOME: color = mix_colors(block->biome_color, block->light); break; case COLOR_COMBINED: color = mix_colors(block->combined_color, block->light); break; case COLOR_STRUCTURE: color = mix_colors(block->structure_color, block->light); break; case COLOR_TRADE: color = mix_colors(block->trade_color, block->light); break; case COLOR_PALETTE: switch(sprite.color_source) { case SOURCE_ELEV: color = mix_colors(tileset->get_palette_color(sprite.palette_number, block->height), block->light); break; case SOURCE_DEPTH: color = mix_colors(tileset->get_palette_color(sprite.palette_number,block->water_height-block->height), block->light); break; case SOURCE_TEMPERATURE: color = mix_colors(tileset->get_palette_color(sprite.palette_number,block->levels[SOURCE_TEMPERATURE]), block->light); break; case SOURCE_RAINFALL: color = mix_colors(tileset->get_palette_color(sprite.palette_number,block->levels[SOURCE_RAINFALL]), block->light); break; case SOURCE_DRAINAGE: color = mix_colors(tileset->get_palette_color(sprite.palette_number,block->levels[SOURCE_DRAINAGE]), block->light); break; case SOURCE_SAVAGERY: color = mix_colors(tileset->get_palette_color(sprite.palette_number,block->levels[SOURCE_SAVAGERY]), block->light); break; case SOURCE_VOLCANISM: color = mix_colors(tileset->get_palette_color(sprite.palette_number,block->levels[SOURCE_VOLCANISM]), block->light); break; case SOURCE_EVIL: color = mix_colors(tileset->get_palette_color(sprite.palette_number,block->levels[SOURCE_EVIL]), block->light); break; case SOURCE_SALINITY: color = mix_colors(tileset->get_palette_color(sprite.palette_number,block->levels[SOURCE_SALINITY]), block->light); break; default: color = block->light; } break; default: color = block->light; break; } al_draw_tinted_bitmap_region( imagelist.get_image(sprite.index), color, sprite.x + (sprite.width * offset), sprite.y + ((!shiftup)*shrink), sprite.width, sprite.height - shrink, x + sprite.origin_x, y + sprite.origin_y, flags); }
unsigned int GFX_mix_colors(unsigned int c1, unsigned int c2, float how_much){ return mix_colors(QColor(c1), QColor(c2), how_much).rgb(); }
void draw_menu(menu_info *m) { int i; int win_len; int x, y; getmaxyx(menu_win, y, x); win_len = x; werase(menu_win); normalize_top(m); x = m->top; box(menu_win, 0, 0); wattron(menu_win, A_BOLD); checked_wmove(menu_win, 0, 3); wprint(menu_win, m->title); wattroff(menu_win, A_BOLD); for(i = 1; x < m->len; i++, x++) { int z, off; char *buf; char *ptr = NULL; col_attr_t col; int type = WIN_COLOR; chomp(m->items[x]); if((ptr = strchr(m->items[x], '\n')) || (ptr = strchr(m->items[x], '\r'))) *ptr = '\0'; col = cfg.cs.color[WIN_COLOR]; if(cfg.hl_search && m->matches != NULL && m->matches[x]) { mix_colors(&col, &cfg.cs.color[SELECTED_COLOR]); type = SELECTED_COLOR; } init_pair(DCOLOR_BASE + type, col.fg, col.bg); wattron(menu_win, COLOR_PAIR(DCOLOR_BASE + type) | col.attr); z = m->hor_pos; off = 0; while(z-- > 0 && m->items[x][off] != '\0') { size_t l = get_char_width(m->items[x] + off); off += l; } buf = strdup(m->items[x] + off); for(z = 0; buf[z] != '\0'; z++) if(buf[z] == '\t') buf[z] = ' '; checked_wmove(menu_win, i, 2); if(get_screen_string_length(buf) > win_len - 4) { size_t len = get_normal_utf8_string_widthn(buf, win_len - 3 - 4); memset(buf + len, ' ', strlen(buf) - len); buf[len + 3] = '\0'; wprint(menu_win, buf); mvwaddstr(menu_win, i, win_len - 5, "..."); } else { const size_t len = get_normal_utf8_string_widthn(buf, win_len - 4); buf[len] = '\0'; wprint(menu_win, buf); } waddstr(menu_win, " "); free(buf); wattroff(menu_win, COLOR_PAIR(DCOLOR_BASE + type) | col.attr); if(i + 3 > y) break; } }
void move_to_menu_pos(int pos, menu_info *m) { /* TODO: refactor this function move_to_menu_pos() */ int redraw = 0; int x, z; char *buf = NULL; col_attr_t col; int off = 0; pos = MIN(m->len - 1, MAX(0, pos)); if(pos < 0) return; normalize_top(m); if(pos > get_last_visible_line(m)) { m->top = pos - (m->win_rows - 2 - 1); redraw = 1; } else if(pos < m->top) { m->top = pos; redraw = 1; } if(cfg.scroll_off > 0) { int s = MIN(DIV_ROUND_UP(m->win_rows - 2, 2), cfg.scroll_off); if(pos - m->top < s && m->top > 0) { m->top -= s - (pos - m->top); normalize_top(m); redraw = 1; } if(pos > get_last_visible_line(m) - s) { m->top += s - (get_last_visible_line(m) - pos); normalize_top(m); redraw = 1; } } m->current = 1 + (pos - m->top); if(redraw) draw_menu(m); x = getmaxx(menu_win) + get_utf8_overhead(m->items[pos]); buf = malloc(x + 2); if(buf == NULL) return; /* TODO: check if this can be false. */ if(m->items[pos] != NULL) { z = m->hor_pos; while(z-- > 0 && m->items[pos][off] != '\0') { size_t l = get_char_width(m->items[pos] + off); off += l; x -= l - 1; } snprintf(buf, x, " %s", m->items[pos] + off); } else { buf[0] = '\0'; } for(z = 0; buf[z] != '\0'; z++) if(buf[z] == '\t') buf[z] = ' '; for(z = strlen(buf); z < x; z++) buf[z] = ' '; buf[x] = ' '; buf[x + 1] = '\0'; col = cfg.cs.color[WIN_COLOR]; if(cfg.hl_search && m->matches != NULL && m->matches[pos]) mix_colors(&col, &cfg.cs.color[SELECTED_COLOR]); mix_colors(&col, &cfg.cs.color[CURR_LINE_COLOR]); init_pair(DCOLOR_BASE + MENU_CURRENT_COLOR, col.fg, col.bg); wattrset(menu_win, COLOR_PAIR(DCOLOR_BASE + MENU_CURRENT_COLOR) | col.attr); checked_wmove(menu_win, m->current, 1); if(get_screen_string_length(m->items[pos] + off) > getmaxx(menu_win) - 4) { size_t len = get_normal_utf8_string_widthn(buf, getmaxx(menu_win) - 3 - 4 + 1); memset(buf + len, ' ', strlen(buf) - len); buf[len + 3] = '\0'; wprint(menu_win, buf); mvwaddstr(menu_win, m->current, getmaxx(menu_win) - 5, "..."); } else { size_t len = get_normal_utf8_string_widthn(buf, getmaxx(menu_win) - 4 + 1); buf[len] = '\0'; wprint(menu_win, buf); } waddstr(menu_win, " "); wattroff(menu_win, COLOR_PAIR(DCOLOR_BASE + MENU_CURRENT_COLOR) | col.attr); m->pos = pos; free(buf); show_position_in_menu(m); }
void clean_menu_position(menu_info *m) { int x, z; int off = 0; char * buf = (char *)NULL; col_attr_t col; int type = MENU_COLOR; x = getmaxx(menu_win) + get_utf8_overhead(m->items[m->pos]); buf = malloc(x + 2); /* TODO: check if this can ever be false. */ if(m->items[m->pos] != NULL) { z = m->hor_pos; while(z-- > 0 && m->items[m->pos][off] != '\0') { size_t l = get_char_width(m->items[m->pos] + off); off += l; x -= l - 1; } snprintf(buf, x, " %s", m->items[m->pos] + off); } else { buf[0] = '\0'; } for(z = 0; buf[z] != '\0'; z++) if(buf[z] == '\t') buf[z] = ' '; for(z = strlen(buf); z < x; z++) buf[z] = ' '; buf[x] = ' '; buf[x + 1] = '\0'; col = cfg.cs.color[WIN_COLOR]; if(cfg.hl_search && m->matches != NULL && m->matches[m->pos]) { mix_colors(&col, &cfg.cs.color[SELECTED_COLOR]); type = SELECTED_COLOR; } init_pair(DCOLOR_BASE + type, col.fg, col.bg); wattrset(menu_win, COLOR_PAIR(type + DCOLOR_BASE) | col.attr); checked_wmove(menu_win, m->current, 1); if(get_screen_string_length(m->items[m->pos] + off) > getmaxx(menu_win) - 4) { size_t len = get_normal_utf8_string_widthn(buf, getmaxx(menu_win) - 3 - 4 + 1); memset(buf + len, ' ', strlen(buf) - len); buf[len + 3] = '\0'; wprint(menu_win, buf); mvwaddstr(menu_win, m->current, getmaxx(menu_win) - 5, "..."); } else { size_t len = get_normal_utf8_string_widthn(buf, getmaxx(menu_win) - 4 + 1); buf[len] = '\0'; wprint(menu_win, buf); } waddstr(menu_win, " "); wattroff(menu_win, COLOR_PAIR(type + DCOLOR_BASE) | col.attr); free(buf); }
/******************************************************************************* * For each pixel we must generate a primary ray and test for intersection with * all of the objects in the scene. If there is more than one ray-object * intersection then we must choose the closest intersection (the smallest * positive value of t).To ensure that there are no objects intersected in * front of the image plane (this is called near plane clipping), we keep the * distance of the primary ray to the screen and test all intersections against * this distance. If the t value is less than this distance, then we ignore the * object. * * If there is an intersection then we must compute the shadow rays and the * reflection rays. */ color_t trace_ray(ray3_t* test_ray, int depth) { int occluded = 0; ray3_t shadow_ray; ray3_t reflected_ray; color_t ray_color = { 0.0, 0.0, 0.0, 0.0 }; color_t nul_color = {0.0, 0.0, 0.0, 1.0}; light_t* light_ptr = 0; double intersect_ray_length_curr = 0.0; double intersect_ray_length_close = 0.0; int intersection_exists = 0; colored_sphere_t* sphere_close_ptr = 0; vector3_t intersection; vector3_t intersection_vector; int sphere_index = 0; int light_index = 0; int shadow_index; color_t add_color; /* test ray against all objects in scene, search until closest intersection * is found. */ for (sphere_index = 0; sphere_index < sphere_list_count; ++sphere_index) { colored_sphere_t* sphere_ptr = &sphere_list[sphere_index]; /* test for intersection between ray and scene object */ if (1 == find_ray_sphere_intersect(test_ray, &sphere_ptr->sphere, &intersect_ray_length_curr)) { if (intersect_ray_length_curr < 0.0) continue; if (0 == intersection_exists) { intersection_exists = 1; intersect_ray_length_close = intersect_ray_length_curr; sphere_close_ptr = sphere_ptr; } else if (intersect_ray_length_curr < intersect_ray_length_close) { intersect_ray_length_curr = intersect_ray_length_close; sphere_close_ptr = sphere_ptr; } } } if (1 == intersection_exists) { intersection.x = test_ray->origin.x + test_ray->vector.x * intersect_ray_length_close; intersection.y = test_ray->origin.y + test_ray->vector.y * intersect_ray_length_close; intersection.z = test_ray->origin.z + test_ray->vector.z * intersect_ray_length_close; shadow_ray.origin = intersection; /* Shadow rays are sent towards all light sources to determine if any objects occlude the intersection spot. */ for (light_index = 0; light_index < light_list_count; ++light_index) { occluded = 0; light_ptr = &light_list[light_index]; shadow_ray.vector.x = (light_ptr->origin.x - shadow_ray.origin.x); shadow_ray.vector.y = (light_ptr->origin.y - shadow_ray.origin.y); shadow_ray.vector.z = (light_ptr->origin.z - shadow_ray.origin.z); normalize_vector(&shadow_ray.vector); /* Test intersection to determine if ray is in occlusion. */ for (shadow_index = 0; shadow_index < sphere_list_count; ++shadow_index) { if (1 == find_ray_sphere_intersect(&shadow_ray, &sphere_list[shadow_index].sphere, &intersect_ray_length_curr)) { occluded = 1; break; } } if (occluded == 0) { /* Calculate the total light intensity. */ double light_intensity = calc_dot_product(&shadow_ray.vector, &test_ray->vector); if (light_intensity < 0.0) light_intensity = -light_intensity; ray_color = mix_colors(&nul_color, &sphere_close_ptr->color, light_intensity); if (depth < 4) { reflected_ray.origin.x = intersection.x; reflected_ray.origin.y = intersection.y; reflected_ray.origin.z = intersection.z; intersection_vector.x = (intersection.x - sphere_close_ptr->sphere.center.x); intersection_vector.y = (intersection.y - sphere_close_ptr->sphere.center.y); intersection_vector.z = (intersection.z - sphere_close_ptr->sphere.center.z); normalize_vector(&intersection_vector); calc_reflected_vector(&reflected_ray.vector, &test_ray->vector, &intersection_vector); add_color = trace_ray(&reflected_ray, ++depth); if ((add_color.r != 0x00) || (add_color.g != 0x00) || (add_color.b != 0x00)) { double mix_ratio = calc_dot_product(&reflected_ray.vector, &intersection_vector); if (mix_ratio < 0.0) mix_ratio = -mix_ratio; ray_color = mix_colors(&ray_color, &add_color, mix_ratio); } } } } } return ray_color; }
void ProcessController::DoDraw(bool force) { BRect bounds(Bounds()); float h = floorf(bounds.Height ()) - 2; float top = 1, left = 1; float bottom = top + h; float barWidth = layout[gCPUcount].cpu_width; // interspace float right = left + gCPUcount * (barWidth + layout[gCPUcount].cpu_inter) - layout[gCPUcount].cpu_inter; // right of CPU frame... if (force && Parent()) { SetHighColor(Parent()->ViewColor()); FillRect(BRect(right + 1, top - 1, right + 2, bottom + 1)); } if (force) { SetHighColor(frame_color); StrokeRect(BRect(left - 1, top - 1, right, bottom + 1)); if (gCPUcount > 1 && layout[gCPUcount].cpu_inter == 1) { for (unsigned int x = 1; x < gCPUcount; x++) StrokeLine(BPoint(left + x * barWidth + x - 1, top), BPoint(left + x * barWidth + x - 1, bottom)); } } float leftMem = bounds.Width() - layout[gCPUcount].mem_width; if (force) StrokeRect(BRect(leftMem - 1, top - 1, leftMem + layout[gCPUcount].mem_width, bottom + 1)); for (unsigned int x = 0; x < gCPUcount; x++) { right = left + barWidth - 1; float rem = fCPUTimes[x] * (h + 1); float barHeight = floorf (rem); rem -= barHeight; float limit = bottom - barHeight; // horizontal line float previousLimit = bottom - fLastBarHeight[x]; float idleTop = top; if (!force && previousLimit > top) idleTop = previousLimit - 1; if (limit > idleTop) { SetHighColor(idle_color); FillRect(BRect(left, idleTop, right, limit - 1)); } if (barHeight <= h) { rgb_color fraction_color; mix_colors(fraction_color, idle_color, active_color, rem); SetHighColor(fraction_color); StrokeLine(BPoint(left, bottom - barHeight), BPoint(right, bottom - barHeight)); } float active_bottom = bottom; if (!force && previousLimit < bottom) active_bottom = previousLimit + 1; if (limit < active_bottom) { SetHighColor(active_color); FillRect(BRect(left, limit + 1, right, active_bottom)); } left += layout[gCPUcount].cpu_width + layout[gCPUcount].cpu_inter; fLastBarHeight[x] = barHeight; } float rightMem = bounds.Width() - 1; float rem = fMemoryUsage * (h + 1); float barHeight = floorf(rem); rem -= barHeight; rgb_color used_memory_color; float sq = fMemoryUsage * fMemoryUsage; sq *= sq; sq *= sq; mix_colors(used_memory_color, memory_color, swap_color, sq); float limit = bottom - barHeight; // horizontal line float previousLimit = bottom - fLastMemoryHeight; float free_top = top; if (!force && previousLimit > top) free_top = previousLimit - 1; if (limit > free_top) { SetHighColor (idle_color); FillRect(BRect(leftMem, free_top, rightMem, limit - 1)); } if (barHeight <= h) { rgb_color fraction_color; mix_colors(fraction_color, idle_color, used_memory_color, rem); SetHighColor(fraction_color); StrokeLine(BPoint(leftMem, bottom - barHeight), BPoint(rightMem, bottom - barHeight)); } float usedBottom = bottom; // if (!force && previousLimit < bottom) // usedBottom = previousLimit + 1; if (limit < usedBottom) { SetHighColor(used_memory_color); FillRect(BRect(leftMem, limit + 1, rightMem, usedBottom)); } fLastMemoryHeight = barHeight; }
static void updatePalette(EditorWidget *my_widget, QWidget *widget, QPalette &pal){ if(system_color==NULL){ system_color=new QColor(SETTINGS_read_string("system_color","#d2d0d5")); SETTINGS_write_string("system_color",system_color->name()); } if(button_color==NULL){ button_color=new QColor(SETTINGS_read_string("button_color","#c1f1e3")); SETTINGS_write_string("button_color",button_color->name()); } if(override_default_qt_colors==false){ //qapplication->setPalette(t.palette()); //my_widget->setPalette( QApplication::palette( my_widget ) ); return; } // Background { //QColor c(0xe5, 0xe5, 0xe5); QColor c(*system_color); QColor b(*button_color); if(dynamic_cast<QComboBox*>(widget)!=NULL){ c = my_widget->colors[13]; c=mix_colors(c.light(70),QColor(98,59,33),0.55);//editor->colors[colnum].light(52); c.setAlpha(76); } pal.setColor( QPalette::Active, QColorGroup::Background, b); pal.setColor( QPalette::Inactive, QColorGroup::Background, b); pal.setColor( QPalette::Disabled, QColorGroup::Background, b.light(95)); pal.setColor( QPalette::Active, QColorGroup::Button, c); pal.setColor( QPalette::Inactive, QColorGroup::Button, c); pal.setColor( QPalette::Disabled, QColorGroup::Button, c.light(80)); pal.setColor(QPalette::Active, QColorGroup::Base, c); pal.setColor(QPalette::Inactive, QColorGroup::Base, c); pal.setColor(QPalette::Disabled, QColorGroup::Base, c.light(80)); pal.setBrush(QPalette::Highlight, (const QBrush&)QBrush(b.light(85))); pal.setColor(QPalette::Disabled, QPalette::Light, c.light(80)); //pal.setBrush((QPalette::ColorGroup)QColorGroup::Button, QPalette::Highlight, (const QBrush&)QBrush(b.light(95))); //pal.setBrush(QPalette::Highlight, QColorGroup::Button, QBrush(c.light(80))); //pal.setBrush(QPalette::Highlight, QColorGroup::Base, QBrush(c.light(80))); #if 0 pal.setColor(QPalette::Active, QColorGroup::Window, c); pal.setColor(QPalette::Inactive, QColorGroup::Window, c); pal.setColor(QPalette::Disabled, QColorGroup::Window, c.light(80)); #endif #if 0 pal.setColor(QPalette::Active, QColorGroup::BrightText, c); pal.setColor(QPalette::Inactive, QColorGroup::BrightText, c); pal.setColor(QPalette::Disabled, QColorGroup::BrightText, c.light(80)); #endif } // Foreground, text, etc. (everything blackish) { QColor c(my_widget==NULL ? QColor(SETTINGS_read_string("color1","black")) : my_widget->colors[1]); c.setAlpha(180); pal.setColor(QPalette::Active, QColorGroup::Foreground, c); pal.setColor(QPalette::Inactive, QColorGroup::Foreground, c.light(93)); pal.setColor(QPalette::Disabled, QColorGroup::Foreground, c.light(80)); pal.setColor(QPalette::Active, QColorGroup::Foreground, c); pal.setColor(QPalette::Inactive, QColorGroup::Foreground, c.light(93)); pal.setColor(QPalette::Disabled, QColorGroup::Foreground, c.light(80)); pal.setColor(QPalette::Active, QColorGroup::ButtonText, c); pal.setColor(QPalette::Inactive, QColorGroup::ButtonText, c.light(93)); pal.setColor(QPalette::Disabled, QColorGroup::ButtonText, c.light(80)); pal.setColor(QPalette::Active, QColorGroup::ButtonText, c); pal.setColor(QPalette::Inactive, QColorGroup::ButtonText, c.light(93)); pal.setColor(QPalette::Disabled, QColorGroup::ButtonText, c.light(80)); pal.setColor(QPalette::Active, QColorGroup::Text, c); pal.setColor(QPalette::Inactive, QColorGroup::Text, c.light(90)); pal.setColor(QPalette::Disabled, QColorGroup::Text, c.light(80)); pal.setColor(QPalette::Active, QColorGroup::HighlightedText, c.light(100)); pal.setColor(QPalette::Inactive, QColorGroup::HighlightedText, c.light(90)); pal.setColor(QPalette::Disabled, QColorGroup::HighlightedText, c.light(80)); pal.setColor(QPalette::Active, QColorGroup::Text, c); pal.setColor(QPalette::Inactive, QColorGroup::Text, c.light(90)); pal.setColor(QPalette::Disabled, QColorGroup::Text, c.light(80)); } }