void Menu::drawMainMenu(Graphics2D& g, bool charSelect) { model::Project& proj = getOwner().getProject(); model::SaveData& lsd = proj.getLSD(); model::DataBase& ldb = proj.getLDB(); std::ostringstream ss; // main menu g.drawWindow( Vector2D(0, 0), Size2D(88, 96) ); // cursor if(charSelect) g.drawCursorPassive( Vector2D(4, cursor(0)*16 + 8), Size2D(80, CURSOR_H) ); else g.drawCursor( Vector2D(4, cursor(0)*16 + 8) + cursorMove(), Size2D(80, CURSOR_H) ); // command font::FontColor c = lsd.memberNum() != 0 ? font::FNT_ENABLE : font::FNT_DISABLE; g.drawString(command_[0], Vector2D(8, 10 + CURSOR_H*0), font::FNT_ENABLE); g.drawString(command_[1], Vector2D(8, 10 + CURSOR_H*1), c); g.drawString(command_[2], Vector2D(8, 10 + CURSOR_H*2), c); g.drawString(command_[3], Vector2D(8, 10 + CURSOR_H*3), proj.canSave() ? font::FNT_ENABLE : font::FNT_DISABLE); g.drawString(command_[4], Vector2D(8, 10 + CURSOR_H*4), font::FNT_ENABLE); // money g.drawMoneyWindow( Vector2D( 0, 208) ); // char info g.drawWindow( Vector2D(88, 0), Size2D(232, 240) ); // char cursor if(charSelect) g.drawCursor( Vector2D(92, cursor(1)*58 + 4) + cursorMove(), Size2D(224, 56) ); std::vector< uint16_t >& mem = lsd.member(); for(uint i = 0; i < mem.size(); i++) { uint charID = mem[i]; Vector2D base(88 + 8, 8 + (FACE_SIZE[1] + 10)*i); g.drawFaceSet( proj.faceSet(charID), proj.faceSetPos(mem[i]), base ); base += Vector2D(FACE_SIZE[0] + 8, 3); g.drawString( proj.name(charID), base); g.drawString( proj.title(charID), base + Vector2D(font::HALF_FONT_W*15, 0) ); base += Vector2D(0, font::FONT_H + 3); // level g.drawString(ldb.vocabulary(128), base, font::FNT_STATUS); ss.str(""); ss << std::setw(2) << proj.level(charID); g.drawString( ss.str(), base + Vector2D(font::FULL_FONT_W, 0) ); // condition g.drawString( proj.condition(charID), base + Vector2D(font::HALF_FONT_W*7, 0), proj.conditionColor(charID) ); // HP g.drawString( ldb.vocabulary(129), base + Vector2D(font::HALF_FONT_W*18, 0), font::FNT_STATUS ); ss.str(""); ss << std::setw(3) << proj.hp(charID) << "/" << std::setw(3) << proj.param(charID, Param::HP); g.drawString( ss.str(), base + Vector2D(font::HALF_FONT_W*20, 0) ); base += Vector2D(0, font::FONT_H + 3); // experience g.drawString(ldb.vocabulary(127), base, font::FNT_STATUS); ss.str(""); if( proj.level(charID) >= LV_MAX ) ss << RPG2kString(6, '-') << "/" << RPG2kString(6, '-'); else ss << std::setw(6) << proj.exp(charID) << "/" << std::setw(6) << proj.nextLevelExp(charID); g.drawString( ss.str(), base + Vector2D(font::FULL_FONT_W, 0) ); // MP g.drawString( ldb.vocabulary(130), base + Vector2D(font::HALF_FONT_W*18, 0), font::FNT_STATUS ); ss.str(""); ss << std::setw(3) << proj.mp(charID) << "/" << std::setw(3) << proj.param(charID, Param::MP); g.drawString( ss.str(), base + Vector2D(font::HALF_FONT_W*20, 0) ); } }
void Menu::draw(Graphics2D& g) { g.drawWallpaper( Vector2D(0, 0), SCREEN_SIZE ); // model::Project& proj = getOwner().getProject(); // model::DataBase& ldb = proj.getLDB(); // model::SaveData& lsd = proj.getLSD(); if( cursorNum() == 1 ) drawMainMenu(g); else switch( cursor(0) ) { case MENU_SKILL: case MENU_EQUIP: drawMainMenu(g, true); break; case MENU_QUIT: g.drawWindow( Vector2D( (SCREEN_SIZE[0]-quitMessageW_-16)/2, 72 ), Size2D(quitMessageW_+16, 32) ); g.drawString(quitMessage_, Vector2D( (SCREEN_SIZE[0]-quitMessageW_)/2, 82 ), font::FNT_NORMAL); g.drawWindow( Vector2D( (SCREEN_SIZE[0]-yesNoW_-16)/2, 120 ), Size2D(yesNoW_+16, 48) ); g.drawCursor( Vector2D( (SCREEN_SIZE[0]-yesNoW_-8)/2, cursor()*CURSOR_H + 128 ) + cursorMove(), Size2D(yesNoW_+8, 16) ); g.drawString(yes_, Vector2D( (SCREEN_SIZE[0]-yesNoW_)/2, 130 ), font::FNT_NORMAL); g.drawString(no_ , Vector2D( (SCREEN_SIZE[0]-yesNoW_)/2, 146 ), font::FNT_NORMAL); break; default: break; } }
int ImageLoad(Image *i, const unsigned char *data, size_t size) { if (!i) { X2(bad_arg, "NULL image pointer"); } if (!data) { X2(bad_arg, "NULL data pointer"); } if (size == 0) { X2(bad_arg, "size must be non-zero"); } if (size > INT_MAX) { X2(bad_size, "stb_image cannot load more than INT_MAX bytes in any one image"); } unsigned char *uc; int x, y, comp; uc = stbi_load_from_memory(data, (int) size, &x, &y, &comp, RGBA_CHANNELS); if (!uc) { X(stbi_load_from_memory); } i->size = Size2D((size_t) x, (size_t) y); i->elements = i->size.x * i->size.y; i->bytes = i->elements * RGBA_SIZE; i->pixels = uc; return 1; err_stbi_load_from_memory: err_bad_size: err_bad_arg: return 0; }
//void putFontStringIntoFramebuffer(char *framebuffer, char *str, int len, int destX, int destY, int vga_color, unsigned char *font, int sizeX, int sizeY){ void fbPutString(char *framebuffer, const char *str, int len, Point destination, int vga_color, Font font){ int sizeX = font.getSizeX(); int sizeY = font.getSizeY(); for(int i=0;i<len;i++){ fbPutGlyph(framebuffer, font.getGlyph(str[i]), Size2D(sizeX, sizeY), Point(destination.getX()+(sizeX * i), destination.getY()), vga_color); } }
void Graphics2D::drawWallpaper(Vector2D const& dstP, Size2D const& dstS) { Image const& sys = getSystemGraphic(); Vector2D backP = Vector2D(0, 32) + 1; Size2D backS = Size2D(16, 16) - 1; switch( getOwner().getProject().wallpaperType() ) { case model::Wallpaper::TILE: { Size2D align = dstS / backS; Size2D remainS = dstS % backS; Vector2D remainP = align * backS; Size2D it; for(it[0] = 0; it[0] < align[0]; it[0]++) { for(it[1] = 0; it[1] < align[1]; it[1]++) { drawImage(sys, dstP + backS*it, backP, backS); } } // draw wallpaper unaligned space if(!remainS[0]) { for(it[1] = 0; it[1] < align[1]; it[1]++) { drawImage(sys, Vector2D(dstP[0] + remainP[0], dstP[1] + backS[1]*it[1]), backP, Size2D(remainS[0], backS[1]) ); } } if(!remainS[1]) { for(it[0] = 0; it[0] < align[0]; it[0]++) { drawImage(sys, Vector2D(dstP[0] + backS[0]*it[0], dstS[1] + remainP[1]), backP, Size2D(backS[0], remainS[1]) ); } } if( (!remainS[0]) && (!remainS[1]) ) { drawImage(sys, dstS + remainP, backP, remainS); } } break; case model::Wallpaper::ZOOM: drawImage(sys, dstP, dstS, backP, backS); break; default: break; } }
UIWidget::UIWidget(std::weak_ptr<Window> parent_window) : window(parent_window) { cache_texture = std::make_shared<SDLTexture>(parent_window, Size2D(0,0)); on_display_mode_changed.SubscribeForever([this](){ if(display_mode != DisplayMode::Invisible) SetNeedsRedrawing(); auto p = parent.lock(); if(p) p->OnChildVisibilityChanged(); }); }
void Item::draw(Graphics2D& g) { model::Project& proj = getOwner().getProject(); model::SaveData& lsd = proj.getLSD(); model::DataBase& ldb = proj.getLDB(); std::ostringstream ss; switch( cursorNum() ) { case 1: { // select item std::map< uint16_t, model::SaveData::Item >& itemList = lsd.item(); structure::Array2D const& item = ldb[13]; g.drawWindow( Vector2D(0, 0), Size2D(SCREEN_SIZE[0], 32) ); g.drawWindow( Vector2D(0, 32), SCREEN_SIZE - Size2D(0, 32) ); g.drawCursor( Vector2D(4, 42) + Vector2D( cursor() % 2 * 160, cursor() / 2 * CURSOR_H ), Size2D(152, CURSOR_H) ); int index = 0; for(std::map< uint16_t, model::SaveData::Item >::const_iterator it = itemList.begin(); it != itemList.end(); ++it) { Vector2D base = Vector2D(8, 42) + Vector2D( index % 2 * 160, index / 2 * CURSOR_H ); if( cursor() == index ) { g.drawString( item[it->first][2], Vector2D(8, 10) ); } g.drawString(item[it->first][1], base); ss.str(""); ss << ":" << std::setw(2) << it->second.num; g.drawString( ss.str(), base + Vector2D( font::HALF_FONT_W*21, 0 ) ); index++; } } break; case 2: // select char break; } }
std::shared_ptr<SDLTextTexture> TextRenderer::Render(std::weak_ptr<Window> w,FontParams fp, std::string text){ auto parent_window = w.lock(); // Split the text into lines. std::vector<std::string> lines = Utilities::SplitString(text,"\n"); // Buffers. std::vector<SDL_Surface*> surfaces; std::vector<std::shared_ptr<SDLTexture>> textures; // For each line of text for(auto& l : lines){ // Workaround for rendering empty strings if(l == "") l = " "; // Ask SDL_TTF to render a line SDL_Surface* surf = TTF_RenderUTF8_Blended(GetFont(fp), l.c_str(), SDL_Color{255,255,255,255}); if(!surf){ std::cout << "Warning: TTF_RenderUTF8_Blended failed " << TTF_GetError() << std::endl; continue; } // Use SDLFix to premultiply alpha SDLFix::PremultiplySurface32RGBA(surf); // Store the surface in buffer. surfaces.push_back(surf); } int totalh = 0, maxw = 0; // When all surfaces are ready, for each surface for(auto& surf : surfaces){ // create corresponding texture. textures.push_back(std::make_shared<SDLTextTexture>(w, surf)); SDL_FreeSurface(surf); // Calculate total size Size2D size = textures.back()->GetSize(); totalh += size.height; if(size.width >= maxw) maxw = size.width; } // Prepare the result texture auto res = std::make_shared<SDLTextTexture>(w,Size2D(maxw,totalh)); // Create a helper drawcontext DrawContext dc(parent_window->GetWindow(), parent_window ->GetRenderer(), nullptr, 0,0,maxw,totalh); // We'll be drawing onto the result texture dc.Push(res,maxw,totalh); dc.Clear(); int currenty = 0; for(auto& texture : textures){ dc.DrawTexture(texture,Point2D(0,currenty)); currenty += texture->GetSize().height; } dc.Pop(); return res; }
void UIPathSelector::Init() { child_button = UIButton::Create(window,"..."); child_entry = UITextEntry::Create(window,path); Insert(child_entry, UIBox::PackMode::WIDE); Insert(child_button, UIBox::PackMode::TIGHT); child_button->SetBorder(false); child_button->SetCustomSize(Size2D(16,16)); child_button->SetInnerMargin(0); subscriptions += child_button->on_clicked.Subscribe([this](){ OpenDialog(); }); subscriptions += child_entry->on_edited.Subscribe([this](){ path = child_entry->GetText(); }); }
int WindsimInit(Windsim *sim, World *w, size3D size) { if (!sim) { X2(bad_arg, "NULL sim pointer"); } if (!w) { X2(bad_arg, "NULL world pointer"); } if (size.x < 1) { X2(bad_arg, "size.x must be > 0"); } if (size.y < 1) { X2(bad_arg, "size.y must be > 0"); } if (size.z < 1) { X2(bad_arg, "size.z must be > 0"); } size2D xy = Size2D(size.x, size.y); sim->world = w; sim->size = size; sim->elements = size.x * size.y * size.z; sim->height = WINDSIM_HEIGHT; /* a 3D grid of cells covering the map surface */ sim->cell = malloc(sizeof(Windcell) * sim->elements); if (!sim->cell) { X(alloc_sim_cells); } /* a 1D grid of cells extending along the z axis away from the surface * of the planet, for graphing simulation state by altitude. */ sim->graphAtmosphere1DCell = malloc(sizeof(GraphAtmosphere1DCell) * sim->size.z); if (!sim->graphAtmosphere1DCell) { X(alloc_graph_cells); } /* 2D buffers for sampling information from the world map at a lower * resolution */ if (!Doubles2DInit(&sim->elevation, xy)) { X(Doubles2DInit_elevation); } if (!Doubles2DInit(&sim->sunlight, xy)) { X(Doubles2DInit_sunlight); } if (!Doubles2DInit(&sim->albedo, xy)) { X(Doubles2DInit_albedo); } return 1; err_Doubles2DInit_albedo: Doubles2DTeardown(&sim->sunlight); err_Doubles2DInit_sunlight: Doubles2DTeardown(&sim->elevation); err_Doubles2DInit_elevation: free(sim->graphAtmosphere1DCell); err_alloc_graph_cells: free(sim->cell); err_alloc_sim_cells: err_bad_arg: return 0; }
ResultsUI::ResultsUI(SpriteList *spriteList) : Screen(spriteList) { mHeaderFont = FontManager::Load("definitionBody"); mHeaderBar = new HeaderBar(mSpriteList, mHeaderFont); mLeaderboard = new Leaderboard(mSpriteList); mSummary = new Summary(mSpriteList); mSummary->mVisible = false; mSummary->mActive = false; mLeaderboard->mVisible = false; mLeaderboard->mActive = false; mSummary->mVisible = false; mSummary->mActive = false; mFillRectangle = new UI::Rectangle(Vec2(-2, -2), Vec2((float)::Screen::Width() + 4, 36), Color(0xff, 0x50, 0x50, 0x50), Color::Black, 2); mFillRectangle->mHitRect = Rect2D(Point2D(-1, -1), Size2D(0,0)); mCloseTexture = Texture::Load("icon_close.png"); mCloseButton = new UI::ImageButton(mCloseTexture, Vec2(::Screen::Width() - 48.0f, 0), Vec2(48, 48)); AddUIItem(mFillRectangle); AddUIItem(mCloseButton); mHeaderBar->AddButton("High scores", mLeaderboard); mHeaderBar->AddButton("Summary", mSummary); mCloseButton->OnPress = [this] () { Activate(false); if(OnClose != null) { OnClose(); } }; Activate(false); this->mZIndex = 2; mHeaderBar->mZIndex = 3; mLeaderboard->mZIndex = 0; mSummary->mZIndex = 0; }
void Graphics2D::drawWindowType(Vector2D const& dstP, Size2D const& dstS, WindowType type) { Vector2D frontP(32*type, 0), backP; Vector2D backS; // background image size Image const& sys = getSystemGraphic(); switch(type) { case WINDOW: backP(32*0, 0); backS = 32; break; case CURSOR_0: case CURSOR_1: backP(frontP[0] + CORNER, frontP[1] + CORNER); backS = NON_FRAME; break; default: return; } // draw wallpaper and side frame switch( getOwner().getProject().wallpaperType() ) { case model::Wallpaper::TILE: { // draw wallpaper // draw wallpaper aligned space Size2D align = dstS / backS; Size2D remainS = dstS % backS; Vector2D remainP = align * backS; Size2D it; for(it[0] = 0; it[0] < align[0]; it[0]++) { for(it[1] = 0; it[1] < align[1]; it[1]++) { drawImage(sys, dstP + backS*it, backP, backS); } } // draw wallpaper unaligned space if(!remainS[0]) { for(it[1] = 0; it[1] < align[1]; it[1]++) { drawImage(sys, Vector2D(dstP[0] + remainP[0], dstP[1] + backS[1]*it[1]), backP, Size2D(remainS[0], backS[1]) ); } } if(!remainS[1]) { for(it[0] = 0; it[0] < align[0]; it[0]++) { drawImage(sys, Vector2D(dstP[0] + backS[0]*it[0], dstS[1] + remainP[1]), backP, Size2D(backS[0], remainS[1]) ); } } if( (!remainS[0]) && (!remainS[1]) ) { drawImage(sys, dstS + remainP, backP, remainS); } // draw side frame // draw top and bottom frame aligned align( (dstS[0]-FRAME_W*2) / FRAME_L, (dstS[1]-FRAME_W*2) / FRAME_L); for(it[0] = 0; it[0] < align[0]; it[0]++) { // top frame drawImage(sys, Vector2D(dstP[0] + FRAME_W + FRAME_L * it[0], dstP[1]), Vector2D(frontP[0]+FRAME_W, frontP[1]), Size2D(FRAME_L, FRAME_W) ); // bottom frame drawImage(sys, Vector2D(dstP[0] + FRAME_W + FRAME_L * it[0], dstP[1] + dstS[1]-FRAME_W), Vector2D(frontP[0]+FRAME_W, frontP[1]+C_AND_N), Size2D(FRAME_L, FRAME_W) ); } // draw left and bottom frame aligned for(it[1] = 0; it[1] < align[1]; it[1]++) { // draw left drawImage(sys, Vector2D(dstP[0], dstP[1]+FRAME_W + FRAME_L*it[1]), Vector2D(frontP[0], frontP[1]+FRAME_W), Size2D(FRAME_W, FRAME_L) ); // draw right drawImage(sys, Vector2D(dstP[0] + dstS[0]-FRAME_W, dstP[1]+FRAME_W + FRAME_L*it[1]), Vector2D(frontP[0]+C_AND_N, frontP[1]+FRAME_W), Size2D(FRAME_W, FRAME_L) ); } // draw frame unaligned remainS( (dstS[0]-FRAME_W*2) % FRAME_L, (dstS[1]-FRAME_W*2) % FRAME_L ); remainP(align[0] * FRAME_L + FRAME_W, align[1] * FRAME_L + FRAME_W); // top frame drawImage(sys, Vector2D(dstP[0]+remainP[0], dstP[1]), Vector2D(frontP[0]+FRAME_W, frontP[1]), Size2D(remainS[0], FRAME_W) ); // bottom frame drawImage(sys, Vector2D(dstP[0]+remainP[0], dstP[1] + dstS[1]-FRAME_W), Vector2D(frontP[0]+FRAME_W, frontP[1]+C_AND_N), Size2D(remainS[0], FRAME_W) ); // left frame drawImage(sys, Vector2D(dstP[0], dstP[1]+remainP[1]), Vector2D(frontP[0], frontP[1]+FRAME_W), Size2D(FRAME_W, remainS[1]) ); // right frame drawImage(sys, Vector2D(dstP[0] + dstS[0]-FRAME_W, dstP[1]+remainP[1]), Vector2D(frontP[0]+C_AND_N, frontP[1]+FRAME_W), Size2D(FRAME_W, remainS[1]) ); } break; case model::Wallpaper::ZOOM: { // draw wallpaper drawImage(sys, dstP, dstS, backP, backS); // draw top frame drawImage(sys, Vector2D(dstP[0]+FRAME_W, dstP[1]), Size2D(dstS[0]-FRAME_W, FRAME_W), Vector2D(frontP[0]+FRAME_W, frontP[1]), Size2D(FRAME_L, FRAME_W) ); // draw left frame drawImage(sys, Vector2D(dstP[0], dstP[1]+FRAME_W), Size2D(FRAME_W, dstS[1]-FRAME_W), Vector2D(frontP[0], frontP[1]+FRAME_W), Size2D(FRAME_W, FRAME_L) ); // draw right frame drawImage(sys, Vector2D(dstP[0] + dstS[0]-FRAME_W, dstP[1]+FRAME_W), Size2D(FRAME_W, dstS[1]-FRAME_W), Vector2D(frontP[0]+C_AND_N, frontP[1]+FRAME_W), Size2D(FRAME_W, FRAME_L) ); // draw bottom frame drawImage(sys, Vector2D(dstP[0]+FRAME_W, dstP[1] + dstS[1]-FRAME_W), Size2D(dstS[0]-FRAME_W, FRAME_W), Vector2D(frontP[0]+FRAME_W, frontP[1]+C_AND_N), Size2D(FRAME_L, FRAME_W) ); } break; default: rpg2k_assert(false); } Vector2D cornerSize(CORNER, CORNER); // draw corner frame drawImage(sys, dstP, frontP, cornerSize); drawImage(sys, Vector2D(dstP[0] + dstS[0] - CORNER, dstP[1]), Vector2D(frontP[0] + C_AND_N, frontP[1]), cornerSize ); drawImage(sys, Vector2D(dstP[0], dstP[1] + dstS[1] - CORNER), Vector2D(frontP[0], frontP[1] + C_AND_N), cornerSize ); drawImage(sys, Vector2D(dstP[0] + dstS[0] - CORNER, dstP[1] + dstS[1] -CORNER), Vector2D(frontP[0] + C_AND_N, frontP[1] + C_AND_N), cornerSize ); }
void UITextEntry::Init(){ SetMinimalSize(Size2D(10, fontsize + 2)); UpdateText(); }
void UITextEntry::SetFontSize(int size){ fontsize = size; SetMinimalSize(Size2D(10, fontsize + 2)); UpdateText(); }
void NEConvolutionLayer::configure(const ITensor *input, const ITensor *weights, const ITensor *biases, ITensor *output, const PadStrideInfo &conv_info, const WeightsInfo &weights_info) { ARM_COMPUTE_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::QS8, DataType::QS16, DataType::F16, DataType::F32); ARM_COMPUTE_ERROR_ON_MISMATCHING_DATA_TYPES(input, weights); ARM_COMPUTE_ERROR_ON_MISMATCHING_FIXED_POINT(input, weights); ARM_COMPUTE_ERROR_ON(!weights_info.are_reshaped() && weights->info()->dimension(2) != input->info()->dimension(2)); ARM_COMPUTE_ERROR_ON(weights->info()->num_dimensions() > 4); if(biases != nullptr) { ARM_COMPUTE_ERROR_ON_MISMATCHING_DATA_TYPES(input, biases); ARM_COMPUTE_ERROR_ON_MISMATCHING_FIXED_POINT(input, biases); ARM_COMPUTE_ERROR_ON(!weights_info.are_reshaped() && biases->info()->dimension(0) != weights->info()->dimension(3)); ARM_COMPUTE_ERROR_ON(biases->info()->num_dimensions() > 1); } const DataType dt = input->info()->data_type(); const int fixed_point_position = input->info()->fixed_point_position(); _has_bias = (biases != nullptr); _are_weights_reshaped = weights_info.are_reshaped(); // Get parameters from conv_info unsigned int stride_x = 0; unsigned int stride_y = 0; std::tie(stride_x, stride_y) = conv_info.stride(); // Get convolved dimensions unsigned int conv_w = 0; unsigned int conv_h = 0; const unsigned int kernel_width = (_are_weights_reshaped) ? weights_info.kernel_size().first : weights->info()->dimension(0); const unsigned int kernel_height = (_are_weights_reshaped) ? weights_info.kernel_size().second : weights->info()->dimension(1); std::tie(conv_w, conv_h) = scaled_dimensions(input->info()->dimension(0), input->info()->dimension(1), kernel_width, kernel_height, conv_info); // Check if its a "fully connected" convolution, i.e. the output size is 1x1xnum_kernels _is_fully_connected_convolution = ((conv_w == 1) && (conv_h == 1)); #if defined(__arm__) if(NEScheduler::get().cpu_info().CPU == CPUTarget::ARMV7 && dt == DataType::F32) { _mm_optimised_kernel = support::cpp14::make_unique<NEGEMMAArch32Kernel>(); std::cout << std::endl <<"line 157: _mm_optimised_kernel is NEGEMMAArch32Kernel" << std::endl; } #elif defined(__aarch64__) if(NEScheduler::get().cpu_info().CPU >= CPUTarget::ARMV8 && dt == DataType::F32) { _mm_optimised_kernel = support::cpp14::make_unique<NEGEMMAArch64Kernel>(); std::cout << std::endl <<"line 163: _mm_optimised_kernel is NEGEMMAArch64Kernel" << std::endl; } #endif /* defined(__arm__) || defined(__aarch64__) */ unsigned int mat_weights_cols = weights->info()->dimension(3); unsigned int mat_weights_rows = weights->info()->dimension(0) * weights->info()->dimension(1) * weights->info()->dimension(2) + (_has_bias ? 1 : 0); // Reshape weights if needed if(_mm_optimised_kernel != nullptr) { if(_are_weights_reshaped) { mat_weights_cols = weights_info.num_kernels(); mat_weights_rows = weights->info()->dimension(1); } else { TensorShape reshaped_weights_shape{ mat_weights_cols, mat_weights_rows }; // Create tensor to store the reshaped weights _weights_reshaped.allocator()->init(TensorInfo(reshaped_weights_shape, 1, dt, fixed_point_position)); _reshape_weights.configure(weights, biases, &_weights_reshaped, false /* 1xW transpose */); weights = &_weights_reshaped; } } else { if(_are_weights_reshaped) { if(_is_fully_connected_convolution) { mat_weights_cols = weights_info.num_kernels(); mat_weights_rows = weights->info()->dimension(1); } else { const unsigned int transpose_width = 16 / input->info()->element_size(); mat_weights_cols = weights_info.num_kernels(); mat_weights_rows = weights->info()->dimension(0) / transpose_width + (_has_bias ? 1 : 0); } } else { TensorShape reshaped_weights_shape; if(_is_fully_connected_convolution) { reshaped_weights_shape = TensorShape{ mat_weights_cols, mat_weights_rows }; } else { // Create tensor to store transposed weights const float transpose_width = 16.0f / input->info()->element_size(); reshaped_weights_shape = TensorShape{ mat_weights_rows *static_cast<unsigned int>(transpose_width), static_cast<unsigned int>(std::ceil(mat_weights_cols / transpose_width)) }; } // Create tensor to store the reshaped weights _weights_reshaped.allocator()->init(TensorInfo(reshaped_weights_shape, 1, dt, fixed_point_position)); _reshape_weights.configure(weights, biases, &_weights_reshaped, !_is_fully_connected_convolution /* 1xW transpose */); weights = &_weights_reshaped; } } // Create tensor to store im2col reshaped inputs const unsigned int mat_input_cols = mat_weights_rows; const unsigned int mat_input_rows = conv_w * conv_h; TensorShape shape_im2col(input->info()->tensor_shape()); shape_im2col.set(0, mat_input_cols); shape_im2col.set(1, mat_input_rows); shape_im2col.set(2, 1); _input_im2col_reshaped.allocator()->init(TensorInfo(shape_im2col, 1, dt, fixed_point_position)); _memory_group.manage(&_input_im2col_reshaped); // Create tensor (interleave) to prepare input tensor for GEMM if(!_is_fully_connected_convolution && _mm_optimised_kernel == nullptr) { TensorShape shape_interleaved(shape_im2col); shape_interleaved.set(0, shape_interleaved.x() * 4); shape_interleaved.set(1, std::ceil(shape_interleaved.y() / 4.f)); _input_interleaved_reshaped.allocator()->init(TensorInfo(shape_interleaved, 1, dt, fixed_point_position)); _memory_group.manage(&_input_interleaved_reshaped); } // Create GEMM output tensor TensorShape shape_gemm(_input_im2col_reshaped.info()->tensor_shape()); shape_gemm.set(0, mat_weights_cols); shape_gemm.set(1, mat_input_rows); _gemm_output.allocator()->init(TensorInfo(shape_gemm, 1, dt, fixed_point_position)); _memory_group.manage(&_gemm_output); // Configure kernels _input_im2col_kernel.configure(input, &_input_im2col_reshaped, Size2D(kernel_width, kernel_height), conv_info, _has_bias); #if defined(__arm__) || defined(__aarch64__) if(_mm_optimised_kernel != nullptr) { struct CPUInfo ci = NEScheduler::get().cpu_info(); const int M = _gemm_output.info()->tensor_shape().y(); const int N = _gemm_output.info()->tensor_shape().x(); const int K = _input_im2col_reshaped.info()->tensor_shape().x(); #if defined(__arm__) GemmInterleaved<sgemm_8x6, float, float> gemm(&ci, M, N, K, false, false); #elif defined(__aarch64__) GemmInterleaved<sgemm_12x8, float, float> gemm(&ci, M, N, K, false, false); #endif /* defined(__arm__) || defined(__aarch64__) */ constexpr size_t alignment = 4096; _workspace.allocator()->init(TensorInfo(TensorShape{ (gemm.get_working_size() + alignment - 1) * NEScheduler::get().num_threads() }, 1, DataType::U8)); _memory_group.manage(&_workspace); // Configure matrix multiplication kernel if(_is_fully_connected_convolution) { _mm_optimised_kernel->configure(&_input_im2col_reshaped, weights, &_gemm_output, &_workspace, 1.f, 0.f); } else { _mm_optimised_kernel->configure(&_input_im2col_reshaped, weights, &_gemm_output, &_workspace); } _workspace.allocator()->allocate(); } else #endif /* defined(__arm__) || defined(__aarch64__) */ { if(_is_fully_connected_convolution) { _mm_kernel.configure(&_input_im2col_reshaped, weights, &_gemm_output, 1.0f); } else { _input_interleave_kernel.configure(&_input_im2col_reshaped, &_input_interleaved_reshaped); _mm_kernel.configure(&_input_interleaved_reshaped, weights, &_gemm_output, 1.0f); _input_interleaved_reshaped.allocator()->allocate(); } } _input_im2col_reshaped.allocator()->allocate(); _output_col2im_kernel.configure(&_gemm_output, output, Size2D(conv_w, conv_h)); _gemm_output.allocator()->allocate(); ARM_COMPUTE_ERROR_ON_MSG((output->info()->dimension(0) != conv_w) || (output->info()->dimension(1) != conv_h), "Output shape does not match the expected one"); // Allocate intermediate tensor if(!_are_weights_reshaped) { _weights_reshaped.allocator()->allocate(); } }
void Skill::draw(Graphics2D& g) { model::Project& proj = getOwner().getProject(); // model::SaveData& lsd = proj.getLSD(); model::DataBase& ldb = proj.getLDB(); std::ostringstream ss; switch( cursorNum() ) { case 2: { // select skill structure::Array2D const& skill = ldb[12]; g.drawWindow( Vector2D(0, 32*0), Size2D(SCREEN_SIZE[0], 32) ); if( cursor() != (int)idList_.size() ) { g.drawString( skill[ idList_[ cursor() ] ][2], Vector2D(8, 10) ); } g.drawWindow( Vector2D(0, 32*1), Size2D(SCREEN_SIZE[0], 32) ); // name Vector2D base(8, 32 + 10); g.drawString( proj.name(curCharID_), base ); // level base += Vector2D( font::HALF_FONT_W*14, 0 ); g.drawString( ldb.vocabulary(128), base, font::FNT_STATUS ); base += Vector2D( font::FULL_FONT_W*1, 0 ); ss.str(""); ss << proj.level(curCharID_); g.drawString( ss.str(), base ); // condition base += Vector2D( font::HALF_FONT_W*5, 0 ); g.drawString( proj.condition(curCharID_), base, proj.conditionColor(curCharID_) ); // HP base += Vector2D( font::HALF_FONT_W*10, 0 ); g.drawString( ldb.vocabulary(129), base, font::FNT_STATUS ); base += Vector2D( font::FULL_FONT_W*1, 0 ); ss.str(""); ss << std::setw(3) << proj.hp(curCharID_) << "/" << std::setw(3) << proj.param(curCharID_, Param::HP); g.drawString( ss.str(), base ); // MP base += Vector2D( font::HALF_FONT_W*9, 0 ); g.drawString( ldb.vocabulary(130), base, font::FNT_STATUS ); base += Vector2D( font::FULL_FONT_W*1, 0 ); ss.str(""); ss << std::setw(3) << proj.mp(curCharID_) << "/" << std::setw(3) << proj.param(curCharID_, Param::MP); g.drawString( ss.str(), base ); g.drawWindow( Vector2D(0, 32*2), SCREEN_SIZE - Size2D(0, 32*2) ); g.drawCursor( Vector2D(4, 72) + Vector2D( cursor() % 2 * 160, cursor() / 2 * CURSOR_H ), Size2D(152, CURSOR_H) ); int index = 0; for(std::vector< uint16_t >::const_iterator it = idList_.begin(); it != idList_.end(); ++it) { if( *it == 0 ) break; base = Vector2D(8, 74) + Vector2D( index % 2 * 160, index / 2 * CURSOR_H ); g.drawString(skill[*it][1], base); ss.str(""); ss << "-" << std::setw(3) << skill[*it][11].get<int>(); g.drawString( ss.str(), base + Vector2D( font::HALF_FONT_W*20, 0 ) ); index++; } } break; case 3: // select char break; } }