void Text::setBlendMode(SDL_BlendMode blending) { //Set blending function SDL_SetTextureBlendMode(mTexture, blending); }
static void sdl2_init_font(sdl2_video_t *vid, const char *font_path, unsigned font_size) { if (!g_settings.video.font_enable) return; if (font_renderer_create_default(&vid->font_driver, &vid->font_data, *font_path ? font_path : NULL, font_size)) { int r = g_settings.video.msg_color_r * 255; int g = g_settings.video.msg_color_g * 255; int b = g_settings.video.msg_color_b * 255; r = r < 0 ? 0 : (r > 255 ? 255 : r); g = g < 0 ? 0 : (g > 255 ? 255 : g); b = b < 0 ? 0 : (b > 255 ? 255 : b); vid->font_r = r; vid->font_g = g; vid->font_b = b; } else { RARCH_WARN("[SDL]: Could not initialize fonts.\n"); return; } const struct font_atlas *atlas = vid->font_driver->get_atlas(vid->font_data); SDL_Surface *tmp = SDL_CreateRGBSurfaceFrom(atlas->buffer, atlas->width, atlas->height, 8, atlas->width, 0, 0, 0, 0); SDL_Color colors[256]; int i; for (i = 0; i < 256; ++i) { colors[i].r = colors[i].g = colors[i].b = i; colors[i].a = 255; } SDL_Palette *pal = SDL_AllocPalette(256); SDL_SetPaletteColors(pal, colors, 0, 256); SDL_SetSurfacePalette(tmp, pal); SDL_SetColorKey(tmp, SDL_TRUE, 0); vid->font.tex = SDL_CreateTextureFromSurface(vid->renderer, tmp); if (vid->font.tex) { vid->font.w = atlas->width; vid->font.h = atlas->height; vid->font.active = true; SDL_SetTextureBlendMode(vid->font.tex, SDL_BLENDMODE_ADD); } else RARCH_WARN("[SDL]: Failed to initialize font texture: %s\n", SDL_GetError()); SDL_FreePalette(pal); SDL_FreeSurface(tmp); }
bool LTexture::loadFromFile( std::string path ) { //Get rid of preexisting texture free(); //The final texture SDL_Texture* newTexture = NULL; //Load image at specified path SDL_Surface* loadedSurface = IMG_Load( path.c_str() ); if( loadedSurface == NULL ) { printf( "Unable to load image %s! SDL_image Error: %s\n", path.c_str(), IMG_GetError() ); } else { //Convert surface to display format SDL_Surface* formattedSurface = SDL_ConvertSurfaceFormat( loadedSurface, SDL_PIXELFORMAT_RGBA8888, NULL ); if( formattedSurface == NULL ) { printf( "Unable to convert loaded surface to display format! %s\n", SDL_GetError() ); } else { //Create blank streamable texture newTexture = SDL_CreateTexture( gRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STREAMING, formattedSurface->w, formattedSurface->h ); if( newTexture == NULL ) { printf( "Unable to create blank texture! SDL Error: %s\n", SDL_GetError() ); } else { //Enable blending on texture SDL_SetTextureBlendMode( newTexture, SDL_BLENDMODE_BLEND ); //Lock texture for manipulation SDL_LockTexture( newTexture, &formattedSurface->clip_rect, &mPixels, &mPitch ); //Copy loaded/formatted surface pixels memcpy( mPixels, formattedSurface->pixels, formattedSurface->pitch * formattedSurface->h ); //Get image dimensions mWidth = formattedSurface->w; mHeight = formattedSurface->h; //Get pixel data in editable format Uint32* pixels = (Uint32*)mPixels; int pixelCount = ( mPitch / 4 ) * mHeight; //Map colors Uint32 colorKey = SDL_MapRGB( formattedSurface->format, 0, 0xFF, 0xFF ); Uint32 transparent = SDL_MapRGBA( formattedSurface->format, 0x00, 0xFF, 0xFF, 0x00 ); //Color key pixels for( int i = 0; i < pixelCount; ++i ) { if( pixels[ i ] == colorKey ) { pixels[ i ] = transparent; } } //Unlock texture to update SDL_UnlockTexture( newTexture ); mPixels = NULL; } //Get rid of old formatted surface SDL_FreeSurface( formattedSurface ); } //Get rid of old loaded surface SDL_FreeSurface( loadedSurface ); } //Return success mTexture = newTexture; return mTexture != NULL; }
void LTexture::setBlendMode(SDL_BlendMode blending) { /* set blending function */ SDL_SetTextureBlendMode(mTexture, blending); }
int main(int argc, char** argv) { srand(time(0)); int i = 0; SDL_Init(SDL_INIT_VIDEO); SDL_Window* window = SDL_CreateWindow("SDL Practice 6.2", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_SHOWN); SDL_Renderer* rend = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED); SDL_Surface* surface[26]; surface[0] = IMG_Load("alpha\\A.png"); surface[1] = IMG_Load("alpha\\B.png"); surface[2] = IMG_Load("alpha\\C.png"); surface[3] = IMG_Load("alpha\\D.png"); surface[4] = IMG_Load("alpha\\E.png"); surface[5] = IMG_Load("alpha\\F.png"); surface[6] = IMG_Load("alpha\\G.png"); surface[7] = IMG_Load("alpha\\H.png"); surface[8] = IMG_Load("alpha\\I.png"); surface[9] = IMG_Load("alpha\\J.png"); surface[10] = IMG_Load("alpha\\K.png"); surface[11] = IMG_Load("alpha\\L.png"); surface[12] = IMG_Load("alpha\\M.png"); surface[13] = IMG_Load("alpha\\N.png"); surface[14] = IMG_Load("alpha\\O.png"); surface[15] = IMG_Load("alpha\\P.png"); surface[16] = IMG_Load("alpha\\Q.png"); surface[17] = IMG_Load("alpha\\R.png"); surface[18] = IMG_Load("alpha\\S.png"); surface[19] = IMG_Load("alpha\\T.png"); surface[20] = IMG_Load("alpha\\U.png"); surface[21] = IMG_Load("alpha\\V.png"); surface[22] = IMG_Load("alpha\\W.png"); surface[23] = IMG_Load("alpha\\X.png"); surface[24] = IMG_Load("alpha\\Y.png"); surface[25] = IMG_Load("alpha\\Z.png"); SDL_Texture* texture[26]; for(i=0; i<26; ++i) texture[i] = SDL_CreateTextureFromSurface(rend, surface[i]); SDL_Surface* black_surface = SDL_LoadBMP("black.bmp"); SDL_Texture* black_texture = SDL_CreateTextureFromSurface(rend, black_surface); SDL_SetTextureBlendMode(black_texture, SDL_BLENDMODE_BLEND); SDL_SetTextureAlphaMod(black_texture, 50); bool quit = false; SDL_Event event; SDL_Rect window_rect; window_rect.h = WINDOW_HEIGHT; window_rect.w = WINDOW_WIDTH; window_rect.x = 0; window_rect.y = 0; SDL_Rect pos[NUMBER]; for(i = 0; i<NUMBER; ++i) { pos[i].w = surface[0]->w; pos[i].h = surface[0]->h; pos[i].x = rand() % (WINDOW_WIDTH + 1); pos[i].y = rand() % (WINDOW_HEIGHT / 2) + WINDOW_HEIGHT / 2; } int alphabet[NUMBER]; for(i = 0; i<NUMBER; ++i) alphabet[i] = rand() % 27; while(!quit) { while(SDL_PollEvent(&event)) { if(event.type == SDL_QUIT) quit = true; } SDL_RenderCopy(rend, black_texture, NULL, &window_rect); for(i = 0; i<NUMBER; ++i) { SDL_RenderCopy(rend, texture[alphabet[i]], NULL, &pos[i]); pos[i].y += (rand() % 10 + 10); if(pos[i].y > WINDOW_HEIGHT) { alphabet[i] = rand() % 27; pos[i].x = rand() % (WINDOW_WIDTH + 1); pos[i].y = rand() % (WINDOW_HEIGHT + 1); } } SDL_RenderPresent(rend); SDL_Delay(100); } for(i=0; i<26; ++i) SDL_FreeSurface(surface[0]); SDL_FreeSurface(black_surface); SDL_DestroyWindow(window); SDL_Quit(); return 0; }
void display::start( __in_opt const mirra::parameter_t ¶meter ) { std::string title; uint32_t height, width; mirra::parameter_t::const_iterator iter; mirra::object_parameter_t::const_iterator attribute_iter; if(!m_initialized) { THROW_MIRRA_DISPLAY_EXCEPTION(MIRRA_DISPLAY_EXCEPTION_UNINITIALIZED); } if(m_started) { THROW_MIRRA_DISPLAY_EXCEPTION(MIRAR_DISPLAY_EXCEPTION_STARTED); } height = DISPLAY_PARAMETER_DEFAULT_HEIGHT; title = DISPLAY_PARAMETER_DEFAULT_TITLE; width = DISPLAY_PRAAMETER_DEFAULT_WIDTH; iter = parameter.find(OBJECT_DISPLAY); if(iter != parameter.end()) { attribute_iter = iter->second.find(DISPLAY_PARAMETER_HEIGHT); if(attribute_iter != iter->second.end()) { if(attribute_iter->second.type != DATA_UNSIGNED) { THROW_MIRRA_DISPLAY_EXCEPTION_FORMAT(MIRRA_DISPLAY_EXCEPTION_INVALID_PARAMETER, "%s: %s (expecting %s)", DISPLAY_PARAMETER_STRING(DISPLAY_PARAMETER_HEIGHT), DATA_STRING(attribute_iter->second.type), DATA_STRING(DATA_UNSIGNED)); } height = attribute_iter->second.data.uvalue; } attribute_iter = iter->second.find(DISPLAY_PARAMETER_TITLE); if(attribute_iter != iter->second.end()) { if(attribute_iter->second.type != DATA_STRING) { THROW_MIRRA_DISPLAY_EXCEPTION_FORMAT(MIRRA_DISPLAY_EXCEPTION_INVALID_PARAMETER, "%s: %s (expecting %s)", DISPLAY_PARAMETER_STRING(DISPLAY_PARAMETER_TITLE), DATA_STRING(attribute_iter->second.type), DATA_STRING(DATA_STRING)); } title = (attribute_iter->second.data.strvalue ? attribute_iter->second.data.strvalue : STRING_EMPTY); } attribute_iter = iter->second.find(DISPLAY_PARAMETER_WIDTH); if(attribute_iter != iter->second.end()) { if(attribute_iter->second.type != DATA_UNSIGNED) { THROW_MIRRA_DISPLAY_EXCEPTION_FORMAT(MIRRA_DISPLAY_EXCEPTION_INVALID_PARAMETER, "%s: %s (expecting %s)", DISPLAY_PARAMETER_STRING(DISPLAY_PARAMETER_WIDTH), DATA_STRING(attribute_iter->second.type), DATA_STRING(DATA_UNSIGNED)); } width = attribute_iter->second.data.uvalue; } } m_window = SDL_CreateWindow(STRING_CHECK(title), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, WINDOW_INIT_FLAGS); if(!m_window) { THROW_MIRRA_DISPLAY_EXCEPTION_FORMAT(MIRRA_DISPLAY_EXCEPTION_EXTERNAL, "SDL_CreateWindow: %s", SDL_GetError()); } m_window_renderer = SDL_CreateRenderer(m_window, SCALAR_INVALID(int), WINDOW_RENDERER_INIT_FLAGS); if(!m_window_renderer) { THROW_MIRRA_DISPLAY_EXCEPTION_FORMAT(MIRRA_DISPLAY_EXCEPTION_EXTERNAL, "SDL_CreateRenderer: %s", SDL_GetError()); } if(SDL_GetRendererOutputSize(m_window_renderer, &m_renderer_width, &m_renderer_height)) { THROW_MIRRA_DISPLAY_EXCEPTION_FORMAT(MIRRA_DISPLAY_EXCEPTION_EXTERNAL, "SDL_GetRendererOutputSize: %s", SDL_GetError()); } if(SDL_SetRenderDrawBlendMode(m_window_renderer, SDL_BLENDMODE_BLEND)) { THROW_MIRRA_DISPLAY_EXCEPTION_FORMAT(MIRRA_DISPLAY_EXCEPTION_EXTERNAL, "SDL_SetRenderDrawBlendMode: %s", SDL_GetError()); } m_window_texture = SDL_CreateTexture(m_window_renderer, SDL_PIXELFORMAT_BGRA8888, SDL_TEXTUREACCESS_STREAMING, width, height); if(!m_window_texture) { THROW_MIRRA_DISPLAY_EXCEPTION_FORMAT(MIRRA_DISPLAY_EXCEPTION_EXTERNAL, "SDL_CreateTexture: %s", SDL_GetError()); } if(SDL_SetTextureBlendMode(m_window_texture, SDL_BLENDMODE_BLEND)) { THROW_MIRRA_DISPLAY_EXCEPTION_FORMAT(MIRRA_DISPLAY_EXCEPTION_EXTERNAL, "SDL_SetTextureBlendMode: %s", SDL_GetError()); } m_started = true; clear(); }
SDL_Texture * SDL_CreateTextureFromSurface(SDL_Renderer * renderer, SDL_Surface * surface) { const SDL_PixelFormat *fmt; SDL_bool needAlpha; Uint32 i; Uint32 format; SDL_Texture *texture; CHECK_RENDERER_MAGIC(renderer, NULL); if (!surface) { SDL_SetError("SDL_CreateTextureFromSurface() passed NULL surface"); return NULL; } /* See what the best texture format is */ fmt = surface->format; if (fmt->Amask || SDL_GetColorKey(surface, NULL) == 0) { needAlpha = SDL_TRUE; } else { needAlpha = SDL_FALSE; } format = renderer->info.texture_formats[0]; for (i = 0; i < renderer->info.num_texture_formats; ++i) { if (!SDL_ISPIXELFORMAT_FOURCC(renderer->info.texture_formats[i]) && SDL_ISPIXELFORMAT_ALPHA(renderer->info.texture_formats[i]) == needAlpha) { format = renderer->info.texture_formats[i]; break; } } texture = SDL_CreateTexture(renderer, format, SDL_TEXTUREACCESS_STATIC, surface->w, surface->h); if (!texture) { return NULL; } if (format == surface->format->format) { if (SDL_MUSTLOCK(surface)) { SDL_LockSurface(surface); SDL_UpdateTexture(texture, NULL, surface->pixels, surface->pitch); SDL_UnlockSurface(surface); } else { SDL_UpdateTexture(texture, NULL, surface->pixels, surface->pitch); } } else { SDL_PixelFormat *dst_fmt; SDL_Surface *temp = NULL; /* Set up a destination surface for the texture update */ dst_fmt = SDL_AllocFormat(format); temp = SDL_ConvertSurface(surface, dst_fmt, 0); SDL_FreeFormat(dst_fmt); if (temp) { SDL_UpdateTexture(texture, NULL, temp->pixels, temp->pitch); SDL_FreeSurface(temp); } else { SDL_DestroyTexture(texture); return NULL; } } { Uint8 r, g, b, a; SDL_BlendMode blendMode; SDL_GetSurfaceColorMod(surface, &r, &g, &b); SDL_SetTextureColorMod(texture, r, g, b); SDL_GetSurfaceAlphaMod(surface, &a); SDL_SetTextureAlphaMod(texture, a); if (SDL_GetColorKey(surface, NULL) == 0) { /* We converted to a texture with alpha format */ SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND); } else { SDL_GetSurfaceBlendMode(surface, &blendMode); SDL_SetTextureBlendMode(texture, blendMode); } } return texture; }
void hc_map::draw(SDL_Rect *viewport, vector<hc_npc*> npcs, hc_npc *player) { //hc_debug << "tiles: " << background.size() << " from: " << info.height * info.width << endl; if(background.size() != info.height * info.width || info.height * info.width == 0) { return; } if(!background_texture) { background_texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, info.width * 16, info.height * 16); if(!background_texture) { hc_fatal << "Unable to create Texture: " << SDL_GetError() << endl; exit(0); } SDL_SetTextureBlendMode(background_texture, SDL_BLENDMODE_NONE); } if(!objects_texture) { objects_texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, info.width * 16, info.height * 16); if(!objects_texture) { hc_fatal << "Unable to create Texture: " << SDL_GetError() << endl; exit(0); } SDL_SetTextureBlendMode(objects_texture, SDL_BLENDMODE_BLEND); } if(!npc_texture) { npc_texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, info.width * 16, info.height * 16); if(!npc_texture) { hc_fatal << "Unable to create Texture: " << SDL_GetError() << endl; exit(0); } SDL_SetTextureBlendMode(npc_texture, SDL_BLENDMODE_BLEND); } //hc_debug << "Draw map: " << info.name << endl; if(background_changed) { hc_debug << "Rerender background" << endl; SDL_Texture *old_texture; old_texture = SDL_GetRenderTarget(renderer); SDL_SetRenderTarget(renderer, background_texture); SDL_SetRenderDrawColor(renderer, 255, 0, 255, 255); SDL_RenderClear(renderer); for(auto tile:background) { bool around[3][3]; uint32_t here_x, here_y; tile.get_coordinates(&here_x, &here_y); for(int32_t y = -1; y < 2; y++) { for(int32_t x = -1; x < 2; x++) { if(here_x + x == -1 || here_x + x == info.width || here_y + y == -1 || here_y + y == info.height) { around[x + 1][y + 1] = true; } for(auto tile_around:background) // TODO: bad solution, very slow { uint32_t there_x, there_y; tile_around.get_coordinates(&there_x, &there_y); if(there_x == here_x + x && there_y == here_y + y) { if(tile.get_tileset() == tile_around.get_tileset()) { around[x + 1][y + 1] = true; } else { around[x + 1][y + 1] = false; } break; } } } } tile.draw_as_background(tileset, around); } background_changed = false; SDL_SetRenderTarget(renderer, old_texture); } if(objects_changed) { hc_debug << "Rerender objects" << endl; SDL_Texture *old_texture; old_texture = SDL_GetRenderTarget(renderer); SDL_SetRenderTarget(renderer, objects_texture); SDL_SetRenderDrawColor(renderer, 255, 0, 255, 0); SDL_RenderClear(renderer); for(auto tile:objects) { tile.draw_as_sprite(tileset); } objects_changed = false; SDL_SetRenderTarget(renderer, old_texture); } { SDL_Texture *old_texture; old_texture = SDL_GetRenderTarget(renderer); SDL_SetRenderTarget(renderer, npc_texture); SDL_SetRenderDrawColor(renderer, 255, 0, 255, 0); SDL_RenderClear(renderer); for(auto npc:npcs) { npc->draw(); } SDL_SetRenderTarget(renderer, old_texture); } SDL_Rect source; SDL_Rect target; int32_t player_x = 0; int32_t player_y = 0; player->get_pos(&player_x, &player_y); player_x += 8; //Half the NPC-sprite-size player_y += 8; uint32_t map_w = info.width * 16; uint32_t map_h = info.height * 16; if(map_w <= viewport->w) { source.w = map_w; target.w = map_w; source.x = 0; target.x = viewport->x + viewport->w / 2 - map_w / 2; } else { source.w = viewport->w; target.w = viewport->w; source.x = player_x - viewport->w / 2; target.x = viewport->x; } if(map_h <= viewport->h) { source.h = map_h; target.h = map_h; source.y = 0; target.y = viewport->y + viewport->h / 2 - map_h / 2; } else { source.h = viewport->h; target.h = viewport->h; source.y = player_y - viewport->h / 2; target.y = viewport->y; } if(source.x < 0) { source.x = 0; } if(source.y < 0) { source.y = 0; } if(source.x > map_w - source.w) { source.x = map_w - source.w; } if(source.y > map_h - source.h) { source.y = map_h - source.h; } SDL_RenderCopy(renderer, background_texture, &source, &target); SDL_RenderCopy(renderer, objects_texture, &source, &target); SDL_RenderCopy(renderer, npc_texture, &source, &target); }
void Video::WriteNextFrame() { int frameFinished = 0; AVPacket packet; if (texturesRecreatedCount != gTexturesRecreatedCount) { texturesRecreatedCount = gTexturesRecreatedCount; SDL_DestroyTexture(pTexture); pTexture = SDL_CreateTexture( gpRenderer, IsYUVFormat(pCodecContext->pix_fmt) ? SDL_PIXELFORMAT_YV12 : SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, width, height); SDL_SetTextureBlendMode(pTexture, SDL_BLENDMODE_BLEND); unsigned char *pPixels = NULL; int pitch = 0; SDL_LockTexture(pTexture, NULL, reinterpret_cast<void **>(&pPixels), &pitch); memcpy(pPixels, pCachedTexturePixels, pitch * height); SDL_UnlockTexture(pTexture); } while (!frameFinished) { if (av_read_frame(pFormatContext, &packet) != 0) { break; } if (packet.stream_index == videoStream && avcodec_decode_video2(pCodecContext, pFrame, &frameFinished, &packet) >= 0) { if (frameFinished) { AVPicture picture; unsigned char *pPixels = NULL; int pitch = 0; SDL_LockTexture(pTexture, NULL, reinterpret_cast<void **>(&pPixels), &pitch); if (IsYUVFormat(pCodecContext->pix_fmt)) { picture.data[0] = pFrame->data[0]; picture.data[1] = pFrame->data[1]; picture.data[2] = pFrame->data[2]; picture.linesize[0] = pFrame->linesize[0]; picture.linesize[1] = pFrame->linesize[1]; picture.linesize[2] = pFrame->linesize[2]; } else { picture.data[0] = pPixels; picture.linesize[0] = pitch; } sws_scale(pImageConvertContext, pFrame->data, pFrame->linesize, 0, pFrame->height, picture.data, picture.linesize); if (IsYUVFormat(pCodecContext->pix_fmt)) { if (pitch == picture.linesize[0]) { int size = pitch * pFrame->height; memcpy(pPixels, picture.data[0], size); memcpy(pPixels + size, picture.data[2], size / 4); memcpy(pPixels + size * 5 / 4, picture.data[1], size / 4); } else { unsigned char *y1, *y2, *y3, *i1, *i2, *i3; y1 = pPixels; y3 = pPixels + pitch * pFrame->height; y2 = pPixels + pitch * pFrame->height * 5 / 4; i1 = picture.data[0]; i2 = picture.data[1]; i3 = picture.data[2]; for (int i = 0; i < pFrame->height / 2; i++) { memcpy(y1, i1, pitch); i1 += picture.linesize[0]; y1 += pitch; memcpy(y1, i1, pitch); memcpy(y2, i2, pitch / 2); memcpy(y3, i3, pitch / 2); y1 += pitch; y2 += pitch / 2; y3 += pitch / 2; i1 += picture.linesize[0]; i2 += picture.linesize[1]; i3 += picture.linesize[2]; } } } memcpy(pCachedTexturePixels, pPixels, pitch * height); SDL_UnlockTexture(pTexture); } } av_free_packet(&packet); } }
/** * @brief Creates / Recreate Textures * @param textureType * @param surface */ void SurfaceManager::createTexture(int textureType, SDL_Surface *surface) { // Handle to Window Manager window_manager_ptr window = m_weak_window_manager.lock(); if (!window) { return; } switch(textureType) { case TEXTURE_MAIN_SCREEN: { // If Exists, Recreate it. if(textureExists(textureType)) { delTexture(textureType); } // Handle to Window Manager window_manager_ptr window = m_weak_window_manager.lock(); if (!window) { return; } // Get the Actual size of the Renderer to match the surface for scaling. // m_is_scalling_surface!! Add Toggle for Scaling here, // Otherwise should use same size as main surface! int screenWidth, screenHeight; SDL_GetRendererOutputSize( window->getRenderer(), &screenWidth, &screenHeight ); // Create Texture: SDL_TEXTUREACCESS_STREAMING texture_ptr texture( new Textures( SDL_CreateTexture( window->getRenderer(), SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, screenWidth, screenHeight ) ) ); addTexture(textureType, texture); // Set the Blend Mode of the Texture NONE if(SDL_SetTextureBlendMode( texture->getTexture(), SDL_BLENDMODE_NONE) < 0) { SDL_Log("Error Setting Blend on Texture - %s", SDL_GetError()); } } break; case TEXTURE_SELECTION: case TEXTURE_HILIGHT: { // If Exists, Recreate it. if(textureExists(textureType)) { delTexture(textureType); } // Create Texture: SDL_TEXTUREACCESS_TARGET texture_ptr texture( new Textures( SDL_CreateTexture( window->getRenderer(), SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, surface->w, surface->h ) ) ); addTexture(textureType, texture); // Set the Blend Mode of the Texture ADD if(SDL_SetTextureBlendMode( texture->getTexture(), SDL_BLENDMODE_ADD) < 0) { SDL_Log("Error Setting Blend on Texture - %s", SDL_GetError()); } } break; default: break; } }
void setBlendMode(LTexture* s, SDL_BlendMode blending ) { SDL_SetTextureBlendMode(s->mTexture, blending ); }
void LTexture::SetBlendMode(SDL_BlendMode blending) { SDL_SetTextureBlendMode( mTexture, blending); }