void kernel_main( const multiboot& /*multiboot_structure*/, typ::uint32_t mboot_magic ) { if( multiboot_magic != mboot_magic ) { screen << color_t( color::red, color::white ) << "Error: No Multiboot Bootloader Found ( Err_NMBF )"; return; } screen << color_t( color::white, color::black ); screen.clear(); screen << "Welcome OSDeveloper"; screen.endl(); gdt::init_gdt(); typ::size_t a = 27; screen << a; return; }
std::vector<color_t> palette(const color_range& cr) { std::vector<color_t> temp, res; std::unordered_set<color_t> clist; // Use blue to make master set of possible colors for(int i = 255; i != 0; i--) { const int j = 255 - i; temp.emplace_back(static_cast<uint8_t>(0), static_cast<uint8_t>(0), static_cast<uint8_t>(i)); temp.emplace_back(static_cast<uint8_t>(j), static_cast<uint8_t>(j), static_cast<uint8_t>(255)); } // Use recolor function to generate list of possible colors. // Could use a special function, would be more efficient, but harder to maintain. color_range_map cmap = recolor_range(cr, temp); for(const auto& cm : cmap) { clist.insert(cm.second); } res.push_back(cmap[{0,0,255}]); for(const auto& cs : clist) { if(cs != res[0] && !cs.null() && cs != color_t(255, 255, 255)) { res.push_back(cs); } } return res; }
void import_styles::set_border_color( border_direction_t dir, color_elem_t alpha, color_elem_t red, color_elem_t green, color_elem_t blue) { border_attrs_t* p = get_border_attrs(m_cur_border, dir); if (p) p->border_color = color_t(alpha, red, green, blue); }
static inline bool valid_total_colors(cube_t *cube) { lyrnum_t layers = cube->layers; for (lyrnum_t i = 0; i < (layers - 1) / 2 + 1; i++) { lyrnum_t total = (layers - i * 2) * 4 - 4; total = (total == 0 ? 1 : total); lyrnum_t count[TOTAL_COLORS]; for (color_t j = 0; j < TOTAL_COLORS; j++) { count[j] = total; } if (total == 1) { lyrnum_t center = pow(layers, 2); for (color_t j = 0; j < TOTAL_COLORS; j++) { count[cube->faces[j][center]]--; } } else { for (color_t j = 0; j < TOTAL_COLORS; j++) { color_t (*face)[layers] = (color_t (*)[layers]) cube->faces[j]; for (lyrnum_t k = i, k_c = layers - 1 - i; k < layers - 1 - i; k++, k_c--) { count[face[i][k]]--; count[face[k][layers - 1 - i]]--; count[face[layers - 1 - i][k_c]]--; count[face[k_c][i]]--; } } } for (color_t j = 0; j < TOTAL_COLORS; j++) { if (count[j] != 0) return false; } } return true; }
void format_run::reset() { pos = 0; size = 0; font.clear(); font_size = 0; bold = false; italic = false; color = color_t(); }
color_range_map recolor_range(const color_range& new_range, const std::vector<color_t>& old_rgb) { color_range_map map_rgb; const uint16_t new_red = new_range.mid().r; const uint16_t new_green = new_range.mid().g; const uint16_t new_blue = new_range.mid().b; const uint16_t max_red = new_range.max().r; const uint16_t max_green = new_range.max().g; const uint16_t max_blue = new_range.max().b; const uint16_t min_red = new_range.min().r; const uint16_t min_green = new_range.min().g; const uint16_t min_blue = new_range.min().b; // Map first color in vector to exact new color const color_t temp_rgb = old_rgb.empty() ? color_t() : old_rgb[0]; const uint16_t reference_avg = (temp_rgb.r + temp_rgb.g + temp_rgb.b) / 3; for(const auto& old_c : old_rgb) { const uint16_t old_avg = (old_c.r + old_c.g + old_c.b) / 3; // Calculate new color uint32_t new_r = 0, new_g = 0, new_b = 0; if(reference_avg && old_avg <= reference_avg) { float old_ratio = static_cast<float>(old_avg) / reference_avg; new_r = static_cast<uint32_t>(old_ratio * new_red + (1 - old_ratio) * min_red); new_g = static_cast<uint32_t>(old_ratio * new_green + (1 - old_ratio) * min_green); new_b = static_cast<uint32_t>(old_ratio * new_blue + (1 - old_ratio) * min_blue); } else if(reference_avg != 255) { float old_ratio = (255.0f - static_cast<float>(old_avg)) / (255.0f - reference_avg); new_r = static_cast<uint32_t>(old_ratio * new_red + (1 - old_ratio) * max_red); new_g = static_cast<uint32_t>(old_ratio * new_green + (1 - old_ratio) * max_green); new_b = static_cast<uint32_t>(old_ratio * new_blue + (1 - old_ratio) * max_blue); } else { // Should never get here. // Would imply old_avg > reference_avg = 255 assert(false); } new_r = std::min<uint32_t>(new_r, 255); new_g = std::min<uint32_t>(new_g, 255); new_b = std::min<uint32_t>(new_b, 255); map_rgb[old_c] = {static_cast<uint8_t>(new_r), static_cast<uint8_t>(new_g), static_cast<uint8_t>(new_b)}; } return map_rgb; }
void fill_t::find_min_max(point_t p,int& YMin, int& YMax, int& XMin, int& XMax,float width,float height){ //std::cout<<"Min max\n"; std::queue <point_t> fmmQueue; fmmQueue.push(p); float pointx = p.getX(); float pointy = p.getY(); color_t c=colorArray[(int)pointx][(int)pointy]; color_t pixels; while(!fmmQueue.empty()){ p=fmmQueue.front(); pointx=p.getX(); pointy=p.getY(); fmmQueue.pop(); //Added Canvas size check if(pointx>=width || pointy>=height || pointx<0 || pointy<0) continue; pixels = colorArray[(int)pointx][(int)pointy]; //glReadPixels(pointx,pointy,1.0,1.0,GL_RGB,GL_FLOAT,pixels); if( (pixels.getR()==c.getR()) && (pixels.getG()==c.getG()) && (pixels.getB()==c.getB()) ) { if(pointy<YMin){ YMin=pointy; } if(pointy>YMax){ YMax=pointy; } if(pointx<XMin){ XMin=pointx; } if(pointx>XMax){ XMax=pointx; } p.draw(pen_t(color_t(0.5,0.5,0.5),1)); //std::cout<<" let me pass!!! I am the point "<<pointx<<" and "<<pointy<<std::endl; fmmQueue.push(point_t(pointx+1,pointy)); fmmQueue.push(point_t(pointx,pointy+1)); fmmQueue.push(point_t(pointx-1,pointy)); fmmQueue.push(point_t(pointx,pointy-1)); // fmmQueue.push(point_t(pointx+1,pointy+1)); // fmmQueue.push(point_t(pointx-1,pointy-1)); // fmmQueue.push(point_t(pointx+1,pointy-1)); // fmmQueue.push(point_t(pointx-1,pointy+1)); } } }
void the_end(CVideo &video, std::string text, unsigned int duration) { // // Some sane defaults. // if(text.empty()) text = _("The End"); if(!duration) duration = 3500; SDL_Rect area = screen_area(); sdl::fill_rect(video.getSurface(),&area,0); video.flip(); const size_t font_size = font::SIZE_XLARGE; area = font::text_area(text,font_size); area.x = screen_area().w/2 - area.w/2; area.y = screen_area().h/2 - area.h/2; for(size_t n = 0; n < 255; n += 5) { if(n) sdl::fill_rect(video.getSurface(),&area,0); const color_t col = color_t(uint8_t(n), uint8_t(n), uint8_t(n), uint8_t(n)); font::draw_text(&video,area,font_size,col,text,area.x,area.y); events::pump(); events::raise_process_event(); events::raise_draw_event(); video.flip(); CVideo::delay(10); } // // Delay after the end of fading. // Rounded to multiples of 10. // unsigned int count = duration/10; while(count) { events::pump(); events::raise_process_event(); events::raise_draw_event(); video.flip(); CVideo::delay(10); --count; } }
void asdf_multiplat_t::render() { renderer->pre_render(); { spritebatch->begin(); ASSERT(!CheckGLError(), "gl error after begin"); main_view->render(glm::vec3(0, 0, 0), glm::mat3(), color_t(1.0f)); ASSERT(!CheckGLError(), "GL error after main_view->render() "); spritebatch->end(); } glUseProgram(0); if (render_debug_views) render_debug(); ASSERT(specific, "app.specific not assigned"); specific->render(); renderer->post_render(); }
namespace editor { const color_t selection_overlay_color = color_t(1.0, 1.0, 1.0, 0.5f); //TODO: move this into an asdf_multiplat header constexpr bool is_sdl_keyboard_event(SDL_Event* event) { return event->type == SDL_KEYDOWN || event->type == SDL_KEYUP || event->type == SDL_TEXTEDITING || event->type == SDL_TEXTINPUT // || event->type == SDL_KEYMAPCHANGED /// Does not compile on travis (it might be using an old version of SDL? docs say this requires SDL 2.0.4) ; } //-- editor_t::editor_t() : hexmap_t() , action_stack(*this) , object_selection(*this) {} void editor_t::init() { hexmap_t::init(); input = make_unique<input_handler_t>(*this); app.mouse_state.thing = input.get(); } void editor_t::render() { hexmap_t::render(); for(auto const& sel_obj_ind : object_selection.object_indices) { auto const& sel_obj = map_data.objects[sel_obj_ind]; auto& spritebatch = rendered_map->spritebatch; auto const& shader = rendered_map->shader; spritebatch.begin(shader->view_matrix, shader->projection_matrix); auto const& pixel_texture = Content.textures["pixel"]; auto const& obj_size_px = rendered_map->ojects_atlas->atlas_entries[sel_obj.id].size_px; auto scale = vec2(obj_size_px) / pixel_texture->get_size(); //scale overlay texture to match object texture size auto sprite_scale = scale * sel_obj.scale / glm::vec2(px_per_unit); spritebatch.draw(pixel_texture, sel_obj.position, selection_overlay_color, sprite_scale, sel_obj.rotation); spritebatch.end(); } } void editor_t::save_action() { map_data.save_to_file("test_save.hxm"); LOG("map saved"); } void editor_t::load_action() { map_data.load_from_file("test_save.hxm"); LOG("map loaded"); } bool editor_t::undo() { if(action_stack.can_undo()) { action_stack.undo(); return true; } return false; } bool editor_t::redo() { if(action_stack.can_redo()) { action_stack.redo(); return true; } return false; } void editor_t::on_event(SDL_Event* event) { // I eventually want to remove this in place of my own keyboard // abstraction so I can get rid of handling sdl events here if(is_sdl_keyboard_event(event)) { if(event->key.type == SDL_KEYDOWN) input->on_key_down(event->key.keysym); } } void editor_t::set_tool(editor_t::tool_type_e const& new_tool) { switch(current_tool) { case select: { object_selection.clear_selection(); break; } case terrain_paint: { paint_terrain_end(); break; } case place_objects: { break; } case place_splines: { break; } }; current_tool = new_tool; LOG("current tool: %s", tool_type_strings[current_tool]); } /// Selection bool editor_t::select_object(size_t object_index) { ASSERT(object_index != size_t(-1), ""); LOG("selected object: %zu", object_index); return object_selection.add_object_index(object_index); } bool editor_t::deselect_object(size_t object_index) { ASSERT(object_index != size_t(-1), ""); LOG("deselected object: %zu", object_index); return object_selection.remove_object_index(object_index); } void editor_t::deselect_all() { object_selection.clear_selection(); } bool editor_t::select_object_at(glm::vec2 position) { size_t ind = map_data.object_index_at(position); if(ind != size_t(-1)) { select_object(ind); return true; } return false; } bool editor_t::is_object_selected(size_t obj_index) const { return object_selection.object_indices.count(obj_index); } /// Terrain void editor_t::paint_terrain_start() { painted_terrain_coords.clear(); } /// If the coord is inside the map, track the old tile_id of that cell /// and then paint it with the editor's current_tile_id bool editor_t::paint_terrain_at_coord(glm::ivec2 coord) { if(map_data.hex_grid.is_in_bounds(coord)) { auto& cell = map_data.hex_grid.cell_at(coord); painted_terrain_coords.insert({coord, cell.tile_id}); cell.tile_id = current_tile_id; return true; } return false; } void editor_t::paint_terrain_end() { if(!painted_terrain_coords.empty()) { action_stack.push(make_unique<paint_tiles_action_t> ( map_data.hex_grid , std::move(painted_terrain_coords) , current_tile_id ) ); painted_terrain_coords.clear(); //pretty sure its empty anyway due to std::move } } /// Map Objects void editor_t::place_object(glm::vec2 position) { auto const& atlas_entries = rendered_map->ojects_atlas->atlas_entries; ASSERT(current_object_id < atlas_entries.size(), "object ID does not exist in atlas"); auto const& atlas_entry = atlas_entries[current_object_id]; glm::vec2 size = glm::vec2(atlas_entry.size_px) * units_per_px; data::map_object_t obj{current_object_id, position, size, glm::vec4(1), glm::vec2(1,1), 0.0f}; action_stack.push_and_execute(make_unique<add_map_object_action_t>(map_data, std::move(obj))); } void editor_t::cancel_action() { switch(current_tool) { case select: { deselect_all(); break; } case terrain_paint: { break; } case place_objects: { break; } case place_splines: { break; } default: break; }; } object_selection_t::object_selection_t(editor_t& _e) : editor(_e) { } bool object_selection_t::add_object_index(size_t obj_ind) { auto x = object_indices.insert(obj_ind); recalc_bounds(); //second value of pair returned by insert is a bool that is true //if the insertion took place return x.second; } bool object_selection_t::remove_object_index(size_t obj_ind) { // not 100% sure if it erases the object at this position, or with this key // I think it's with the key auto n = object_indices.erase(obj_ind); recalc_bounds(); return n > 0; } void object_selection_t::clear_selection() { object_indices.clear(); recalc_bounds(); } void object_selection_t::recalc_bounds() { upper_bound = vec2(numeric_limits<float>::min()); lower_bound = vec2(numeric_limits<float>::max()); for(auto const& obj_ind : object_indices) { auto const& obj = editor.map_data.objects[obj_ind]; upper_bound.x = std::max(upper_bound.x, obj.position.x + obj.size_d2.x); upper_bound.y = std::max(upper_bound.y, obj.position.y + obj.size_d2.y); lower_bound.x = std::min(lower_bound.x, obj.position.x - obj.size_d2.x); lower_bound.y = std::min(lower_bound.y, obj.position.y - obj.size_d2.y); } } }
void import_shared_strings::set_segment_font_color( color_elem_t alpha, color_elem_t red, color_elem_t green, color_elem_t blue) { m_cur_format.color = color_t(alpha, red, green, blue); }
virtual color_t get_clear_color() const { return color_t(); }
void color_t::reset() { *this = color_t(); }
void import_styles::set_fill_bg_color(color_elem_t alpha, color_elem_t red, color_elem_t green, color_elem_t blue) { m_cur_fill.bg_color = color_t(alpha, red, green, blue); }
void import_styles::set_font_underline_color(color_elem_t alpha, color_elem_t red, color_elem_t green, color_elem_t blue) { m_cur_font.underline_color = color_t(alpha, red, green, blue); }
color_t gradientUp() { return color_t (red*255.0+(1.0-red)*102.0 , green*255.0+(1.0-green)*102.0 , blue*255.0+(1.0-blue)*102.0 ) ; }
color_t gradientDown() { return color_t (red*153 , green*153 , blue*153 ) ; }