【DirectX11】テクスチャが暗い・白っぽくなる原因とは?|sRGBとUNORMの取り違えを画素の値で4通り確かめて、ガンマ補正の正しい組み合わせを整理

【DirectX11】テクスチャが暗い・白っぽくなる原因とは?|sRGBとUNORMの取り違えを画素の値で4通り確かめて、ガンマ補正の正しい組み合わせを整理 ゲーム制作

同じ灰色(128)のテクスチャを貼っただけなのに、画面では、暗い灰色(55)になったり、明るい灰色(188)になったりする。この原因の多くは、テクスチャの読み方と、描画先の形式が、sRGBとUNORMで、食い違っていることにあります。

どの組み合わせで、どちらにずれるのかを、実際に描いて、画素の値で確かめました。あわせて、半透明の重ね合わせ(ブレンド)と、拡大縮小のときの補間(バイリニア)が、形式によって、どれだけ変わるかも測っています。

検証は、DirectX11の、ハードウェアデバイスで、画面外の描画先(8bit×4のテクスチャ)に描いて、できあがった画素の値を、CPU側で読み出して行いました。

sRGBとガンマ補正とは?

・PNGやJPEGなどの色は、人の目に合わせた「sRGB」(明るさに、ガンマ補正がかかった値)で保存されている。光の足し算や混ぜ合わせは、補正を外した「線形」の値で行うのが、物理的に正しい

DirectX11には、この変換を、ハードウェアが自動で行う形式があります。DXGI_FORMAT_R8G8B8A8_UNORM_SRGBです。

  • テクスチャの読み込み側(SRV)が_SRGB:読んだ値を、線形に変換してから、シェーダーに渡す
  • 描画先(RTV)が_SRGB:シェーダーが出した線形の値を、sRGBに変換してから、書き込む
  • _SRGBでないUNORM:変換なし。読んだ値も、書いた値も、そのまま

読み込みと書き込みの形式が、食い違うと、変換が、片側にしか入らず、色がずれます。

実験①:シェーダーが出した「0.5」は、画面でいくつになるか

ピクセルシェーダーで0.5を、そのまま出力して、描画先の形式を変えました。

▼e1_srgb.cpp
// sRGB と UNORM の取り違えで、画素の値がどう変わるかを、実際の画素で調べる
#include <d3d11.h>
#include <d3dcompiler.h>
#include <cstdio>
#include <cstring>
#include <vector>
#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "d3dcompiler.lib")

static const char* kShader = R"(
Texture2D    tex  : register(t0);
SamplerState samp : register(s0);
cbuffer C : register(b0) { float4 g_color; };
struct VSOut { float4 pos : SV_POSITION; float2 uv : TEXCOORD0; };
VSOut VS(uint id : SV_VertexID)
{
    VSOut o;
    float2 uv = float2((id << 1) & 2, id & 2);               // 画面全体を覆う三角形
    o.pos = float4(uv * float2(2, -2) + float2(-1, 1), 0, 1);
    o.uv = uv;
    return o;
}
float4 PS_const(VSOut i) : SV_TARGET { return g_color; }
float4 PS_tex(VSOut i)   : SV_TARGET { return tex.Sample(samp, i.uv); }
float4 PS_ramp(VSOut i)  : SV_TARGET { return float4(i.uv.x, i.uv.x, i.uv.x, 1); }
)";

struct Env
{
    ID3D11Device* dev = nullptr; ID3D11DeviceContext* ctx = nullptr;
    ID3D11VertexShader* vs = nullptr;
    ID3D11PixelShader *psConst = nullptr, *psTex = nullptr, *psRamp = nullptr;
    ID3D11Buffer* cb = nullptr;
    ID3D11SamplerState *sampPoint = nullptr, *sampLinear = nullptr;
    ID3D11BlendState* blend = nullptr;
};

static ID3D11PixelShader* makePS(Env& e, const char* entry)
{
    ID3DBlob* code = nullptr; ID3DBlob* err = nullptr;
    if (FAILED(D3DCompile(kShader, strlen(kShader), nullptr, nullptr, nullptr, entry, "ps_5_0", 0, 0, &code, &err))) { std::printf("%s\n", (char*)err->GetBufferPointer()); std::exit(1); }
    ID3D11PixelShader* ps = nullptr; e.dev->CreatePixelShader(code->GetBufferPointer(), code->GetBufferSize(), nullptr, &ps); code->Release();
    return ps;
}

// 幅 W、高さ H の描画先(TYPELESS)に、rtvFmt のビューで描いて、画素のバイト列(R,G,B,A)を返す
static std::vector<unsigned char> render(Env& e, DXGI_FORMAT rtvFmt, ID3D11PixelShader* ps, ID3D11ShaderResourceView* srv,
                                         ID3D11SamplerState* samp, bool useBlend, const float color[4], int W, int H)
{
    D3D11_TEXTURE2D_DESC td{}; td.Width = W; td.Height = H; td.MipLevels = 1; td.ArraySize = 1;
    td.Format = DXGI_FORMAT_R8G8B8A8_TYPELESS; td.SampleDesc.Count = 1; td.Usage = D3D11_USAGE_DEFAULT; td.BindFlags = D3D11_BIND_RENDER_TARGET;
    ID3D11Texture2D* rt = nullptr; e.dev->CreateTexture2D(&td, nullptr, &rt);
    D3D11_RENDER_TARGET_VIEW_DESC rd{}; rd.Format = rtvFmt; rd.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
    ID3D11RenderTargetView* rtv = nullptr; e.dev->CreateRenderTargetView(rt, &rd, &rtv);
    float black[4] = {0, 0, 0, 1};
    e.ctx->ClearRenderTargetView(rtv, black);
    e.ctx->OMSetRenderTargets(1, &rtv, nullptr);
    D3D11_VIEWPORT vp{0, 0, (float)W, (float)H, 0, 1}; e.ctx->RSSetViewports(1, &vp);
    float bf[4] = {0, 0, 0, 0};
    e.ctx->OMSetBlendState(useBlend ? e.blend : nullptr, bf, 0xFFFFFFFF);
    e.ctx->UpdateSubresource(e.cb, 0, nullptr, color, 0, 0);
    e.ctx->VSSetShader(e.vs, nullptr, 0); e.ctx->PSSetShader(ps, nullptr, 0);
    e.ctx->PSSetConstantBuffers(0, 1, &e.cb);
    e.ctx->PSSetShaderResources(0, 1, &srv);
    e.ctx->PSSetSamplers(0, 1, &samp);
    e.ctx->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
    e.ctx->Draw(3, 0);

    td.Usage = D3D11_USAGE_STAGING; td.BindFlags = 0; td.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
    ID3D11Texture2D* st = nullptr; e.dev->CreateTexture2D(&td, nullptr, &st);
    e.ctx->CopyResource(st, rt);
    D3D11_MAPPED_SUBRESOURCE m{}; e.ctx->Map(st, 0, D3D11_MAP_READ, 0, &m);
    std::vector<unsigned char> out(W * H * 4);
    for (int y = 0; y < H; ++y) memcpy(&out[y * W * 4], (unsigned char*)m.pData + y * m.RowPitch, W * 4);
    e.ctx->Unmap(st, 0);
    st->Release(); rtv->Release(); rt->Release();
    ID3D11ShaderResourceView* nullSrv = nullptr; e.ctx->PSSetShaderResources(0, 1, &nullSrv);
    return out;
}

static ID3D11ShaderResourceView* makeTex(Env& e, int w, int h, const unsigned char* rgba, DXGI_FORMAT srvFmt)
{
    D3D11_TEXTURE2D_DESC td{}; td.Width = w; td.Height = h; td.MipLevels = 1; td.ArraySize = 1;
    td.Format = DXGI_FORMAT_R8G8B8A8_TYPELESS; td.SampleDesc.Count = 1; td.Usage = D3D11_USAGE_DEFAULT; td.BindFlags = D3D11_BIND_SHADER_RESOURCE;
    D3D11_SUBRESOURCE_DATA sd{rgba, (UINT)(w * 4), 0};
    ID3D11Texture2D* t = nullptr; e.dev->CreateTexture2D(&td, &sd, &t);
    D3D11_SHADER_RESOURCE_VIEW_DESC vd{}; vd.Format = srvFmt; vd.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; vd.Texture2D.MipLevels = 1;
    ID3D11ShaderResourceView* v = nullptr; e.dev->CreateShaderResourceView(t, &vd, &v);
    t->Release();
    return v;
}

static const DXGI_FORMAT UNORM = DXGI_FORMAT_R8G8B8A8_UNORM;
static const DXGI_FORMAT SRGB  = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;

static void savePPM(const char* path, const std::vector<unsigned char>& px, int w, int h)
{
    FILE* f = nullptr; fopen_s(&f, path, "wb");
    std::fprintf(f, "P6\n%d %d\n255\n", w, h);
    for (int i = 0; i < w * h; ++i) std::fwrite(&px[i * 4], 1, 3, f);
    std::fclose(f);
}

int main()
{
    std::setvbuf(stdout, nullptr, _IONBF, 0);
    Env e; D3D_FEATURE_LEVEL fl;
    if (FAILED(D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, 0, nullptr, 0, D3D11_SDK_VERSION, &e.dev, &fl, &e.ctx))) { std::printf("デバイス作成失敗\n"); return 1; }

    ID3DBlob* vsb = nullptr; ID3DBlob* err = nullptr;
    D3DCompile(kShader, strlen(kShader), nullptr, nullptr, nullptr, "VS", "vs_5_0", 0, 0, &vsb, &err);
    e.dev->CreateVertexShader(vsb->GetBufferPointer(), vsb->GetBufferSize(), nullptr, &e.vs);
    e.psConst = makePS(e, "PS_const"); e.psTex = makePS(e, "PS_tex"); e.psRamp = makePS(e, "PS_ramp");
    D3D11_BUFFER_DESC bd{}; bd.ByteWidth = 16; bd.Usage = D3D11_USAGE_DEFAULT; bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    e.dev->CreateBuffer(&bd, nullptr, &e.cb);
    D3D11_SAMPLER_DESC sd{}; sd.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT; sd.AddressU = sd.AddressV = sd.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP; sd.MaxLOD = D3D11_FLOAT32_MAX;
    e.dev->CreateSamplerState(&sd, &e.sampPoint);
    sd.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; e.dev->CreateSamplerState(&sd, &e.sampLinear);
    D3D11_BLEND_DESC bl{}; bl.RenderTarget[0].BlendEnable = TRUE;
    bl.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA; bl.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA; bl.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
    bl.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE; bl.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO; bl.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
    bl.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
    e.dev->CreateBlendState(&bl, &e.blend);

    // ---- A: シェーダーが出した「0.5」は、画面では、いくつになるか ----
    float half[4] = {0.5f, 0.5f, 0.5f, 1.0f};
    auto a1 = render(e, UNORM, e.psConst, nullptr, e.sampPoint, false, half, 1, 1);
    auto a2 = render(e, SRGB,  e.psConst, nullptr, e.sampPoint, false, half, 1, 1);
    std::printf("【A】シェーダーが 0.5 を出力したとき、描画先に書かれた値(0〜255)\n");
    std::printf("  描画先が UNORM       : %3d\n", a1[0]);
    std::printf("  描画先が UNORM_SRGB  : %3d  (ハードウェアが、線形の 0.5 を sRGB に変換して書いた)\n\n", a2[0]);

    // ---- B: 灰色(128)のテクスチャを、そのまま貼る。テクスチャの読み方 x 描画先 の4通り ----
    unsigned char grey[4] = {128, 128, 128, 255};
    auto texU = makeTex(e, 1, 1, grey, UNORM);
    auto texS = makeTex(e, 1, 1, grey, SRGB);
    float none[4] = {0, 0, 0, 0};
    struct Row { const char* label; ID3D11ShaderResourceView* srv; DXGI_FORMAT rtv; } rows[] = {
        {"テクスチャ UNORM      → 描画先 UNORM     ", texU, UNORM},
        {"テクスチャ UNORM_SRGB → 描画先 UNORM_SRGB", texS, SRGB},
        {"テクスチャ UNORM_SRGB → 描画先 UNORM     ", texS, UNORM},
        {"テクスチャ UNORM      → 描画先 UNORM_SRGB", texU, SRGB},
    };
    std::printf("【B】灰色(128)のテクスチャを、そのまま画面いっぱいに貼ったときの、描画先の値\n");
    for (auto& r : rows)
    {
        auto px = render(e, r.rtv, e.psTex, r.srv, e.sampPoint, false, none, 1, 1);
        std::printf("  %s : %3d\n", r.label, px[0]);
    }
    std::printf("\n");

    // ---- C: 白を、不透明度 0.5 で、黒の上に重ねる(アルファブレンド) ----
    float whiteHalf[4] = {1, 1, 1, 0.5f};
    auto c1 = render(e, UNORM, e.psConst, nullptr, e.sampPoint, true, whiteHalf, 1, 1);
    auto c2 = render(e, SRGB,  e.psConst, nullptr, e.sampPoint, true, whiteHalf, 1, 1);
    std::printf("【C】黒の上に、白を不透明度 0.5 で重ねたときの値\n");
    std::printf("  描画先が UNORM       : %3d\n", c1[0]);
    std::printf("  描画先が UNORM_SRGB  : %3d\n\n", c2[0]);

    // ---- D: 黒(0)と白(255)の、境目をバイリニアで読む(2x1のテクスチャ) ----
    unsigned char bw[8] = {0, 0, 0, 255, 255, 255, 255, 255};
    auto bwU = makeTex(e, 2, 1, bw, UNORM);
    auto bwS = makeTex(e, 2, 1, bw, SRGB);
    auto d1 = render(e, UNORM, e.psTex, bwU, e.sampLinear, false, none, 1, 1);
    auto d2 = render(e, SRGB,  e.psTex, bwS, e.sampLinear, false, none, 1, 1);
    std::printf("【D】黒と白のちょうど真ん中を、バイリニアで読んだときの値\n");
    std::printf("  UNORM → UNORM            : %3d\n", d1[0]);
    std::printf("  UNORM_SRGB → UNORM_SRGB  : %3d\n\n", d2[0]);

    // ---- E: 0→1 のなめらかなグラデーション(PNG用に保存) ----
    auto r1 = render(e, UNORM, e.psRamp, nullptr, e.sampPoint, false, none, 256, 32);
    auto r2 = render(e, SRGB,  e.psRamp, nullptr, e.sampPoint, false, none, 256, 32);
    savePPM("ramp_unorm.ppm", r1, 256, 32);
    savePPM("ramp_srgb.ppm", r2, 256, 32);
    std::printf("【E】0→1 のグラデーションの、画素の値(左から 0, 64, 128, 192, 255 番目)\n");
    int xs[5] = {0, 64, 128, 192, 255};
    std::printf("  UNORM       :"); for (int x : xs) std::printf(" %3d", r1[x * 4]); std::printf("\n");
    std::printf("  UNORM_SRGB  :"); for (int x : xs) std::printf(" %3d", r2[x * 4]); std::printf("\n");
    return 0;
}
【A】シェーダーが 0.5 を出力したとき、描画先に書かれた値(0〜255)
  描画先が UNORM       : 127
  描画先が UNORM_SRGB  : 188  (ハードウェアが、線形の 0.5 を sRGB に変換して書いた)

【B】灰色(128)のテクスチャを、そのまま画面いっぱいに貼ったときの、描画先の値
  テクスチャ UNORM      → 描画先 UNORM      : 128
  テクスチャ UNORM_SRGB → 描画先 UNORM_SRGB : 128
  テクスチャ UNORM_SRGB → 描画先 UNORM      :  55
  テクスチャ UNORM      → 描画先 UNORM_SRGB : 188

【C】黒の上に、白を不透明度 0.5 で重ねたときの値
  描画先が UNORM       : 127
  描画先が UNORM_SRGB  : 187

【D】黒と白のちょうど真ん中を、バイリニアで読んだときの値
  UNORM → UNORM            : 127
  UNORM_SRGB → UNORM_SRGB  : 188

【E】0→1 のグラデーションの、画素の値(左から 0, 64, 128, 192, 255 番目)
  UNORM       :   0  64 128 192 255
  UNORM_SRGB  :   7 138 188 225 255

【A】の結果は、UNORMの描画先では127、UNORM_SRGBの描画先では188でした。0.5 × 255 = 127.5なので、127は丸めの結果です。_SRGBの描画先では、ハードウェアが、線形の0.5を、sRGBの値に変換して、書き込みました(線形の0.5は、sRGBでは約0.735、255倍して188)。

【重要】実験②:テクスチャの読み方と描画先の、4通りの組み合わせ

次に、灰色(128)の1×1のテクスチャを、画面いっぱいに貼ります。テクスチャを読むときの形式(UNORMかUNORM_SRGB)と、描画先の形式(UNORMかUNORM_SRGB)を、組み合わせて、4通りです。結果は、実行結果の【B】にあります。

同じ灰色128のテクスチャを、読み方と描画先の形式を組み合わせて描いた結果。値は128、128、55、188
読み方と描画先を、そろえると128のまま。食い違うと、55(暗すぎる)か188(明るすぎる)になった
テクスチャの読み方描画先描画先の値見た目
UNORMUNORM128正しい(変換なし)
UNORM_SRGBUNORM_SRGB128正しい(線形で計算して、sRGBに戻した)
UNORM_SRGBUNORM55暗すぎる(読むときだけ線形に変換して、戻していない)
UNORMUNORM_SRGB188明るすぎる・白っぽい(sRGBのままの値を線形と見なして、さらに変換した)

上の2行は、どちらも128で、正しく表示されます。「そろえる」ことが、大事です。食い違った下の2行は、128の灰色が、55(暗い)と188(明るい)に変わりました。画面が全体的に暗くなる、または、全体が白っぽくぼやける、という症状の、典型です。

実験③:なめらかなグラデーションは、どう変わるか

次は、0から1まで、線形になめらかに変化する値を、シェーダーから出力して、2つの描画先に、書き込みました。

0から1までの線形なグラデーションを、UNORMとUNORM_SRGBの描画先にそのまま書いた結果
同じシェーダーの出力でも、描画先がUNORM_SRGBだと、暗い部分が持ち上がって、全体が明るくなる

左から0・64・128・192・255番目の画素は、UNORMでは0・64・128・192・255、UNORM_SRGBでは7・138・188・225・255でした。UNORM_SRGBのほうが、暗い側が、大きく持ち上がっています。線形な明るさの変化を、人の目が、均等に感じるように、変換されるためです。

ライティングの計算(N·L)は、線形の値で行います。その結果を、UNORMの描画先に、そのまま書くと、暗い側が、必要以上に、暗くなります。「陰が、黒つぶれしてしまう」場合は、この変換が、抜けていることがあります。

実験④:ブレンドとバイリニアは、どちらの空間で計算されるか

描画先が_SRGBだと、混ぜ合わせの計算も、線形の値で行われます。2つの場面で確かめました。実行結果の【C】と【D】です。

場面UNORM(変換なし)UNORM_SRGB(線形で計算)
黒の上に、白を不透明度0.5で重ねる127187
黒と白のちょうど真ん中を、バイリニアで読む127188
どちらも、1画素の描画先に描いた結果。UNORM_SRGB の側は、テクスチャの読み込みも _SRGB にそろえた

UNORMでは、黒(0)と白(255)を混ぜると、ちょうど真ん中の127になります。数字の平均として見れば、これが、素直な結果です。一方、UNORM_SRGBでは、187〜188になりました。「黒と白の光を、半分ずつ混ぜた明るさ」を、物理的に正しく計算してから、画面向けの値に直した結果だからです。

どちらが正しいかは、目的しだいです。写実的な描画や、光の加算(パーティクルの発光)を、物理的に自然に見せたいなら、線形空間(_SRGB)で計算するほうが、自然に見えます。ただし、同じ半透明の画像でも、_SRGBにそろえたとたんに、色の混ざり具合が、変わるので、途中から切り替えると、見た目が変わってしまう点に、注意が必要です。

直し方:読み込み側と描画先を、そろえる

  • 色の画像(アルベド、UIの画像、写真):読み込み側(SRV)を_SRGBにする。描画先(RTV)も_SRGBにして、線形空間で、計算する
  • 色ではないデータ(法線マップ、ラフネス、メタルネス、AOなど):_SRGBを付けない(UNORMのまま読む)
  • 読み込みに、DirectXTKなどのライブラリを使うときは、sRGBとして扱うかどうかを、指定するフラグ(WIC_LOADER_FORCE_SRGBなど)がある。画像ファイルの種類に合わせて、選ぶ(今回は、このフラグ自体は、検証していません)
  • 描画先をUNORMのまま、ライティングを線形で計算した場合は、最後に、シェーダーの中で、pow(color, 1/2.2)などで、ガンマ補正を入れる

実験②の3行目は、「色ではないデータに、_SRGBを付けてしまった」ときの、被害の例にもなっています。たとえば、ラフネスマップの128(線形の値としては0.5相当)を、UNORM_SRGBで読むと、シェーダーには、約0.216(55相当)の値が、渡ります。テクスチャが、暗いのではなく、データそのものが、書き換わります。(ラフネスについては、PBRのラフネスの記事で扱っています。)

よくある失敗例と対処法

①画面全体が暗い

実験②の3行目の形です。テクスチャを_SRGBで読んでいるのに、描画先がUNORMで、sRGBに戻す変換がない可能性があります。描画先を_SRGBにするか、シェーダーの最後で、ガンマ補正を入れます。

②画面全体が、白っぽくぼやける

実験②の4行目の形です。テクスチャは、UNORMで読んでいるのに、描画先が_SRGBで、二重に、明るくなっています。テクスチャを、_SRGBで読むようにそろえます。

③法線マップやラフネスが、おかしい

色ではないデータを、_SRGBで読んでいないかを確認します。値が、約0.216倍のように、暗くなっていたら、この形です。

④ブレンドの結果が、他のツールと違う

実験④のとおり、描画先が_SRGBかどうかで、混ざり方が変わります。画像編集ソフトの見た目と、そろえたいときは、どちらの空間で計算されているのかを、確かめます。

⑤ミップマップの縮小で、遠景だけ暗い・明るい

ミップマップの生成も、_SRGBのテクスチャなら、線形空間で行うのが、自然です。ミップマップの記事や、テクスチャフィルタリングの記事とあわせて、見てください(今回の実験は、ミップマップを含んでいません)。

注意点

  • _SRGBは、読み込みでは「線形に変換」、書き込みでは「sRGBに変換」を、ハードウェアが自動で行う
  • 読み込み側と描画先が、食い違うと、灰色の128が、55(暗すぎ)や188(明るすぎ)になった
  • 線形な0〜1のグラデーションを、UNORM_SRGBに書くと、64番目が138、128番目が188になった
  • ブレンドとバイリニアは、_SRGBの描画先では、線形空間で計算される(黒と白の中間が、127ではなく187〜188)
  • 法線マップやラフネスなどの、色でないデータには、_SRGBを付けない
  • 今回の検証は、DirectX11のハードウェアデバイスで、R8G8B8A8の描画先を使って行った。スワップチェーンや、ミップマップ、ライブラリのフラグは、検証していない

この記事のポイント

  • 暗い・白っぽい原因は、読み込み側と描画先の、sRGBとUNORMの食い違いであることが多い
  • 色の画像は_SRGBで読み、描画先も_SRGBにそろえる(または、最後にガンマ補正を入れる)
  • 色ではないデータは、_SRGBで読まない
  • 迷ったら、灰色128のテクスチャを貼って、描画先の画素の値を、読み出して確かめる

色がおかしいとき、画面を眺めていても、「どのくらい、ずれているか」は、分かりません。灰色の128を、貼ってみる。128なら、設定が、そろっています。55か188なら、どちらの変換が、片側だけに入っているかが、すぐに、分かります。

あわせて読みたい