Sounds like a good solution to me, too!
And I second Kent's question about the compatibility of encryptet pyp files.

I did try it out, and did not experience any change in behavior. I guess it's rooted somewhere entirely else.

Hm, not bad. In deed, it has the potential to look more like the "normal" HUD, without doing hacky stunts. And it is a bit faster than DrawMultipleHUDText().

However, even if I only draw 4 texts using this code, the framerate on my iMac is down to 24 fps (tested in R21). Using my own code, I get 127 fps. I'll see if it can be optimised more (e.g. by making the clip map a member of MyClass so it does not have to be allocated for every draw call.

Cheers,
Frank

EDIT: And it gets slower in a linear way. drawing 4 texts only gives me 12 fps. So, it looked promising, and I thank you very much for the code, as it gives me some new inspiration on how to do text drawing in the viewport), but for what I need to do (drawing > 30 texts on average), it is not suitable.

Thank you Ricardo! This looks much simpler than the code we're currently using. I'll check it out!

What I also find weird is, that even if I use the DrawMultipleHUDText() function, the stuff that appears in the viewport still looks different from the standard HUD elements like "Projection" or "FPS". It's a bit darker and the margin around the text looks different.

Hm... interesting. I am getting a promising result now with this code:

BaseBitmap* MyClass::CreateTextBitmap(const String &text, const Vector &textColor, const Vector &bgColor, Float bgOpacity, Int32 margin)
{
	if (!_clipmap)
	{
		_clipmap.Assign(GeClipMap::Alloc());
		if (!_clipmap)
			return nullptr;
	}

	// Dummy draw, just to get the text dimensions
	if (_clipmap->Init(0, 0, 32) != IMAGERESULT::OK)
		return nullptr;
	_clipmap->BeginDraw();
	Int32 width = _clipmap->GetTextWidth(text) + margin * 2;
	Int32 height = _clipmap->GetTextHeight() + margin * 2;
	_clipmap->EndDraw();
	_clipmap->Destroy();

	// Begin actual drawing
	if (_clipmap->Init(width, height, 32) != IMAGERESULT::OK)
		return nullptr;
	_clipmap->BeginDraw();
	_clipmap->EndDraw();
	
	width = _clipmap->GetBw();
	height = _clipmap->GetBh();
	_clipmap->BeginDraw();

	// Background. Fill clipmap with a rectangle, overpainting possibly existing text
	// Drawn with alpha = 255, because this alpha value just defines the transparency of the drawn color over the background.
	// The actual background alpha is set later.
	const Int32 backgroundColorR = (Int32)(bgColor.x * 255.0);
	const Int32 backgroundColorG = (Int32)(bgColor.y * 255.0);
	const Int32 backgroundColorB = (Int32)(bgColor.z * 255.0);
	_clipmap->SetColor(backgroundColorR, backgroundColorG, backgroundColorB, 255);
	_clipmap->FillRect(0, 0, width - 1, height - 1);

	const Int32 backgroundOpacity = (Int32)(bgOpacity * 255.0);

	// Text
	// Drawn with alpha = 255, because this alpha value just defines the transparency of the drawn color over the background.
	_clipmap->SetColor((Int32)(textColor.x * 255.0), (Int32)(textColor.y * 255.0), (Int32)(textColor.z * 255.0), 255);
	_clipmap->TextAt(margin, margin, text);

	_clipmap->EndDraw();

	BaseBitmap *bitmap = _clipmap->GetBitmap()->GetClone();
	if (!bitmap)
		return nullptr;

	BaseBitmap *alphaBitmap = bitmap->AddChannel(true, true);
	if (!alphaBitmap)
		return nullptr;
	alphaBitmap = bitmap->GetInternalChannel();
	if (!alphaBitmap)
		return nullptr;

	for (Int32 y = 0; y < bitmap->GetBh(); ++y)
	{
		for (Int32 x = 0; x < bitmap->GetBw(); ++x)
		{
			// 100% transparent corners
			if ((x == 0 && y == 0) || (x == width - 1 && y == height - 1) ||
				(x == 0 && y == height - 1) || (x == width - 1 && y == 0))
			{
				bitmap->SetAlphaPixel(alphaBitmap, x, y, 0);
			}
			else // All other pixels: semi transparent
			{
				bitmap->SetAlphaPixel(alphaBitmap, x, y, backgroundOpacity);
			}
		}
	}
	
	return bitmap;
}

I wonder why this looks so different... I still didn't set opaque pixels for the text, but it seems to be a good start...

But that is how I am doing it, too. Using BaseBitmap::SetAlphaPixel() to set alpha values into the bitmap's internal alpha channel. I am getting my values from another source (because I'm not copying a bitmap, but creating a new one), but they are still in the correct value range. I have even tried setting all pixels to the same alpha value (e.g. 128) and still did not get a semi transparent result in the viewport.

Oh, ok. As far as I understood the docs, BaseBitmap::AddChannel() would add an alpha channel, and passing true as the first argument would make this the "internal" alpha channel. After all, before I can set any alpha value with BaseBitmap::SetAlphaPixel() I would need an alpha channel to set the data to, right? BaseBitmap::GetInternalChannel() gives me nullptr if I don't call BaseBitmap::AddChannel() first.

And no, as I see it, BaseBitmap::SetAlphaPixel() does not always write to the primary alpha channel, but to the channel I pass to the function. If I pass nullptr, no alpha value seems to be written.

Hi & thank you for the reply!

That is, I guess pretty much what I do. Only you are copying alpha values from another BaseBitmap, and I need to make up alpha values based on the color of pixels in the BaseBitmap I got from the GeClipMap. As long as my alpha values are in the range of 0 ... 255 (which they are), I should see at least some kind of semi transparency, right?

So, my question remains :D Maybe the SDK team knows some details?

Thanks & greetings,
Frank

Hello,

I need to draw text with a semi-transparent background that look exactly like the HUD. But I can not use DrawMultipleHUDText() for that, because it's super slow (I need to draw a lot of text entries).

I'm now using a GeClipMap to draw the text, then I get the clipmap's bitmap, and use BaseDraw::DrawTexture() for the actual drawing. Still, to get the semi-transparent background of the HUD, I need a proper alpha channel. Using GeClipMap::SetPixelRGBA() does not help, since the GeClipMap is not able to return a BaseBitmap with alpha channel.

The next thing I tried is using bitmap->AddChannel(true, true) to create an alpha channel. I then iterate over all pixels in the bitmap, and set values to the alpha channel depending on the pixel values in the bitmap. The values are being set correctly, I checked that, but in the viewport there seems to be only "visible" and "invisible", no semi-transparency. Of course, I use DRAW_ALPHA::NORMAL in the DrawTexture() call.

The only thing that gives me semi-transparency is using DRAW_ALPHA::FROM_IMAGE. But then the alpha is depending on the actual pixel colors in the bitmap, and I couldn't find any color that would give me the exact HUD look. It is fast, though, much faster than DrawMultipleHUDText().

Another problem is that the text does look almost perfectly like the HUD (close enough at least), but only on computers with retina screen. On computers with low-res screens, it looks washed out and blurred. That is, if I use DRAW_TEXTUREFLAGS::INTERPOLATION_LINEAR. Using DRAW_TEXTUREFLAGS::INTERPOLATION_NEAREST makes the text look broken, as if it had been scaled down. But I don't scale it, it should be drawn exactly in the right size (see me using the bitmaps width and height for the texture vertex coordinates).

Here's the code for texture creation:

BaseBitmap* MyClass::CreateTextBitmap(const String &text, const Vector &textColor, const Vector &bgColor, Float bgOpacity, Int32 margin)
{
	// _clipmap is a member of MyClass
	if (!_clipmap)
	{
		_clipmap.Assign(GeClipMap::Alloc());
		if (!_clipmap)
			return nullptr;
	}

	// Dummy draw, just to get the text dimensions
	if (_clipmap->Init(0, 0, 32) != IMAGERESULT::OK)
		return nullptr;
	_clipmap->BeginDraw();
	Int32 width = _clipmap->GetTextWidth(text) + margin * 2;
	Int32 height = _clipmap->GetTextHeight() + margin * 2;
	_clipmap->EndDraw();
	_clipmap->Destroy();

	// Begin actual drawing
	if (_clipmap->Init(width, height, 32) != IMAGERESULT::OK)
		return nullptr;
	_clipmap->BeginDraw();
	_clipmap->EndDraw();
	
	width = _clipmap->GetBw();
	height = _clipmap->GetBh();
	_clipmap->BeginDraw();

	// Background. Fill clipmap with a rectangle, overpainting possibly existing text
	// Drawn with alpha = 255, because this alpha value just defines the transparency of the drawn color over the background.
	// The actual background alpha is set later.
	const Int32 backgroundColorR = (Int32)(bgColor.x * 255.0);
	const Int32 backgroundColorG = (Int32)(bgColor.y * 255.0);
	const Int32 backgroundColorB = (Int32)(bgColor.z * 255.0);
	_clipmap->SetColor(backgroundColorR, backgroundColorG, backgroundColorB, 255);
	_clipmap->FillRect(0, 0, width - 1, height - 1);

	const Int32 backgroundOpacity = (Int32)(bgOpacity * 255.0);

	// Text
	// Drawn with alpha = 255, because this alpha value just defines the transparency of the drawn color over the background.
	_clipmap->SetColor((Int32)(textColor.x * 255.0), (Int32)(textColor.y * 255.0), (Int32)(textColor.z * 255.0), 255);
	_clipmap->TextAt(margin, margin, text);

	// Make corner pixels transparent (looks more like HUD then)
	_clipmap->SetColor(0, 0, 0, 255);
	_clipmap->SetPixel(0, 0);
	_clipmap->SetPixel(0, height - 1);
	_clipmap->SetPixel(width - 1, 0);
	_clipmap->SetPixel(width - 1, height - 1);

	_clipmap->EndDraw();

	// Get bitmap from clipmap
	BaseBitmap *bitmap = _clipmap->GetBitmap()->GetClone();
	if (!bitmap)
		return nullptr;

	// Iterate over pixels, set the actual alpha values
	BaseBitmap *alphaBitmap = bitmap->AddChannel(true, true);
	if (!alphaBitmap)
		return nullptr;
	alphaBitmap = bitmap->GetInternalChannel();
	if (!alphaBitmap)
		return nullptr;

	for (Int32 y = 0; y < bitmap->GetBh(); ++y)
	{
		for (Int32 x = 0; x < bitmap->GetBw(); ++x)
		{
			UInt16 r = 0, g = 0, b = 0;
			bitmap->GetPixel(x, y, &r, &g, &b);

			if (r == backgroundColorR && g == backgroundColorG && b == backgroundColorB)
				bitmap->SetAlphaPixel(alphaBitmap, x, y, 255 - backgroundOpacity);
			else if (r == 0 && g == 0 && b == 0)
				bitmap->SetAlphaPixel(alphaBitmap, x, y, 0);
			else
				bitmap->SetAlphaPixel(alphaBitmap, x, y, 255);
		}
	}
	
	return bitmap;
}

And this is the code I use for drawing:

void MyClass::DrawRect(BaseDraw *bd, BaseBitmap *bmp, const Vector* padr4, const Vector &color, DRAW_ALPHA alphamode, DRAW_TEXTUREFLAGS flags)
{
	if (!bd || !bmp || !padr4)
		return;
	
	// Vertex normal array
	static const Vector vnadr[4] = {
		Vector(0.0, 1.0, 0.0),
		Vector(0.0, 1.0, 0.0),
		Vector(0.0, 1.0, 0.0),
		Vector(0.0, 1.0, 0.0)
	};
	
	// UV coordinate array
	static const Vector uvadr[4] = {
		Vector(0.0, 0.0, 0.0),
		Vector(1.0, 0.0, 0.0),
		Vector(1.0, 1.0, 0.0),
		Vector(0.0, 1.0, 0.0)
	};
	
	// Color array
	const Vector cadr[4] = {
		color,
		color,
		color,
		color
	};
	
	bd->DrawTexture(bmp, padr4, cadr, vnadr, uvadr, 4, alphamode, flags);
}

And here's the code that starts everything inside my SceneHook plugin's Draw() call:

// Set draw matrix to screen space, prevent drawn elements from being lit
bd->SetMatrix_Screen();
bd->SetLightList(BDRAW_SETLIGHTLIST_NOLIGHTS);

String valueText = FormatNumber(123.45, FORMAT_METER, 25);
BaseBitmap *valueTexture(CreateTextBitmap(valueText, Vector(0.9), Vector(0.25), 0.2, 2));

const Float valueTextureWidth = valueTexture->GetBw();
const Float valueTextureHeight = valueTexture->GetBh();

const Vector textPadr[4] = {
	textUpperLeftCornerPos,
	textUpperLeftCornerPos + Vector(valueTextureWidth, 0.0, 0.0),
	textUpperLeftCornerPos + Vector(valueTextureWidth, valueTextureHeight, 0.0),
	textUpperLeftCornerPos + Vector(0.0, valueTextureHeight, 0.0),
};

const Vector hudTextColor = bd->GetParameterData(BASEDRAW_HUD_TEXTCOLOR).GetVector();

DrawRect(bd, valueTexture, textPadr, hudTextColor, DRAW_ALPHA::NORMAL, DRAW_TEXTUREFLAGS::INTERPOLATION_LINEAR);

Any help would be very appreciated. As I said, the only goal here is just to have a function that draws text with semi-transparent background into the viewport that looks exactly like the HUD, just faster.

Cheers,
Frank