SDL + SDL_ttf: Transparenter überblendeter Text?

Question

Ich möchte eine anti-aliased Zeichenfolge auf einer SDL_Surface mit einem bestimmten Alphakanal.

Ich habe herausgefunden, dass es möglich ist, zu rendern:

• eine Anti-Aliasing-Zeichenkette mit dem Blended Variante der String-Rendering-Methode (d.h.: TTR_RenderText_Blended ). Aber dann kann ich es nicht transparent machen.
• Ein Anti-Aliasing-String mit der Shaded Methode. Aber dann gibt es einen soliden Hintergrund. Der Hintergrund und die gezeichnete Zeichenkette können transparent gemacht werden, aber dann ist der feste Hintergrund immer noch da. Die Übergabe einer transparenten Hintergrundfarbe ist ebenfalls nicht möglich.
• eine nicht geglättete Zeichenkette, die ich nach Belieben transparent machen kann, indem ich die Solid Variante. Aber sie ist nicht anti-aliasing.

Danke

Answer 1

Ich weiß, ich bin ein bisschen spät dran :/

Nach der SDL Dokumentation über SDL_SetAlpha :

Beachten Sie, dass Alpha pro Pixel und pro Fläche nicht kombiniert werden kann; falls vorhanden, wird immer das Alpha pro Pixel verwendet.

Also regelmäßig SDL_BlitSurface / SDL_SetAlpha wird hier nicht funktionieren. Aber es kann getan werden:

Die einzigen Möglichkeiten, die mir zum Alpha-Blending einfallen TTF_RenderText_Blended Ausgabe sind die Verwendung von OpenGL oder die Anpassung der Alphawerte der einzelnen Pixel in der Oberfläche.

Durch Anpassung der Alphawerte pro Pixel

Sie können dies tun, indem Sie die Alphawerte pro Pixel von [0, 255] zu einem neuen Bereich [0, alpha] :

// Changes a surface's alpha value, by altering per-pixel alpha if necessary.
void SetSurfaceAlpha (SDL_Surface *surface, Uint8 alpha)
{
    SDL_PixelFormat* fmt = surface->format;

    // If surface has no alpha channel, just set the surface alpha.
    if( fmt->Amask == 0 ) {
        SDL_SetAlpha( surface, SDL_SRCALPHA, alpha );
    }
    // Else change the alpha of each pixel.
    else {
        unsigned bpp = fmt->BytesPerPixel;
        // Scaling factor to clamp alpha to [0, alpha].
        float scale = alpha / 255.0f;

        SDL_LockSurface(surface);

        for (int y = 0; y < surface->h; ++y) 
        for (int x = 0; x < surface->w; ++x) {
            // Get a pointer to the current pixel.
            Uint32* pixel_ptr = (Uint32 *)( 
                    (Uint8 *)surface->pixels
                    + y * surface->pitch
                    + x * bpp
                    );

            // Get the old pixel components.
            Uint8 r, g, b, a;
            SDL_GetRGBA( *pixel_ptr, fmt, &r, &g, &b, &a );

            // Set the pixel with the new alpha.
            *pixel_ptr = SDL_MapRGBA( fmt, r, g, b, scale * a );
        }   

        SDL_UnlockSurface(surface);
    }       
}           

Ich weiß, es sieht beängstigend aus, aber es ist ziemlich einfach. Die wichtigste Zeile ist hier:

*pixel_ptr = SDL_MapRGBA( fmt, r, g, b, scale * a );

Sie können ihn wie folgt verwenden:

text_surface = TTF_RenderText_Blended( font, "Hello World!", color );
SetSurfaceAlpha( text_surface, 128 );

Mit OpenGL

Bei der Verwendung von OpenGL sind die Dinge viel einfacher. Angenommen, Sie konvertieren die SDL_Surface von TTF_RenderText_Blended zu einer GL-Textur zu machen, können Sie einfach verwenden:

glColor4f( 1.0, 1.0, 1.0, Alpha );

bevor Sie es auf einem texturierten Quad rendern.

Vergessen Sie aber nicht, vorher den Alpha-Blending-Modus zu aktivieren!

glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );

Answer 2

Der Weg, dies mit einer TTF zu tun, ist die Verwendung von SDL_SetTextureAlphaMod() Etwa so

SDL_Surface *surface;
SDL_Texture *texture;
SDL_Color color = {255, 255, 255, 128}
surface = TTF_RenderText_Blended_Wrapped(myFont, "HI!", color, 100);
// myFont and the _renderer is pre-defined somewhere in the game
texture = SDL_CreateTextureFromSurface(_renderer, surface);
SDL_SetTextureAlphaMod(texture, color.a);
SDL_RenderCopy(_renderer, texture, NULL, &dest);
SDL_DestroyTexture(texture);
SDL_FreeSurface(surface);

/*...*/

SDL_RenderPresent(_renderer);

https://wiki.libsdl.org/SDL_SetTextureAlphaMod

Answer 3

Alles, was Sie tun müssen, ist anrufen SDL_SetAlpha zu Ihrem SDL_Surface nach Erstellung des Sprites, auf dem der Text gerendert wird, aber vor dem Aufruf von SDL_DisplayFormatAlpha auf diesem Sprite .

// Make the sprite with the text on it
SDL_Surface *swSprite = TTF_RenderText_Solid( font, text, textColor ) ;

// CALL SET ALPHA NOW
SDL_SetAlpha( swSprite, SDL_SRCALPHA, 128 ) ; // 50% opacity

// OK, NOW you can convert it to display format.  I'm presuming
// you called `SDL_SetVideoMode` with the `SDL_HWSURFACE` flag set previously
SDL_Surface* hwSprite = SDL_DisplayFormatAlpha( swSprite ) ;

// If you invert the above 2 steps, it won't work.

// We don't need the software sprite anymore
SDL_FreeSurface( swSprite ) ;

// Now draw the hwSprite as normal
SDL_BlitSurface( hwSprite, NULL, screen, &spriteLocation );

Answer 4

Warum nicht Bitmap-Schriften verwenden? Sie könnten ein png-Bild mit Alphakanal erstellen. Ich denke, dass SDL_ttf mit dem gleichen System arbeitet, es erstellt ein Bild und verwendet intern Bitmap-Schriften.