The code is part of a BepInEx plugin that dumps game data to JSON and PNG. It is open source, and the icon export lives in a single file.

Reading pixels from a texture you can't read

Textures in Valheim and in mods usually can't be read from the CPU, so calling GetPixels on them directly fails. The workaround is to draw the texture into a RenderTexture and read the result back into a Texture2D. This is the shape of it. It is condensed, and the plugin makes the same calls through reflection, so it doesn't depend on Unity's texture API at compile time:

static Texture2D ReadBack(Texture src, RenderTextureFormat rtFormat,
                          TextureFormat texFormat, bool linear)
{
    var rw = linear ? RenderTextureReadWrite.Linear : RenderTextureReadWrite.sRGB;
    var rt = RenderTexture.GetTemporary(src.width, src.height, 0, rtFormat, rw);
    var prev = RenderTexture.active;
    try
    {
        Graphics.Blit(src, rt);
        RenderTexture.active = rt;
        var tex = new Texture2D(src.width, src.height, texFormat, false, linear);
        tex.ReadPixels(new Rect(0, 0, src.width, src.height), 0, 0);
        tex.Apply();
        return tex;
    }
    finally
    {
        RenderTexture.active = prev;
        RenderTexture.ReleaseTemporary(rt);
    }
}

Two arguments decide the colours: the format of the render target, and whether it is Linear or sRGB. Both matter below.

Why the icons come out dark

Valheim renders in linear colour space. With a Linear render target, the values you read back are linear. A PNG is assumed to be sRGB, and nothing converts the numbers when the file is written. A viewer then treats linear numbers as if they were sRGB, and the icon looks too dark.

A colour that is (77, 201, 176) in sRGB is about (19, 149, 111) in linear values. Saved to a PNG as is, it shows up as that darker green.

The conversion

The fix is the sRGB transfer function, applied to red, green and blue. Alpha is not touched. This is the function from the plugin:

static float ToSrgb(float c)
{
    if (c <= 0f) return 0f;
    if (c >= 1f) return 1f;
    return c <= 0.0031308f
        ? c * 12.92f
        : 1.055f * (float)Math.Pow(c, 1.0 / 2.4) - 0.055f;
}

Cutting one sprite out of the texture

A sprite is a rectangle inside a texture. For each sprite the plugin takes the texture and the sprite's textureRect (it falls back to rect), reads those pixels from the readable copy, converts the colour channels, and encodes the PNG:

Color[] px = readable.GetPixels(x, y, w, h, 0);
for (int i = 0; i < px.Length; i++)
{
    px[i].r = ToSrgb(px[i].r);
    px[i].g = ToSrgb(px[i].g);
    px[i].b = ToSrgb(px[i].b);
}
var outTex = new Texture2D(w, h, TextureFormat.RGBA32, false, linear);
outTex.SetPixels(px);
outTex.Apply();
byte[] png = outTex.EncodeToPNG();

Keeping the data in float

In the default mode the render target is a float format (ARGBFloat). The values stay floats until the conversion is done, and only the final PNG is 8 bits per channel. If the float format isn't available on a machine, the plugin falls back to an 8-bit target and doesn't try the float one again.

Three modes

The config has three colour modes:

• LinearToSRGB is the default: a float linear target, then the per-pixel conversion above.
• sRGB reads back through an sRGB render target and lets the GPU do the conversion.
• Linear writes the raw linear values. These are the dark ones.

I kept the last two so I can compare them with the default.

Not reading the same texture twice

Many sprites sit in the same texture, so reading a whole texture back for every sprite would repeat the same blit. The plugin keeps readable copies of the four textures it used most recently and destroys the older ones. If the same sprite comes up twice, it reuses the file it already wrote.

Checking the result

I compared the converted icons with the originals already on the wiki, which came from an earlier dump (WikiDump 1.1). The mean error is about 6 out of 255.

The plugin is open source: WikiDump on GitHub, and the code above is in src/Icons.cs. The icons are used on Valheim Wiki, which also has a seed map for 1.0 that runs in the browser.