void Ball::RenderBall(SDL_Renderer* sdlRenderer, SDL_Texture* pointDest, SDL_Texture* ballDest){ // if(CApp::drawPath){ // Point tempPoint(x , y); // pointAry.push_back(tempPoint); // } // for(int i = 0; i < pointAry.size(); i++){ // pointAry[i].renderPoint(sdlRenderer); // } if(CApp::drawPath){ SDL_Rect tempRect; tempRect.x = x; tempRect.y = y; tempRect.w = 1; tempRect.h = 1; SDL_SetRenderTarget(sdlRenderer, pointDest);//pointDest is the texture which to draw points on the positions that the ball has been on. SDL_SetRenderDrawColor(sdlRenderer, 0, 0, 0, 255); SDL_RenderFillRect(sdlRenderer,&tempRect); SDL_SetRenderDrawColor(sdlRenderer,255,255,255,255); } SDL_SetRenderTarget(sdlRenderer, ballDest); SDL_Rect DestR = {round(x - (Width/2.0)) + CApp::scrollModifierX ,round(y - (Height/ 2.0)) + CApp::scrollModifierY,Width, Height}; CTexture::OnDraw(sdlRenderer,Tex_Ball,&DestR); SDL_SetRenderTarget(sdlRenderer, NULL); }
void TransformableViewScene::Render(SDL_Renderer *renderer) { SDL_Rect srcrect; srcrect.x = 0; srcrect.y = 0; srcrect.w = targetSize.x; srcrect.h = targetSize.y; SDL_Rect dstrect; dstrect.x = origin.x; dstrect.y = origin.y; dstrect.w = size.x; dstrect.h = size.y; auto target = SDL_GetRenderTarget(renderer); int res = SDL_SetRenderTarget(renderer, renderTarget.get()); Uint8 r,g,b,a; SDL_GetRenderDrawColor(renderer, &r, &g, &b, &a); SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0); SDL_RenderClear(renderer); SDL_SetRenderDrawColor(renderer, r, g, b, a); scene->Render(renderer); res = SDL_SetRenderTarget(renderer, target); res = SDL_SetTextureAlphaMod(renderTarget.get(), opacity * 255); //SDL_RenderCopy(renderer, renderTarget.get(), &srcrect, &dstrect); SDL_RenderCopyEx(renderer, renderTarget.get(), &srcrect, &dstrect, rotation, &axis, SDL_FLIP_NONE); }
static void DrawBackgroundWithRenderer( GraphicsDevice *g, SDL_Renderer *renderer, SDL_Texture *target, SDL_Texture *src, DrawBuffer *buffer, const HSV tint, const struct vec2 pos, GrafxDrawExtra *extra) { SDL_RendererInfo ri; if (SDL_GetRendererInfo(renderer, &ri) != 0) { LOG(LM_GFX, LL_ERROR, "cannot set render target: %s", SDL_GetError()); } else { if (!(ri.flags & SDL_RENDERER_TARGETTEXTURE)) { LOG(LM_GFX, LL_ERROR, "renderer does not support render to texture"); } } if (SDL_SetRenderTarget(renderer, target) != 0) { LOG(LM_GFX, LL_ERROR, "cannot set render target: %s", SDL_GetError()); } DrawBackground(g, target, src, buffer, &gMap, tint, pos, extra); if (SDL_SetRenderTarget(renderer, NULL) != 0) { LOG(LM_GFX, LL_ERROR, "cannot set render target: %s", SDL_GetError()); } }
Image* Image::cutFrame(int frame) { if (frame > nframes) { printf("Frame nao existe - %d. Limit: %d\n", frame, nframes); return NULL; } SDL_Renderer* renderer = Game::getGlobalGame()->getRenderer(); // printCut(frame); // Criar surface SDL_Texture* tex = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, cut[0].w, cut[0].h); if(tex == NULL) { printf("SDL_CreateTexture failed: %s\n", SDL_GetError()); return NULL; } SDL_SetRenderTarget(Game::getGlobalGame()->getRenderer(), tex); SDL_RenderCopy(renderer, picture, &cut[frame], 0 ); SDL_SetRenderTarget(Game::getGlobalGame()->getRenderer(), 0); // Desenhar na surface o frame correspondente SDL_Rect offset; offset.x = offset.y = 0; return new Image(tex, 1, NULL, centerX, centerY); }
void Engine::Graphics::draw(Camera * camera_, Sprite *sprite_, int x_, int y_, int width_, int height_, int frame_, int zIndex_) { SDL_Rect dstrect; dstrect.x = x_ - camera_->getX(); dstrect.y = y_ - camera_->getY(); dstrect.w = width_; dstrect.h = height_; //find or create the correct renderlayer struct RenderLayer *layer = getRenderLayer(zIndex_); SDL_SetRenderTarget(renderer, layer->texture); //sets the render target to a texture if (sprite_) { SDL_Rect srcrect; srcrect.x = sprite_->getFrameWidth() * frame_; srcrect.y = 0; srcrect.w = sprite_->getFrameWidth(); srcrect.h = sprite_->getFrameHeight(); SDL_RenderCopy(renderer, sprite_->getTexture(), &srcrect, &dstrect); //render to the texture } else { //draw a purple rectangle SDL_SetRenderDrawColor(renderer, 255, 0, 255, 255); SDL_RenderDrawRect(renderer, &dstrect); } SDL_SetRenderTarget(renderer, NULL); //reset the render target to the renderer }
SDL_Texture* TextureFactory::CreateTiledSprite(Renderer *renderer, SDL_Texture *base, SDL_Rect baseLocation, int newWidth, int newHeight ) { Uint32 format; SDL_QueryTexture(base, &format, nullptr, nullptr, nullptr); SDL_Texture *texture = SDL_CreateTexture(renderer->GetRenderingContext(), format, SDL_TEXTUREACCESS_TARGET, newWidth*baseLocation.w, newHeight*baseLocation.h); SDL_SetRenderTarget(renderer->GetRenderingContext(), texture); SDL_Rect dstLocation; dstLocation.w = baseLocation.w; dstLocation.h = baseLocation.h; for (int x = 0; x < newWidth; ++x) { for (int y = 0; y < newHeight; ++y) { dstLocation.x = x*baseLocation.w; dstLocation.y = y*baseLocation.h; SDL_RenderCopy(renderer->GetRenderingContext(), base, &baseLocation, &dstLocation); } } SDL_SetRenderTarget(renderer->GetRenderingContext(), nullptr); return texture; }
PackedTextures::PackedTextures(SDL_Renderer * ren, std::vector<SDL_Texture *> & texVec, std::vector<SDL_Rect> & srcRect) { int sum_height=0; int max_width = 0; SDL_Rect tRect; tRect.x = 0; for( int i=0; i<texVec.size(); i++) { tRect.w = srcRect[i].w; tRect.h = srcRect[i].h; if( max_width < tRect.w ) max_width = tRect.w; tRect.y = sum_height; sum_height += tRect.h; placements.push_back(tRect); } packedTexture = SDL_CreateTexture(ren, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, max_width, sum_height); SDL_SetTextureBlendMode(packedTexture, SDL_BLENDMODE_NONE); SDL_Texture * pTarget = SDL_GetRenderTarget(ren); printf("Pack prev-renderer: %i\n",pTarget); printf("Pack new-texture: %i\n",packedTexture); SDL_SetRenderTarget(ren, packedTexture); SDL_SetRenderDrawColor(ren, 0, 0, 0, SDL_ALPHA_TRANSPARENT); SDL_RenderClear(ren); for( int i=0; i<texVec.size(); i++) { SDL_RenderCopy(ren, texVec[i], &srcRect[i], &placements[i]); } SDL_SetRenderTarget(ren, pTarget); SDL_SetTextureBlendMode(packedTexture, SDL_BLENDMODE_BLEND); }
void FadeScene::Render(SDL_Renderer *renderer) { SDL_Rect rect; rect.x = 0; rect.y = 0; rect.w = _w; rect.h = _h; auto target = SDL_GetRenderTarget(renderer); int res = SDL_SetRenderTarget(renderer, _renderTarget.get()); _scene->Render(renderer); res = SDL_SetRenderTarget(renderer, target); if (_scene->Running() && _opacity != 255) { _opacity = std::min(_opacity + _speed, 255.0); } else if (!_scene->Running() && _opacity != 0) { _opacity = std::max(_opacity - _speed, 0.0); } res = SDL_SetTextureAlphaMod(_renderTarget.get(), _opacity); SDL_RenderCopy(renderer, _renderTarget.get(), &rect, &rect); }
void Button::SetText(SDL_Renderer* renderer, TTF_Font* font, std::string s, SDL_Color color) { //make the surface (from SDL_ttf) SDL_Surface* surf = TTF_RenderText_Solid(font, s.c_str(), color); if (!surf) { throw(std::runtime_error("Failed to create a TTF surface")); } //convert to texture SDL_Texture* text = SDL_CreateTextureFromSurface(renderer, surf); SDL_FreeSurface(surf); if (!text) { throw(std::runtime_error("Failed to create a TTF texture")); } //get the dimensions & rects int x, y, w, h; SDL_QueryTexture(text, nullptr, nullptr, &w, &h); x = (image.GetClipW() - w) / 2; y = (image.GetClipH() - h) / 2; SDL_Rect src = {0, 0, w, h}; SDL_Rect dst; //draw the text to the background SDL_SetRenderTarget(renderer, image.GetTexture()); for (int i = 0; i < 3; i++) { dst = {x, y + image.GetClipH() * i, w, h}; SDL_RenderCopy(renderer, text, &src, &dst); } SDL_SetRenderTarget(renderer, nullptr); //free the texture SDL_DestroyTexture(text); }
bool Label::onDraw(SDL_Renderer *renderer) { //SDL_Texture *oldTarget; //oldTarget = SDL_GetRenderTarget(renderer); SDL_Texture *oldTarget = SDL_GetRenderTarget(renderer); SDL_SetRenderTarget(renderer, _texture); SDL_SetRenderDrawColor(renderer, bgColor.r, bgColor.g, bgColor.b, bgColor.a); SDL_RenderClear(renderer); SDL_Rect dst = {0, 0, 0, 0}; SDL_QueryTexture(label, NULL, NULL, &dst.w, &dst.h); dst.x = (frame.w - dst.w) / 2; dst.y = (frame.h - dst.h) / 2; dst.w += padding.x + padding.w; dst.h += 8; LOGD("%dx%d%+d%+d\n", dst.x, dst.y, dst.w, dst.h); SDL_RenderCopy(renderer, label, NULL, &dst); SDL_SetRenderDrawColor(renderer, 0,0,0,255); dirty = false; SDL_SetRenderTarget(renderer, oldTarget); }
void Range::generateTexture(SDL_Renderer * renderer) { if(texture != nullptr) { SDL_DestroyTexture(texture); texture = nullptr; } setWidth(value * 2); setHeight(value * 2); SDL_Texture * prevRenderTarget = SDL_GetRenderTarget(renderer); texture = SDL_CreateTexture(renderer,SDL_PIXELFORMAT_UNKNOWN,SDL_TEXTUREACCESS_TARGET,getWidth(),getHeight()); SDL_SetTextureBlendMode(texture,SDL_BLENDMODE_BLEND); SDL_SetRenderTarget(renderer,texture); SDL_SetRenderDrawColor(renderer,0,0,0,0); SDL_RenderClear(renderer); SDL_SetRenderDrawColor(renderer,255,0,0,255); for(double i = 0; i<=360; i+=0.01) { int x = value + value * cos(i); int y = value + value * sin(i); SDL_RenderDrawPoint(renderer,x,y); } SDL_SetRenderTarget(renderer,prevRenderTarget); }
Image* SDLHardwareImage::resize(int width, int height) { if(!surface || width <= 0 || height <= 0) return NULL; SDLHardwareImage *scaled = new SDLHardwareImage(device, renderer); if (!scaled) return NULL; scaled->surface = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, width, height); if (scaled->surface != NULL) { // copy the source texture to the new texture, stretching it in the process SDL_SetRenderTarget(renderer, scaled->surface); SDL_RenderCopyEx(renderer, surface, NULL, NULL, 0, NULL, SDL_FLIP_NONE); SDL_SetRenderTarget(renderer, NULL); // Remove the old surface this->unref(); return scaled; } else { delete scaled; } return NULL; }
static void VL_SDL2_Present(void *surface, int scrlX, int scrlY) { // TODO: Verify this is a VL_SurfaceUsage_FrontBuffer VL_SDL2_ResizeWindow(); SDL_Surface *surf = (SDL_Surface *)surface; SDL_Rect srcr = {(Sint16)scrlX, (Sint16)scrlY, VL_EGAVGA_GFX_WIDTH, VL_EGAVGA_GFX_HEIGHT}; SDL_Rect integerRect = {0, 0, vl_integerWidth, vl_integerHeight}; SDL_Rect renderRect = {(Sint16)vl_renderRgn_x, (Sint16)vl_renderRgn_y, vl_renderRgn_w, vl_renderRgn_h}; SDL_Rect fullRect = {(Sint16)vl_fullRgn_x, (Sint16)vl_fullRgn_y, vl_fullRgn_w, vl_fullRgn_h}; SDL_BlitSurface(surf, &srcr, vl_sdl2_stagingSurface, 0); SDL_UpdateTexture(vl_sdl2_texture, 0, vl_sdl2_stagingSurface->pixels, vl_sdl2_stagingSurface->pitch); SDL_SetRenderTarget(vl_sdl2_renderer, vl_sdl2_scaledTarget); SDL_SetRenderDrawColor(vl_sdl2_renderer, VL_EGARGBColorTable[vl_emuegavgaadapter.bordercolor][0], VL_EGARGBColorTable[vl_emuegavgaadapter.bordercolor][1], VL_EGARGBColorTable[vl_emuegavgaadapter.bordercolor][2], 255); SDL_RenderClear(vl_sdl2_renderer); SDL_RenderCopy(vl_sdl2_renderer, vl_sdl2_texture, 0, &renderRect); SDL_SetRenderTarget(vl_sdl2_renderer, 0); SDL_SetRenderDrawColor(vl_sdl2_renderer, 0, 0, 0, 255); SDL_RenderClear(vl_sdl2_renderer); SDL_RenderSetViewport(vl_sdl2_renderer, 0); SDL_RenderCopy(vl_sdl2_renderer, vl_sdl2_scaledTarget, 0, &fullRect); SDL_RenderPresent(vl_sdl2_renderer); }
void render() { if(quit) return; //clear renderer SDL_SetRenderTarget(renderer, NULL); SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255); SDL_RenderClear(renderer); //clear camera SDL_SetRenderTarget(renderer, camera.game_texture.sdl_texture); SDL_SetRenderDrawColor(renderer, 0, 0, 255, 255); SDL_RenderClear(renderer); render_board(&board); render_striker(&striker); render_chips(); if(game_state == PLAY && striker.state == WITH_PLAYER) { render_orientation(&striker); } //render camera in viewport SDL_SetRenderTarget(renderer, NULL); SDL_Rect dest_rect = { VIEWPORT_X, VIEWPORT_Y, VIEWPORT_HEIGHT, VIEWPORT_WIDTH }; SDL_RenderCopy(renderer, camera.game_texture.sdl_texture, NULL, &dest_rect); if(game_state == MAIN_MENU) { render_main_menu(); } if(game_state == INSTRUCTION) { render_instructions(); } if(game_state == GAME_OVER) { render_game_over_state(); } if(game_state == PLAY && striker.state == WITH_PLAYER) { render_speed(&striker); // render_orientation_text(&striker); } if(game_state == PLAY) { render_main_instruction(); } render_scores(); SDL_RenderPresent(renderer); }
void SDLHardwareRenderDevice::blankScreen() { SDL_SetRenderDrawColor(renderer, background_color.r, background_color.g, background_color.b, background_color.a); SDL_SetRenderTarget(renderer, NULL); SDL_RenderClear(renderer); SDL_SetRenderTarget(renderer, texture); SDL_RenderClear(renderer); return; }
void Cursor::clearRingTexture() { SDL_Renderer *r{Image::sdl_renderer()}; // Clear out the render target for the cursor. SDL_SetRenderTarget(r, m_target); SDL_SetRenderDrawColor(r, 0x00, 0x00, 0x00, 0x0); SDL_RenderClear(r); SDL_SetRenderTarget(r, nullptr); }
/* * Set the pixel at (x, y) to the given value */ void SDLHardwareImage::drawPixel(int x, int y, const Color& color) { if (!surface) return; SDL_SetRenderTarget(renderer, surface); SDL_SetTextureBlendMode(surface, SDL_BLENDMODE_BLEND); SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, color.a); SDL_RenderDrawPoint(renderer, x, y); SDL_SetRenderTarget(renderer, NULL); }
void SpriteBatch::sbSetRenderTarget(SDL_Texture *target) { if(target == nullptr) SDL_SetRenderTarget(__renderer, nullptr); else SDL_SetRenderTarget(__renderer, target); this->__target = target; }
void SDLHardwareImage::fillWithColor(const Color& color) { if (!surface) return; SDL_SetRenderTarget(renderer, surface); SDL_SetTextureBlendMode(surface, SDL_BLENDMODE_BLEND); SDL_SetRenderDrawColor(renderer, color.r, color.g , color.b, color.a); SDL_RenderClear(renderer); SDL_SetRenderTarget(renderer, NULL); }
void SDLRenderer::popTarget() { _targetStack.pop_back(); if(_targetStack.size() > 0) { SDL_SetRenderTarget(_renderer, ((ARC<SDLTexture>)_targetStack.back())->_hwTexture->raw()); } else { SDL_SetRenderTarget(_renderer, nullptr); } }
void XDL_SpriteBatch::Begin()//begin clears the screen and creates a new texture for us to draw to. { SDL_SetRenderDrawColor(_renderer,XDL_Game::_r,XDL_Game::_g,XDL_Game::_b,255); SDL_SetRenderTarget(_renderer, XDL_SpriteBatch::_drawTexture);//target the drawTexture so we can clear it. SDL_RenderCopy(_renderer,_clearTexture,NULL,NULL);//clear it SDL_SetRenderTarget(_renderer, NULL);//then change focus back to the screen SDL_RenderClear(_renderer);//and clear it _thingsToBeDrawn.clear();//remove all items that need to be drawn so we start with a blank slate }
SDL_Texture* Card::loadShadow(SDL_Renderer* r) { SDL_Texture* newTexture = SDL_CreateTexture( r, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, 100 , 100 ); SDL_SetRenderTarget( r, newTexture ); SDL_SetRenderDrawColor( r, 0x20, 0x20, 0x20, 0xFF ); SDL_RenderFillRect( r , NULL ); SDL_SetRenderTarget( r, NULL ); return newTexture; }
void MenuState::draw(double dt){ auto renderer = m_game->renderer(); SDL_SetRenderTarget(renderer, m_drawtex); SDL_SetRenderDrawColor(renderer, 0, 100, 200, 0); SDL_RenderClear(renderer); //return; entityx::ComponentHandle<Position> position; // entityx::ComponentHandle<Drawable> drawable; for(entityx::Entity entity: m_entities.entities_with_components(position)){ (void) entity; glm::vec2 pos = position->position(); auto drawable = entity.component<Drawable>(); auto textitem = entity.component<TextItem>(); if(drawable){ SDL_Rect dest; dest.x = pos.x; dest.y = pos.y; dest.w = drawable->width(); dest.h = drawable->height(); SDL_Rect* src; AnimTemplate anim = drawable->anim(); if (anim.frame_width() == 0 || anim.frame_height() == 0) { src = nullptr; } else { SDL_Rect s; s.x = anim.frame_width() * drawable->animation_index(); s.y = anim.frame_height() * anim.y_index(); s.w = anim.frame_width(); s.h = anim.frame_height(); drawable->tick(dt); src = &s; } SDL_Texture* tex = m_game->res_manager().texture(drawable->texture_key()); (void)tex;(void)dest;(void)src; SDL_RenderCopyEx(m_game->renderer(), tex, src, &dest, 0, nullptr, SDL_FLIP_NONE); } if(textitem){ draw_text(m_game->renderer(), m_game->res_manager(), textitem->text(), textitem->font_key(), pos.x, pos.y, textitem->color()); } } SDL_SetRenderTarget(renderer, nullptr); SDL_RenderCopy(renderer, m_drawtex, &m_camera, nullptr); SDL_RenderPresent(renderer); }
void EmuinoSDL::render() { if (!setup) return; renderTiles(); SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255); SDL_UpdateTexture(screenTexture, NULL, screenSurface->pixels, screenSurface->pitch); // get camera offset int16_t camX = 0, camY = 0; SharedRAM.read(REG_SCROLL_X | 0x8000, &camX, 2); SharedRAM.read(REG_SCROLL_Y | 0x8000, &camY, 2); // render everything on the screen texture such as sprites and tilemaps SDL_SetRenderTarget(renderer, screenTexture); for (int i = 0; i < NUM_TILE_LAYERS; i++) { int16_t offsetX, offsetY; int w = tileMapSurfaces[i]->w; int h = tileMapSurfaces[i]->h; SharedRAM.read(TILE_LAYER_REG(i, TILE_OFFSET_X) | 0x8000, &offsetX, 2); SharedRAM.read(TILE_LAYER_REG(i, TILE_OFFSET_Y) | 0x8000, &offsetY, 2); // add camera offset offsetX -= camX; offsetY -= camY; // hacky repetition, will need to be replaced with proper OpenGL texture repetition offsetX = offsetX % w; if (offsetX < 0) offsetX += w; offsetY = offsetY % h; if (offsetY < 0) offsetY += w; SDL_Rect offsetRect = {offsetX, offsetY, w, h}; SDL_RenderCopy(renderer, tileMapTextures[i], NULL, &offsetRect); offsetRect.x -= w; SDL_RenderCopy(renderer, tileMapTextures[i], NULL, &offsetRect); offsetRect.y -= w; SDL_RenderCopy(renderer, tileMapTextures[i], NULL, &offsetRect); offsetRect.x = offsetX; SDL_RenderCopy(renderer, tileMapTextures[i], NULL, &offsetRect); } SDL_SetRenderTarget(renderer, NULL); // render the screen texture SDL_RenderClear(renderer); SDL_RenderCopy(renderer, screenTexture, NULL, NULL); SDL_RenderPresent(renderer); }
void Box(int x, int y, int w, int h, int angle, int r, int g, int b, int a){ SDL_Rect rect = {x, y, w, h}; SDL_Texture * texture = SDL_CreateTexture(gfx.renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, w, h); SDL_SetRenderTarget(gfx.renderer, texture); SDL_SetRenderDrawColor(gfx.renderer, r, g, b, a); SDL_RenderClear(gfx.renderer); SDL_SetRenderTarget(gfx.renderer, NULL); SDL_RenderCopyEx(gfx.renderer, texture, NULL, &rect, angle, NULL, SDL_FLIP_NONE); SDL_DestroyTexture(texture); }
/** * \fn int displayMap(sInterface *p_interface, sMap *p_map) * \brief Fonction qui initialise les graphismes de la map * * \param *p_interface pointeur vers une structure de type sInterface * \param *p_map pointeur vers une structure de type sMap * \return int représentant le déroulement de la fonction */ int displayMap(sInterface *p_interface, sMap *p_map) { int l_i, l_j; SDL_Rect l_posCase, l_arbre; SDL_Surface *l_sprite; SDL_Texture *l_texture; l_posCase.x = 0; l_posCase.y = 0; l_posCase.h = WINDOW_HEIGHT / CASE_LINE_AMOUNT; l_posCase.w = WINDOW_WIDTH / CASE_COLUMN_AMOUNT; SDL_SetRenderTarget(p_interface->renderer, p_interface->backgroundSprite); SDL_SetRenderDrawColor(p_interface->renderer, 0, 0, 0, 0); SDL_RenderClear(p_interface->renderer); for (l_i = 0; l_i < p_map->mapDimension.height; ++l_i) { for (l_j = 0; l_j < p_map->mapDimension.width; ++l_j) { SDL_RenderCopy(p_interface->renderer, p_interface->caseSprite[0], NULL, &l_posCase); SDL_RenderCopy(p_interface->renderer, p_interface->caseSprite[p_map->path[l_i][l_j].type], NULL, &l_posCase ); if ((l_i == 0 || l_j == 0 || l_i == 9 || l_j == 9) && (p_map->path[l_i][l_j].type == 2)) { l_arbre = l_posCase; //l_arbre.x += (rand() % 10) - 5; //l_arbre.y += (rand() % 10) - 5; l_sprite = IMG_Load("./assets/sprite/tree_0.png"); l_texture = SDL_CreateTextureFromSurface(p_interface->renderer, l_sprite); SDL_FreeSurface(l_sprite); SDL_RenderCopy(p_interface->renderer, l_texture, NULL, &l_arbre); } if (p_map->starting.y == l_i && p_map->starting.x == l_j) { l_sprite = IMG_Load("./assets/sprite/start.png"); l_texture = SDL_CreateTextureFromSurface(p_interface->renderer, l_sprite); SDL_FreeSurface(l_sprite); SDL_RenderCopy(p_interface->renderer, l_texture, NULL, &l_posCase); } if (p_map->ending.y == l_i && p_map->ending.x == l_j) { l_sprite = IMG_Load("./assets/sprite/goal.png"); l_texture = SDL_CreateTextureFromSurface(p_interface->renderer, l_sprite); SDL_FreeSurface(l_sprite); SDL_RenderCopy(p_interface->renderer, l_texture, NULL, &l_posCase); } l_posCase.x += WINDOW_WIDTH / CASE_COLUMN_AMOUNT; } l_posCase.x = 0; l_posCase.y += WINDOW_HEIGHT / CASE_LINE_AMOUNT; } SDL_SetRenderTarget(p_interface->renderer, NULL); return 0; }
void Simulation::Render() { SDL_Renderer *renderer = Game::getGlobalGame()->getRenderer(); Game::getGlobalGame()->setBackgroundColor(0, 0, 0); // Render do Fundo // SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_ADD); SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255); drawBG(background[0], bgOffsetX, bgOffsetY, -0.1, renderer); drawBG(background[1], bgOffsetX, bgOffsetY, -0.13, renderer); drawBG(background[2], bgOffsetX, bgOffsetY, -0.2, renderer); drawBG(background[3], bgOffsetX, bgOffsetY, -0.28, renderer); // background[0]->DrawImage(bgOffsetX*0.10, bgOffsetY*0.10, renderer); // background[1]->DrawImage(bgOffsetX*0.13, bgOffsetY*0.13, renderer); // background[2]->DrawImage(bgOffsetX*0.20, bgOffsetY*0.20, renderer); // background[3]->DrawImage(bgOffsetX*0.28, bgOffsetY*0.28, renderer); // background->DrawImage(bgOffsetX, bgOffsetY, renderer); // background->DrawImage(bgOffsetX + Game::getGlobalGame()->getWidth(), // bgOffsetY + Game::getGlobalGame()->getHeight(), renderer); // // background->DrawImage(bgOffsetX + Game::getGlobalGame()->getWidth(), bgOffsetY, renderer); // background->DrawImage(bgOffsetX, bgOffsetY + Game::getGlobalGame()->getHeight(), renderer); //Just TESTING SDL_SetRenderTarget(renderer, renderCombat); // Limpar textura SDL_SetTextureBlendMode(renderCombat, SDL_BLENDMODE_BLEND); SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0); SDL_RenderClear(renderer); SDL_SetRenderDrawBlendMode(renderer, SDL_BlendMode::SDL_BLENDMODE_NONE); SDL_SetTextureBlendMode(renderCombat, SDL_BLENDMODE_BLEND); simulationWorld->render(); SDL_SetRenderTarget(renderer, 0); // Renderizar imagem de combate na tela SDL_Rect rect; rect.x = -camera->getX(); rect.w = 2048; rect.y = -camera->getY(); rect.h = 2048; SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255); SDL_SetRenderDrawBlendMode(renderer, SDL_BlendMode::SDL_BLENDMODE_NONE); SDL_RenderCopy( renderer, renderCombat, 0, &rect); if(selectedUnit) { filledCircleRGBA( renderer, selectedUnit->getAvgX(), selectedUnit->getAvgY(), 64, 0, 0, 255, 128 ); } }
void Engine::Graphics::flipBuffer() { SDL_RenderClear(renderer); //clears the renderer struct RenderLayer *i = &zeroLayer; while (i != NULL) { SDL_RenderCopy(renderer, i->texture, NULL, NULL); //blits the texture to the renderer SDL_SetRenderTarget(renderer, i->texture); //sets the render target to the texture SDL_RenderClear(renderer); //clears the texture SDL_SetRenderTarget(renderer, NULL); //resets the render target i = i->next; } SDL_RenderPresent(renderer); }
void DrawGame(GameRenderer* g, World* world) { CheckResize(g, world); //Prepare to render to texture. SDL_SetRenderTarget(g->renderer, g->gameTexture); //Clear screen SDL_SetRenderDrawColor( g->renderer, 0xFF, 0xFF, 0xFF, 0xFF ); SDL_RenderClear( g->renderer ); //Draw our grid //Resizing the background grid looks terrible. if(g->zoom >= 0) { DrawBackgroundGrid( g->renderer, g->screenGame.w, g->screenGame.h, &g->gridProps ); } DrawCells(g->renderer, &g->gridProps, world); SDL_RenderPresent( g->renderer ); //Now draw the rest of the screen SDL_SetRenderTarget(g->renderer, NULL); SDL_SetRenderDrawColor( g->renderer, 180, 180, 180, 255 ); SDL_RenderClear( g->renderer ); SDL_RenderCopy(g->renderer, g->gameTexture, NULL, &(g->screenGame)); //Draw the ring of greyed-out game areas around our game area, to represent world wrapping to the user. SDL_SetTextureColorMod(g->gameTexture, 240, 240, 240); int startX = g->screenGame.x - g->screenGame.w; int startY = g->screenGame.y - g->screenGame.h; SDL_Rect current; current.w = g->screenGame.w; current.h = g->screenGame.h; for(int iterX = 0; iterX < 3; ++iterX) { for(int iterY = 0; iterY < 3; ++iterY) { //Don't draw over primary game area. if( ! ((iterX == 1) && (iterY == 1))) { current.x = startX + (current.w * iterX); current.y = startY + (current.h * iterY); SDL_RenderCopy(g->renderer, g->gameTexture, NULL, ¤t); } } } SDL_SetTextureColorMod(g->gameTexture, 255, 255, 255); SDL_RenderPresent(g->renderer); }
void LightSurface::draw() { SDL_Rect offset = this->getRect(); if(Surface::videoBuffer!= NULL && this->getSurface() != NULL) { SDL_BlitSurface(this->getSurface(),&this->clip,Surface::videoBuffer,&offset); } SDL_SetRenderTarget(LightSurface::render, LightSurface::sdlTexture2); SDL_RenderCopy(LightSurface::render, this->texture, &this->clip, &offset); SDL_SetRenderTarget(LightSurface::render, NULL); }