同じ灰色(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】にあります。

| テクスチャの読み方 | 描画先 | 描画先の値 | 見た目 |
|---|---|---|---|
UNORM | UNORM | 128 | 正しい(変換なし) |
UNORM_SRGB | UNORM_SRGB | 128 | 正しい(線形で計算して、sRGBに戻した) |
UNORM_SRGB | UNORM | 55 | 暗すぎる(読むときだけ線形に変換して、戻していない) |
UNORM | UNORM_SRGB | 188 | 明るすぎる・白っぽい(sRGBのままの値を線形と見なして、さらに変換した) |
上の2行は、どちらも128で、正しく表示されます。「そろえる」ことが、大事です。食い違った下の2行は、128の灰色が、55(暗い)と188(明るい)に変わりました。画面が全体的に暗くなる、または、全体が白っぽくぼやける、という症状の、典型です。
実験③:なめらかなグラデーションは、どう変わるか
次は、0から1まで、線形になめらかに変化する値を、シェーダーから出力して、2つの描画先に、書き込みました。

左から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で重ねる | 127 | 187 |
| 黒と白のちょうど真ん中を、バイリニアで読む | 127 | 188 |
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なら、どちらの変換が、片側だけに入っているかが、すぐに、分かります。
あわせて読みたい
- 【DirectX11】テクスチャが真っ黒になる・色がおかしい原因とは?|SRV・サンプラー・ミップ・チャンネル順を8通り再現して、デバッグレイヤーが教えてくれるかも確かめる
- 【DirectX11】半透明が表示されない・奥の物体が消える原因とは?|ブレンド設定・描画順・深度書き込みを6通り再現して、画素の値で確かめる
- 【ゲーム制作】PBRのラフネスと反射率とは?|Cook-Torranceを実装して球で比較
- 【ゲーム制作】PNGとHDRの違いとは?|メリットデメリットと使い分けを解説
- 【ゲーム制作】ミップマップとは?|遠くのテクスチャがちらつく原因と仕組み
- 【ゲーム制作】テクスチャフィルタリングとは?|ポイント・バイリニア・トライリニア・異方性を正解画像との差とGPU時間で比べる

