LCOV - code coverage report
Current view: top level - systems - render3d.go Coverage Total Hit
Test: coverage.lcov Lines: 64.8 % 400 259
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package systems
       2              : 
       3              : import (
       4              :         "fmt"
       5              :         "image"
       6              :         "image/color"
       7              :         "sort"
       8              :         "sync"
       9              : 
      10              :         "github.com/hajimehoshi/ebiten/v2"
      11              :         gc "github.com/kijimaD/ruins/internal/components"
      12              :         "github.com/kijimaD/ruins/internal/consts"
      13              :         "github.com/kijimaD/ruins/internal/raw"
      14              :         "github.com/kijimaD/ruins/internal/rawschema"
      15              :         "github.com/kijimaD/ruins/internal/render3d"
      16              :         w "github.com/kijimaD/ruins/internal/world"
      17              :         "github.com/kijimaD/ruins/internal/world/query"
      18              :         "github.com/mlange-42/ark/ecs"
      19              : )
      20              : 
      21              : // Render3DSystem は壁と床をローポリの3Dで描くレンダラである。
      22              : // 既存の RenderSpriteSystem と同じ ECS ワールドを読み、床タイルを水平クアッド、
      23              : // 壁タイルを箱、それ以外のエンティティをビルボードとして透視投影する。
      24              : // テクスチャは既存スプライトシートをそのまま流用する。Ebiten は深度バッファを持たないため、
      25              : // 各クアッドをカメラ空間の奥行きで並べ替える画家アルゴリズムで隠面を解く。
      26              : type Render3DSystem struct {
      27              :         // UseFOV は視界データに従い、隠れたタイルを描かず記憶タイルを減光する。
      28              :         // 本番のダンジョンでは true、部屋全体を見せたいデモでは false にする。
      29              :         // TODO: この切り替えは system でなく設定で保持する。設計は docs/design/260822112145.md
      30              :         UseFOV bool
      31              : 
      32              :         // 毎フレーム作り直さず使い回す描画バッファ。容量がフレーム間で保たれるので確保・コピー・GC を
      33              :         // 起こさない。Draw は単一ゴルーチンなので共有して安全。
      34              :         quads []r3quad
      35              :         verts []ebiten.Vertex
      36              :         inds  []uint16
      37              : }
      38              : 
      39              : // String は w.Renderer を満たす。
      40            1 : func (sys *Render3DSystem) String() string { return "Render3DSystem" }
      41              : 
      42              : // --- クアッド ---
      43              : 
      44              : type r3quad struct {
      45              :         p     [4]render3d.Vec
      46              :         uv    [4][2]float64
      47              :         atlas *ebiten.Image
      48              :         col   [3]float64 // 頂点色の乗算。テクスチャ面は灰色の減光、フラット面は平均色
      49              :         alpha float64    // 頂点アルファ。既定は不透明の1。霜など半透明の重ねだけ1未満にする
      50              :         key   float64
      51              :         // depth は画家ソートの副キー。quad は元エンティティを持たないので、立て板を作るときにSpriteRender.Depth をここへ焼き込む
      52              :         depth int
      53              : }
      54              : 
      55              : // dayOverbright* はタイルが受ける環境光が強いほどタイルの明るさを乗算の天井 1.0 超へ持ち上げる帯。
      56              : // テクスチャ本来の明るさを越えて晴天らしく明るく見せる。dayOverbrightLow 以下では持ち上げない。
      57              : // vision.go の lightFadeHigh と同じ環境光のスケールの値で、役割ごとに段階が分かれる。
      58              : // まず環境光 lightFadeHigh までに光源の寄与を消し、そこからさらに明るい dayOverbrightHigh に向けて日中の底上げが最大になる。
      59              : const (
      60              :         dayOverbrightMax  = 0.3
      61              :         dayOverbrightLow  = 0.6
      62              :         dayOverbrightHigh = 0.95
      63              : )
      64              : 
      65              : // tintFunc はタイルへ乗せる乗算色 tint と描画状態を返す。tint は明るさと光源色を合成済み。
      66              : // drawable はタイルを描くか、visible は今まさに見えているか。動体は visible のときだけ描く。
      67              : type tintFunc func(*gc.GridElement) (tint [3]float64, drawable, visible bool)
      68              : 
      69              : // normalizeLight は光源色を最大成分で正規化した乗算色にする。明るさは bright が持つので、
      70              : // ここでは色味だけを表す。無色や未設定は {1,1,1} を返す。
      71              : func normalizeLight(c color.RGBA) [3]float64 {
      72            1 :         m := max(c.R, max(c.G, c.B))
      73            1 :         if c.A == 0 || m == 0 {
      74            1 :                 return [3]float64{1, 1, 1}
      75            1 :         }
      76            1 :         f := 1.0 / float64(m)
      77            1 :         return [3]float64{float64(c.R) * f, float64(c.G) * f, float64(c.B) * f}
      78              : }
      79              : 
      80              : // spriteRect は SpriteRender からアトラス画像と切り出し矩形を解決する。見つからなければ ok=false。
      81              : func (sys *Render3DSystem) spriteRect(world w.World, sr *gc.SpriteRender) (atlas *ebiten.Image, x, y, ww, hh float64, ok bool) {
      82            1 :         tex, rect, ok := world.Resources.Sprites.Rect(sr)
      83            1 :         if !ok {
      84            1 :                 return nil, 0, 0, 0, 0, false
      85            1 :         }
      86            1 :         return tex.Image, float64(rect.Min.X), float64(rect.Min.Y), float64(rect.Dx()), float64(rect.Dy()), true
      87              : }
      88              : 
      89              : // scaleCol は色に係数を掛ける。面ごとのシェードを乗算色へ乗せるのに使う。
      90              : func scaleCol(c [3]float64, s float64) [3]float64 {
      91            1 :         return [3]float64{c[0] * s, c[1] * s, c[2] * s}
      92            1 : }
      93              : 
      94              : func (sys *Render3DSystem) addQuad(out *[]r3quad, p0, p1, p2, p3 render3d.Vec, atlas *ebiten.Image, x, y, ww, hh float64, col [3]float64) {
      95            1 :         *out = append(*out, r3quad{
      96            1 :                 p:     [4]render3d.Vec{p0, p1, p2, p3},
      97            1 :                 uv:    [4][2]float64{{x, y}, {x + ww, y}, {x + ww, y + hh}, {x, y + hh}},
      98            1 :                 atlas: atlas,
      99            1 :                 col:   col,
     100            1 :                 alpha: 1,
     101            1 :         })
     102            1 : }
     103              : 
     104              : // addFlatQuad は面をスプライトの平均色でフラットに塗る。壁の側面に使う。真上視点用テクスチャを
     105              : // 垂直面へ引き伸ばす違和感を避け、新規アートなしでローポリらしい平板シェードにする。
     106              : func (sys *Render3DSystem) addFlatQuad(out *[]r3quad, p0, p1, p2, p3 render3d.Vec, atlas *ebiten.Image, x, y, ww, hh float64, col [3]float64) {
     107            0 :         c := avgSpriteColor(atlas, x, y, ww, hh)
     108            0 :         *out = append(*out, r3quad{
     109            0 :                 p:     [4]render3d.Vec{p0, p1, p2, p3},
     110            0 :                 uv:    [4][2]float64{{0, 0}, {0, 0}, {0, 0}, {0, 0}},
     111            0 :                 atlas: whitePixel(),
     112            0 :                 col:   [3]float64{c[0] * col[0], c[1] * col[1], c[2] * col[2]},
     113            0 :                 alpha: 1,
     114            0 :         })
     115            0 : }
     116              : 
     117              : type flatColorKey struct {
     118              :         atlas      *ebiten.Image
     119              :         x, y, w, h int
     120              : }
     121              : 
     122              : var (
     123              :         r3whiteImg  *ebiten.Image
     124              :         r3whiteOnce sync.Once
     125              :         r3flatColor sync.Map // flatColorKey -> [3]float64
     126              : )
     127              : 
     128              : // whitePixel はフラット塗り用の白1pxを返す。頂点色をそのまま出すために使う。
     129              : // アトラス配置に画素が左右されないよう unmanaged で作る。機構は components.Texture を参照
     130              : func whitePixel() *ebiten.Image {
     131            1 :         r3whiteOnce.Do(func() {
     132            1 :                 r3whiteImg = ebiten.NewImageWithOptions(image.Rect(0, 0, 1, 1), &ebiten.NewImageOptions{Unmanaged: true})
     133            1 :                 r3whiteImg.Fill(color.White)
     134            1 :         })
     135            1 :         return r3whiteImg
     136              : }
     137              : 
     138              : // avgSpriteColor はアトラス上の矩形の平均色を 0..1 で返す。透明画素は除く。結果はキャッシュする。
     139              : func avgSpriteColor(atlas *ebiten.Image, x, y, w, h float64) [3]float64 {
     140            0 :         key := flatColorKey{atlas, int(x), int(y), int(w), int(h)}
     141            0 :         if v, ok := r3flatColor.Load(key); ok {
     142            0 :                 if c, ok2 := v.([3]float64); ok2 {
     143            0 :                         return c
     144            0 :                 }
     145              :         }
     146            0 :         var sr, sg, sb, n float64
     147            0 :         for py := int(y); py < int(y+h); py++ {
     148            0 :                 for px := int(x); px < int(x+w); px++ {
     149            0 :                         cr, cg, cb, ca := atlas.At(px, py).RGBA()
     150            0 :                         if ca == 0 {
     151            0 :                                 continue
     152              :                         }
     153            0 :                         sr += float64(cr >> 8)
     154            0 :                         sg += float64(cg >> 8)
     155            0 :                         sb += float64(cb >> 8)
     156            0 :                         n++
     157              :                 }
     158              :         }
     159            0 :         res := [3]float64{0.5, 0.5, 0.5}
     160            0 :         if n > 0 {
     161            0 :                 res = [3]float64{sr / n / 255, sg / n / 255, sb / n / 255}
     162            0 :         }
     163            0 :         r3flatColor.Store(key, res)
     164            0 :         return res
     165              : }
     166              : 
     167              : // Draw は w.Renderer を満たす。3Dシーンを screen へ描く。
     168              : func (sys *Render3DSystem) Draw(world w.World, screen *ebiten.Image) error {
     169            0 :         quads, projector, err := sys.buildScene(world)
     170            0 :         if err != nil {
     171            0 :                 return err
     172            0 :         }
     173            0 :         sys.emit(screen, quads, projector)
     174            0 :         return nil
     175              : }
     176              : 
     177              : // buildScene は投影とクアッド列を組み立てる。Draw の幾何を1箇所に集約する。
     178              : func (sys *Render3DSystem) buildScene(world w.World) ([]r3quad, render3d.Projector, error) {
     179            1 :         projector, err := render3d.WorldProjector(world)
     180            1 :         if err != nil {
     181            0 :                 return nil, render3d.Projector{}, err
     182            0 :         }
     183              : 
     184            1 :         visTint := sys.visTintFunc(world)
     185            1 :         // 前フレームのバッファを [:0] で使い回す。追記で伸びた容量を最後に持ち越す
     186            1 :         walls := render3d.BoxTileSet(world)
     187            1 :         quads := sys.collectTiles(world, sys.quads[:0], projector, visTint, walls)
     188            1 :         quads = sys.collectBillboards(world, quads, projector, visTint, walls, closedInsets(world), posesAt(world))
     189            1 :         // 状態従属の装飾もクアッドとして積み、深度ソートで手前の壁に隠させる
     190            1 :         quads = sys.collectDecorations(world, quads, projector)
     191            1 :         // 展開中キューブの野営エリアを囲むレーザー壁も状態従属の装飾として積む
     192            1 :         quads = sys.collectDeployField(world, quads, projector)
     193            1 :         // 戻り値は sys.quads と同一スライス。emit がそのまま辿り、次フレームは [:0] で容量を使い回す
     194            1 :         sys.quads = quads
     195            1 :         return quads, projector, nil
     196              : }
     197              : 
     198              : // deployFieldColor は展開エリアを囲むレーザー壁の色。強化マスを思わせる青。
     199              : var deployFieldColor = [3]float64{0.3, 0.6, 1.0}
     200              : 
     201              : const (
     202              :         // deployFieldAlpha は壁の半透明度。エネルギー幕らしく向こうが透ける
     203              :         deployFieldAlpha = 0.45
     204              :         // deployFieldHeight は壁の高さ。建物ほど高くせず、囲いと分かる程度に立てる。単位はタイル幅
     205              :         deployFieldHeight = 0.6
     206              : )
     207              : 
     208              : // collectDeployField は展開中キューブの野営エリアを囲む青いレーザー壁を積む。エリアはキューブ中心の
     209              : // 縦横別半径 CubeDeployBaseRange の矩形。隣がエリア外の辺にだけ縦面を張り、外周だけを描く。
     210              : // エネルギー幕なので明るさに依らず一定の青で光らせ、visTint は掛けない。
     211              : func (sys *Render3DSystem) collectDeployField(world w.World, quads []r3quad, projector render3d.Projector) []r3quad {
     212            1 :         area := deployFieldArea(world)
     213            1 :         if len(area) == 0 {
     214            1 :                 return quads
     215            1 :         }
     216            1 :         h := deployFieldHeight
     217            1 :         for tile := range area {
     218            1 :                 if !projector.TileOnScreen(tile, h) {
     219            1 :                         continue
     220              :                 }
     221            1 :                 fx, fz := float64(tile.X), float64(tile.Y)
     222            1 :                 if !area[tile.Add(consts.Coord[consts.Tile]{X: 0, Y: -1})] {
     223            1 :                         sys.addFieldWall(&quads, render3d.At(fx, 0, fz), render3d.At(fx+1, 0, fz), render3d.At(fx+1, h, fz), render3d.At(fx, h, fz))
     224            1 :                 }
     225            1 :                 if !area[tile.Add(consts.Coord[consts.Tile]{X: 0, Y: 1})] {
     226            1 :                         sys.addFieldWall(&quads, render3d.At(fx, 0, fz+1), render3d.At(fx+1, 0, fz+1), render3d.At(fx+1, h, fz+1), render3d.At(fx, h, fz+1))
     227            1 :                 }
     228            1 :                 if !area[tile.Add(consts.Coord[consts.Tile]{X: -1, Y: 0})] {
     229            1 :                         sys.addFieldWall(&quads, render3d.At(fx, 0, fz), render3d.At(fx, 0, fz+1), render3d.At(fx, h, fz+1), render3d.At(fx, h, fz))
     230            1 :                 }
     231            1 :                 if !area[tile.Add(consts.Coord[consts.Tile]{X: 1, Y: 0})] {
     232            1 :                         sys.addFieldWall(&quads, render3d.At(fx+1, 0, fz), render3d.At(fx+1, 0, fz+1), render3d.At(fx+1, h, fz+1), render3d.At(fx+1, h, fz))
     233            1 :                 }
     234              :         }
     235            1 :         return quads
     236              : }
     237              : 
     238              : // deployFieldArea は展開中の各キューブの野営矩形を合わせたタイル集合を返す。矩形はキューブ中心の
     239              : // 縦横別半径 CubeDeployBaseRange。レーザー壁の外周判定の元になる。
     240              : func deployFieldArea(world w.World) map[consts.Coord[consts.Tile]]bool {
     241            1 :         area := make(map[consts.Coord[consts.Tile]]bool)
     242            1 :         q := query.ActiveFilter2[gc.Deployed, gc.GridElement](world).Query()
     243            1 :         defer q.Close()
     244            1 :         for q.Next() {
     245            1 :                 e := q.Entity()
     246            1 :                 c := world.Components.GridElement.Get(e).Coord
     247            1 :                 // 壁は展開時に凍結した範囲で描く。展開中にモジュールで範囲が伸びても野営の見た目は変えない
     248            1 :                 r := world.Components.Deployed.Get(e).Range
     249            1 :                 for dy := -r.Y; dy <= r.Y; dy++ {
     250            1 :                         for dx := -r.X; dx <= r.X; dx++ {
     251            1 :                                 area[consts.Coord[consts.Tile]{X: c.X + dx, Y: c.Y + dy}] = true
     252            1 :                         }
     253              :                 }
     254              :         }
     255            1 :         return area
     256              : }
     257              : 
     258              : // addFieldWall はレーザー壁の縦面を1枚積む。白1pxを青の頂点色と半透明で塗り、エネルギー幕にする。
     259              : func (sys *Render3DSystem) addFieldWall(out *[]r3quad, p0, p1, p2, p3 render3d.Vec) {
     260            1 :         *out = append(*out, r3quad{
     261            1 :                 p:     [4]render3d.Vec{p0, p1, p2, p3},
     262            1 :                 uv:    [4][2]float64{{0, 0}, {0, 0}, {0, 0}, {0, 0}},
     263            1 :                 atlas: whitePixel(),
     264            1 :                 col:   deployFieldColor,
     265            1 :                 alpha: deployFieldAlpha,
     266            1 :         })
     267            1 : }
     268              : 
     269              : // lightSample は解決済みの明るさと色。フィルタ列で乗算色まで変換する。
     270              : type lightSample struct {
     271              :         brightness float64    // 0..1 の明るさ。overbright で 1.0 を超えうる
     272              :         color      [3]float64 // 光源色の乗算色。無色なら {1,1,1}
     273              : }
     274              : 
     275              : // sampleOf はタイルの描画情報から明るさと色のサンプルを起こす。可視は Darkness を 1-d の
     276              : // 明るさへ、LightColor を色味へ反映する。記憶は visible=false、未探索は drawable=false。
     277              : func sampleOf(info TileRenderInfo) (s lightSample, drawable, visible bool) {
     278            1 :         switch v := info.(type) {
     279              :         case TileRenderVisible:
     280            1 :                 return lightSample{1 - float64(v.Darkness), normalizeLight(v.LightColor)}, true, true
     281              :         case TileRenderRemembered:
     282            1 :                 return lightSample{1 - float64(v.Darkness), [3]float64{1, 1, 1}}, true, false
     283              :         default:
     284            1 :                 return lightSample{}, false, false
     285              :         }
     286              : }
     287              : 
     288              : // overbright は明るさを boost 倍に持ち上げる。
     289              : func (s lightSample) overbright(boost float64) lightSample {
     290            1 :         s.brightness *= boost
     291            1 :         return s
     292            1 : }
     293              : 
     294              : // tint はサンプルを乗算色にする。
     295              : func (s lightSample) tint() [3]float64 {
     296            1 :         return scaleCol(s.color, s.brightness)
     297            1 : }
     298              : 
     299              : // visTintFunc はタイルへ乗せる乗算色 tint を返す関数を作る。隠れタイルは drawable=false。
     300              : func (sys *Render3DSystem) visTintFunc(world w.World) tintFunc {
     301            1 :         if !sys.UseFOV {
     302            2 :                 return func(*gc.GridElement) ([3]float64, bool, bool) { return [3]float64{1, 1, 1}, true, true }
     303              :         }
     304            1 :         renderMap := computeTileRenderMap(world, query.GetVisionState(world).LightSourceCache)
     305            1 :         // タイルの受ける環境光が強いほど明るさを 1.0 超へ持ち上げ、乗算の天井を越えて晴天を明るく見せる。
     306              :         // 屋根の下は日照を減らして受けるので持ち上がらない
     307            1 :         return func(g *gc.GridElement) ([3]float64, bool, bool) {
     308            1 :                 info := renderMap[*g]
     309            1 :                 s, drawable, visible := sampleOf(info)
     310            1 :                 if v, ok := info.(TileRenderVisible); ok {
     311            1 :                         s = s.overbright(1 + dayOverbrightMax*smoothstep(dayOverbrightLow, dayOverbrightHigh, v.Ambient))
     312            1 :                 }
     313            1 :                 return s.tint(), drawable, visible
     314              :         }
     315              : }
     316              : 
     317              : // collectTiles は床と壁のクアッドを quads へ追記して返す。
     318              : func (sys *Render3DSystem) collectTiles(world w.World, quads []r3quad, projector render3d.Projector, visTint tintFunc, walls map[consts.Coord[consts.Tile]]bool) []r3quad {
     319            1 :         snow := sys.newSnowLayer(world)
     320            1 :         tileQ := query.ActiveFilter3[gc.SpriteRender, gc.GridElement, gc.Tile](world).Query()
     321            1 :         for tileQ.Next() {
     322            0 :                 e := tileQ.Entity()
     323            0 :                 g := world.Components.GridElement.Get(e)
     324            0 :                 fx, fz := float64(g.X), float64(g.Y)
     325            0 :                 // 画面に掛からない升はクアッドを積む前に落とす。壁は上へ伸びるので天面 WallHeight まで含める
     326            0 :                 if !projector.TileOnScreen(g.Coord, render3d.WallHeight) {
     327            0 :                         continue
     328              :                 }
     329            0 :                 sr := world.Components.SpriteRender.Get(e)
     330            0 :                 atlas, ux, uy, uw, uh, ok := sys.spriteRect(world, sr)
     331            0 :                 if !ok {
     332            0 :                         continue
     333              :                 }
     334            0 :                 tint, vok, _ := visTint(g)
     335            0 :                 if !vok {
     336            0 :                         continue
     337              :                 }
     338            0 :                 if render3d.IsBoxTileEntity(world, e) {
     339            0 :                         sys.addWall(&quads, walls, g.Coord, fx, fz, atlas, ux, uy, uw, uh, tint)
     340            0 :                 } else {
     341            0 :                         sys.addQuad(&quads, render3d.At(fx, 0, fz), render3d.At(fx+1, 0, fz), render3d.At(fx+1, 0, fz+1), render3d.At(fx, 0, fz+1), atlas, ux, uy, uw, uh, tint)
     342            0 :                         snow.add(&quads, world, e, g.Coord, tint)
     343            0 :                 }
     344              :         }
     345            1 :         return quads
     346              : }
     347              : 
     348              : // snowLayer は1回の描画で地面に重ねる雪の層。雪の割合はその日の平均気温から決まり行ごとに同じなので、
     349              : // 行ごとに1回だけ求める
     350              : type snowLayer struct {
     351              :         sys            *Render3DSystem
     352              :         atlas          *ebiten.Image
     353              :         ux, uy, uw, uh float64
     354              :         ok             bool
     355              :         fractions      map[consts.Tile]float64
     356              : }
     357              : 
     358              : // newSnowLayer は雪の層の絵を raw の雪のタイルから引く。引けなければ雪を重ねない
     359              : func (sys *Render3DSystem) newSnowLayer(world w.World) *snowLayer {
     360            1 :         l := &snowLayer{sys: sys, fractions: map[consts.Tile]float64{}}
     361            1 :         row, err := raw.GetTile(world.Resources.RawMaster, consts.TileNameSnow)
     362            1 :         if err != nil {
     363            0 :                 return l
     364            0 :         }
     365            1 :         sr := gc.SpriteRender{SpriteSheetName: row.SpriteRender.SpriteSheetName, SpriteKey: row.SpriteRender.SpriteKey}
     366            1 :         l.atlas, l.ux, l.uy, l.uw, l.uh, l.ok = sys.spriteRect(world, &sr)
     367            1 :         return l
     368              : }
     369              : 
     370              : // amount は地面 e に積もる雪の量を返す。通れて屋根の無い地面のときだけ正になり、タイルの解けやすさの分だけ減る
     371              : func (l *snowLayer) amount(world w.World, e ecs.Entity, c consts.Coord[consts.Tile]) float64 {
     372            1 :         if world.Components.BlockPass.Has(e) || !world.Components.TileEnvironment.Has(e) {
     373            1 :                 return 0
     374            1 :         }
     375            1 :         env := world.Components.TileEnvironment.Get(e)
     376            1 :         if world.Resources.TileEnvDefs.Shelters[env.Shelter].Covered {
     377            1 :                 return 0
     378            1 :         }
     379            1 :         f, ok := l.fractions[c.Y]
     380            1 :         if !ok {
     381            1 :                 f = query.SnowFractionAt(world, c.Y)
     382            1 :                 l.fractions[c.Y] = f
     383            1 :         }
     384            1 :         return query.SnowAmount(f, query.SnowRankAt(world, c.X, c.Y)) * float64(100-env.SnowMeltPercent) / 100
     385              : }
     386              : 
     387              : // add は地面 e の上に、積もる量を透明度にした雪の層を重ねる。地面より後に描くよう depth を1つ上げる
     388              : func (l *snowLayer) add(out *[]r3quad, world w.World, e ecs.Entity, c consts.Coord[consts.Tile], tint [3]float64) {
     389            0 :         if !l.ok {
     390            0 :                 return
     391            0 :         }
     392            0 :         a := l.amount(world, e, c)
     393            0 :         if a <= 0 {
     394            0 :                 return
     395            0 :         }
     396            0 :         fx, fz := float64(c.X), float64(c.Y)
     397            0 :         l.sys.addQuad(out, render3d.At(fx, 0, fz), render3d.At(fx+1, 0, fz), render3d.At(fx+1, 0, fz+1), render3d.At(fx, 0, fz+1), l.atlas, l.ux, l.uy, l.uw, l.uh, tint)
     398            0 :         q := &(*out)[len(*out)-1]
     399            0 :         q.alpha = a
     400            0 :         q.depth = 1
     401              : }
     402              : 
     403              : // addWall は壁1マスの天面と、隣が壁でない側だけの側面を積む。
     404              : func (sys *Render3DSystem) addWall(out *[]r3quad, walls map[consts.Coord[consts.Tile]]bool, c consts.Coord[consts.Tile], fx, fz float64, atlas *ebiten.Image, ux, uy, uw, uh float64, tint [3]float64) {
     405              :         // 天面は真上視点なので既存テクスチャをそのまま貼り、側面はフラット単色にする。
     406              :         // 面ごとのシェード 天面0.95・南北0.6・東西0.78 は疑似方向光源で、平板な側面に陰影を付けて立体に見せる
     407            0 :         sys.addQuad(out, render3d.At(fx, render3d.WallHeight, fz), render3d.At(fx+1, render3d.WallHeight, fz), render3d.At(fx+1, render3d.WallHeight, fz+1), render3d.At(fx, render3d.WallHeight, fz+1), atlas, ux, uy, uw, uh, scaleCol(tint, 0.95))
     408            0 :         if !walls[c.Add(consts.Coord[consts.Tile]{X: 0, Y: -1})] {
     409            0 :                 sys.addFlatQuad(out, render3d.At(fx, 0, fz), render3d.At(fx+1, 0, fz), render3d.At(fx+1, render3d.WallHeight, fz), render3d.At(fx, render3d.WallHeight, fz), atlas, ux, uy, uw, uh, scaleCol(tint, 0.6))
     410            0 :         }
     411            0 :         if !walls[c.Add(consts.Coord[consts.Tile]{X: 0, Y: 1})] {
     412            0 :                 sys.addFlatQuad(out, render3d.At(fx+1, 0, fz+1), render3d.At(fx, 0, fz+1), render3d.At(fx, render3d.WallHeight, fz+1), render3d.At(fx+1, render3d.WallHeight, fz+1), atlas, ux, uy, uw, uh, scaleCol(tint, 0.6))
     413            0 :         }
     414            0 :         if !walls[c.Add(consts.Coord[consts.Tile]{X: -1, Y: 0})] {
     415            0 :                 sys.addFlatQuad(out, render3d.At(fx, 0, fz+1), render3d.At(fx, 0, fz), render3d.At(fx, render3d.WallHeight, fz), render3d.At(fx, render3d.WallHeight, fz+1), atlas, ux, uy, uw, uh, scaleCol(tint, 0.78))
     416            0 :         }
     417            0 :         if !walls[c.Add(consts.Coord[consts.Tile]{X: 1, Y: 0})] {
     418            0 :                 sys.addFlatQuad(out, render3d.At(fx+1, 0, fz), render3d.At(fx+1, 0, fz+1), render3d.At(fx+1, render3d.WallHeight, fz+1), render3d.At(fx+1, render3d.WallHeight, fz), atlas, ux, uy, uw, uh, scaleCol(tint, 0.78))
     419            0 :         }
     420              : }
     421              : 
     422              : // collectBillboards はタイル以外のエンティティを SpriteRender.Shape の形で積む。省けばカメラを向く立て板、
     423              : // inset は壁にはめる板、facing は置き方 Pose に合わせて立てる閉じた板にし、Pose が無ければ立て板にする。床の模様は地面に寝かせる。
     424              : func (sys *Render3DSystem) collectBillboards(world w.World, quads []r3quad, projector render3d.Projector, visTint tintFunc, walls, insets map[consts.Coord[consts.Tile]]bool, poses map[consts.Coord[consts.Tile]]gc.Pose) []r3quad {
     425            1 :         right := projector.Right()
     426            1 :         objQ := query.ActiveFilter2[gc.SpriteRender, gc.GridElement](world).Without(ecs.C[gc.Tile]()).Query()
     427            1 :         for objQ.Next() {
     428            1 :                 e := objQ.Entity()
     429            1 :                 g := world.Components.GridElement.Get(e)
     430            1 :                 fx, fz := float64(g.X), float64(g.Y)
     431            1 :                 // 立て板は上へ伸びるので天面 BillboardHeight まで含めて画面掛かりを判定する
     432            1 :                 if !projector.TileOnScreen(g.Coord, render3d.BillboardHeight) {
     433            0 :                         continue
     434              :                 }
     435            1 :                 sr := world.Components.SpriteRender.Get(e)
     436            1 :                 atlas, ux, uy, uw, uh, ok := sys.spriteRect(world, sr)
     437            1 :                 if !ok {
     438            1 :                         continue
     439              :                 }
     440            1 :                 tint, vok, vis := visTint(g)
     441            1 :                 if !vok {
     442            0 :                         continue
     443              :                 }
     444            1 :                 if sr.Depth == gc.DepthNumDecal {
     445              :                         // 奥行きが床と同値になるので、副キーの描画順で床の直後に描く
     446            1 :                         sys.addQuad(&quads, render3d.At(fx, 0, fz), render3d.At(fx+1, 0, fz), render3d.At(fx+1, 0, fz+1), render3d.At(fx, 0, fz+1), atlas, ux, uy, uw, uh, tint)
     447            1 :                         quads[len(quads)-1].depth = int(sr.Depth)
     448            1 :                         continue
     449              :                 }
     450            1 :                 if sr.Shape == rawschema.Inset {
     451              :                         // 壁と同じく記憶エリアにも描く。視界の外の開け閉めを見せないよう、記憶エリアでは閉じた形にする。
     452              :                         // 開いた扉は描かず、開口部だけを残す
     453            1 :                         if !vis || world.Components.BlockPass.Has(e) {
     454            0 :                                 sys.addSlab(&quads, insetFaces(g.Coord, insetConnections(walls, insets, g.Coord)), atlas, ux, uy, uw, uh, tint)
     455            0 :                         }
     456            1 :                         continue
     457              :                 }
     458              :                 // 動体は今見えているタイルにだけ描く。フォグ内や記憶エリアの敵・アイテムは位置を見せない。
     459              :                 // 地面に寝かせるものは床と同じく記憶エリアにも描く
     460            1 :                 if !vis {
     461            0 :                         continue
     462              :                 }
     463            1 :                 if f, ok := poses[g.Coord]; ok && sr.Shape == rawschema.Facing {
     464            0 :                         drawn := func(n consts.Coord[consts.Tile]) bool {
     465            0 :                                 _, _, v := visTint(&gc.GridElement{Coord: n})
     466            0 :                                 return v && projector.TileOnScreen(n, render3d.BillboardHeight)
     467            0 :                         }
     468            0 :                         sys.addSlab(&quads, facingFaces(g.Coord, f, poses, drawn), atlas, ux, uy, uw, uh, tint)
     469            0 :                         continue
     470              :                 }
     471            1 :                 base := render3d.At(fx+0.5, 0, fz+0.5)
     472            1 :                 const bw = 0.45
     473            1 :                 const bh = render3d.BillboardHeight
     474            1 :                 b0 := render3d.Add(base, render3d.Scale(right, -bw))
     475            1 :                 b1 := render3d.Add(base, render3d.Scale(right, bw))
     476            1 :                 top := render3d.At(0, bh, 0)
     477            1 :                 tl, tr := render3d.Add(b0, top), render3d.Add(b1, top)
     478            1 :                 // 立て板の上下は SpriteRender.Depth で決める。同一タイルの立て板は4隅が一致して奥行きが
     479              :                 // 同値になるので、この副キーが無いと走査順で前後がばらつく
     480            1 :                 depth := int(sr.Depth)
     481            1 :                 sys.addQuad(&quads, tl, tr, b1, b0, atlas, ux, uy, uw, uh, tint)
     482            1 :                 quads[len(quads)-1].depth = depth
     483              :         }
     484            1 :         return quads
     485              : }
     486              : 
     487              : // insetThickness は壁にはめる置物の板の厚み
     488              : const insetThickness = 0.2
     489              : 
     490              : const (
     491              :         // facingThickness は向きを決めた置物の板の厚み。扉の板とそろえる
     492              :         facingThickness = insetThickness
     493              :         // facingGap は背の塞がりに寄せた板と背のあいだ。壁の面と重なってちらつかないよう少し離す
     494              :         facingGap = 0.02
     495              :         // facingLift は板の正面と背面から絵を浮かせる距離。奥行きの並べ替えで絵を板の面より後に描かせる
     496              :         facingLift = 0.01
     497              : )
     498              : 
     499              : // posesAt は置き方 Pose を持つエンティティの、座標ごとの置き方を返す。板の端を隣とつなぐのに使う
     500              : func posesAt(world w.World) map[consts.Coord[consts.Tile]]gc.Pose {
     501            1 :         poses := map[consts.Coord[consts.Tile]]gc.Pose{}
     502            1 :         q := query.ActiveFilter2[gc.Pose, gc.GridElement](world).Query()
     503            1 :         for q.Next() {
     504            1 :                 poses[world.Components.GridElement.Get(q.Entity()).Coord] = *world.Components.Pose.Get(q.Entity())
     505            1 :         }
     506            1 :         return poses
     507              : }
     508              : 
     509              : // facingFaces は置き方 f の置物の面を返す。平均色で塗った閉じた6面の板の正面と背面に、外向きに絵を貼る。
     510              : // 同じ置き方の隣が描かれ drawn、接するときは、重なってちらつかないよう端を省く
     511              : func facingFaces(c consts.Coord[consts.Tile], f gc.Pose, poses map[consts.Coord[consts.Tile]]gc.Pose, drawn func(consts.Coord[consts.Tile]) bool) []insetFace {
     512            1 :         const h = render3d.WallHeight
     513            1 :         turns := quarterTurns(f.Facing)
     514            1 :         connected := func(side consts.Cardinal) bool {
     515            1 :                 local := side.Delta()
     516            1 :                 for range turns {
     517            1 :                         local = consts.Coord[consts.Tile]{X: -local.Y, Y: local.X}
     518            1 :                 }
     519            1 :                 n, ok := poses[c.Add(local)]
     520            1 :                 return ok && n.Facing == f.Facing && n.Anchor == f.Anchor && drawn(c.Add(local))
     521              :         }
     522            1 :         z0 := 0.5 - facingThickness/2
     523            1 :         if f.Anchor == gc.AnchorBack {
     524            1 :                 z0 = facingGap
     525            1 :         }
     526            1 :         z1 := z0 + facingThickness
     527            1 :         faces := slab(z0, z1, !connected(consts.West), !connected(consts.East))
     528            1 :         for i := range faces {
     529            1 :                 faces[i].flat = true
     530            1 :         }
     531            1 :         faces = append(faces,
     532            1 :                 insetFace{p: [4]render3d.Vec{render3d.At(0, 0, z1), render3d.At(1, 0, z1), render3d.At(1, 0, z0), render3d.At(0, 0, z0)}, flat: true},
     533            1 :                 insetFace{p: [4]render3d.Vec{render3d.At(0, h, z1+facingLift), render3d.At(1, h, z1+facingLift), render3d.At(1, 0, z1+facingLift), render3d.At(0, 0, z1+facingLift)}},
     534            1 :                 insetFace{p: [4]render3d.Vec{render3d.At(1, h, z0-facingLift), render3d.At(0, h, z0-facingLift), render3d.At(0, 0, z0-facingLift), render3d.At(1, 0, z0-facingLift)}},
     535            1 :         )
     536            1 :         for i := range faces {
     537            1 :                 for j, v := range faces[i].p {
     538            1 :                         for range turns {
     539            1 :                                 v = turnQuarter(v)
     540            1 :                         }
     541            1 :                         faces[i].p[j] = render3d.At(v.X+float64(c.X), v.Y, v.Z+float64(c.Y))
     542              :                 }
     543              :         }
     544            1 :         return faces
     545              : }
     546              : 
     547              : // quarterTurns は南を向く板を向き dir へ回す90度の回数を返す
     548              : func quarterTurns(dir consts.Cardinal) int {
     549            1 :         switch dir {
     550              :         case consts.South:
     551            1 :                 return 0
     552              :         case consts.West:
     553            1 :                 return 1
     554              :         case consts.North:
     555            1 :                 return 2
     556              :         case consts.East:
     557            1 :                 return 3
     558              :         }
     559            0 :         panic(fmt.Sprintf("unknown cardinal: %d", int(dir)))
     560              : }
     561              : 
     562              : // insetFace は壁にはめる置物の1面。flat は絵を貼らず平均色で塗る面
     563              : type insetFace struct {
     564              :         p    [4]render3d.Vec
     565              :         flat bool
     566              : }
     567              : 
     568              : // closedInsets は閉じている壁にはめる置物の座標の集合を返す
     569              : func closedInsets(world w.World) map[consts.Coord[consts.Tile]]bool {
     570            1 :         insets := map[consts.Coord[consts.Tile]]bool{}
     571            1 :         q := query.ActiveFilter3[gc.SpriteRender, gc.GridElement, gc.BlockPass](world).Without(ecs.C[gc.Tile]()).Query()
     572            1 :         for q.Next() {
     573            1 :                 if world.Components.SpriteRender.Get(q.Entity()).Shape == rawschema.Inset {
     574            1 :                         insets[world.Components.GridElement.Get(q.Entity()).Coord] = true
     575            1 :                 }
     576              :         }
     577            1 :         return insets
     578              : }
     579              : 
     580              : // connections は壁にはめる置物が、北・東・南・西の隣とつながるか
     581              : type connections struct {
     582              :         north, east, south, west bool
     583              : }
     584              : 
     585              : // insetConnections は c の置物が、隣の壁 walls か閉じている壁にはめる置物 insets とつながるかを返す
     586              : func insetConnections(walls, insets map[consts.Coord[consts.Tile]]bool, c consts.Coord[consts.Tile]) connections {
     587            1 :         at := func(dx, dy consts.Tile) bool {
     588            1 :                 n := c.Add(consts.Coord[consts.Tile]{X: dx, Y: dy})
     589            1 :                 return walls[n] || insets[n]
     590            1 :         }
     591            1 :         return connections{north: at(0, -1), east: at(1, 0), south: at(0, 1), west: at(-1, 0)}
     592              : }
     593              : 
     594              : // insetFaces は閉じた壁にはめる置物の面を返す。つながる向きに並ぶ板にし、つながりが無ければ東西に並べ、
     595              : // つながる端を省く。南北の板は東西の板をタイルの中心で回して作る
     596              : func insetFaces(c consts.Coord[consts.Tile], conn connections) []insetFace {
     597            1 :         alongX := conn.west || conn.east || (!conn.north && !conn.south)
     598            1 :         var faces []insetFace
     599            1 :         if alongX {
     600            1 :                 faces = slab(0.5-insetThickness/2, 0.5+insetThickness/2, !conn.west, !conn.east)
     601            1 :         } else {
     602            1 :                 faces = slab(0.5-insetThickness/2, 0.5+insetThickness/2, !conn.north, !conn.south)
     603            1 :         }
     604            1 :         for i := range faces {
     605            1 :                 for j, v := range faces[i].p {
     606            1 :                         if !alongX {
     607            1 :                                 v = turnQuarter(v)
     608            1 :                         }
     609            1 :                         faces[i].p[j] = render3d.At(v.X+float64(c.X), v.Y, v.Z+float64(c.Y))
     610              :                 }
     611              :         }
     612            1 :         return faces
     613              : }
     614              : 
     615              : // slab は z0..z1 に東西に立つ板の面を、タイルの北西の角を原点に返す。南北の2面に絵を貼り、天面と東西の端は平均色で塗る。
     616              : // westEnd と eastEnd は西と東の端を描くか。面は外から見て左上から時計回りに張る
     617              : func slab(z0, z1 float64, westEnd, eastEnd bool) []insetFace {
     618            1 :         const h = render3d.WallHeight
     619            1 :         faces := []insetFace{
     620            1 :                 {p: [4]render3d.Vec{render3d.At(0, h, z0), render3d.At(1, h, z0), render3d.At(1, h, z1), render3d.At(0, h, z1)}, flat: true},
     621            1 :                 {p: [4]render3d.Vec{render3d.At(1, h, z0), render3d.At(0, h, z0), render3d.At(0, 0, z0), render3d.At(1, 0, z0)}},
     622            1 :                 {p: [4]render3d.Vec{render3d.At(0, h, z1), render3d.At(1, h, z1), render3d.At(1, 0, z1), render3d.At(0, 0, z1)}},
     623            1 :         }
     624            1 :         if westEnd {
     625            1 :                 faces = append(faces, insetFace{p: [4]render3d.Vec{render3d.At(0, h, z0), render3d.At(0, h, z1), render3d.At(0, 0, z1), render3d.At(0, 0, z0)}, flat: true})
     626            1 :         }
     627            1 :         if eastEnd {
     628            1 :                 faces = append(faces, insetFace{p: [4]render3d.Vec{render3d.At(1, h, z1), render3d.At(1, h, z0), render3d.At(1, 0, z0), render3d.At(1, 0, z1)}, flat: true})
     629            1 :         }
     630            1 :         return faces
     631              : }
     632              : 
     633              : // turnQuarter はタイルの中の点を中心で90度回す。西の端が北へ、東の端が南へ来る。裏返らないので面の張り順が保たれる
     634              : func turnQuarter(v render3d.Vec) render3d.Vec {
     635            1 :         return render3d.At(1-v.Z, v.Y, v.X)
     636            1 : }
     637              : 
     638              : // faceShade は面の向きから陰影を返す。天面0.95・東西0.78・南北0.6は壁の箱と同じ疑似方向光源
     639              : func faceShade(p [4]render3d.Vec) float64 {
     640            1 :         switch {
     641              :         case p[0].Y == p[1].Y && p[1].Y == p[2].Y:
     642            1 :                 return 0.95
     643              :         case p[0].X == p[1].X && p[1].X == p[2].X:
     644            1 :                 return 0.78
     645              :         default:
     646            1 :                 return 0.6
     647              :         }
     648              : }
     649              : 
     650              : // addSlab は板の面を積む
     651              : func (sys *Render3DSystem) addSlab(out *[]r3quad, faces []insetFace, atlas *ebiten.Image, ux, uy, uw, uh float64, tint [3]float64) {
     652            0 :         for _, f := range faces {
     653              :                 // 絵を貼る面は立て板と同じ明るさにし、平均色の面にだけ陰影を付ける
     654            0 :                 if f.flat {
     655            0 :                         sys.addFlatQuad(out, f.p[0], f.p[1], f.p[2], f.p[3], atlas, ux, uy, uw, uh, scaleCol(tint, faceShade(f.p)))
     656            0 :                         continue
     657              :                 }
     658            0 :                 sys.addQuad(out, f.p[0], f.p[1], f.p[2], f.p[3], atlas, ux, uy, uw, uh, tint)
     659              :         }
     660              : }
     661              : 
     662              : // sortQuadsByDepth はカメラ空間の奥行きでクアッドを安定ソートする。画家アルゴリズムの前段。
     663              : // クアッドを物理的に並べ替えるので、続く emit は連続アクセスで辿れる。添字ソートは emit が
     664              : // ランダムアクセスになりキャッシュミスで却って遅くなるため採らない。
     665              : func sortQuadsByDepth(quads []r3quad, depth func(render3d.Vec) float64) {
     666            1 :         for i := range quads {
     667            1 :                 c := render3d.Vec{}
     668            1 :                 for _, p := range quads[i].p {
     669            1 :                         c = render3d.Add(c, p)
     670            1 :                 }
     671            1 :                 quads[i].key = depth(render3d.Scale(c, 0.25))
     672              :         }
     673              :         // 奥行きが同値のときは depth で割る。同一タイルの立て板はここで前後が確定する。
     674              :         // 大きい depth を後に描いて手前にし、プレイヤーを足元のアイテムより必ず上へ出す
     675            1 :         sort.SliceStable(quads, func(i, j int) bool {
     676            1 :                 if quads[i].key != quads[j].key {
     677            1 :                         return quads[i].key < quads[j].key
     678            1 :                 }
     679            1 :                 return quads[i].depth < quads[j].depth
     680              :         })
     681              : }
     682              : 
     683              : // emit はクアッドを奥行き順の添字で辿り、アトラスが変わる境目でバッチに分けて描く。
     684              : // 頂点バッファはフレーム間で使い回す。
     685              : func (sys *Render3DSystem) emit(screen *ebiten.Image, quads []r3quad, projector render3d.Projector) {
     686            0 :         sortQuadsByDepth(quads, projector.Depth)
     687            0 : 
     688            0 :         verts := sys.verts[:0]
     689            0 :         inds := sys.inds[:0]
     690            0 :         var curAtlas *ebiten.Image
     691            0 :         flush := func() {
     692            0 :                 if len(inds) == 0 || curAtlas == nil {
     693            0 :                         return
     694            0 :                 }
     695            0 :                 screen.DrawTriangles(verts, inds, curAtlas, &ebiten.DrawTrianglesOptions{})
     696            0 :                 verts = verts[:0]
     697            0 :                 inds = inds[:0]
     698              :         }
     699            0 :         for i := range quads {
     700            0 :                 q := &quads[i]
     701            0 :                 // アトラス切り替え、または uint16 の頂点インデックス上限を跨ぐ前に flush する。
     702              :                 // 同一スプライトシートのタイルが大量に積まれても 65535 を超えると黙って描画化けするため
     703            0 :                 if q.atlas != curAtlas || len(verts)+4 > maxVertsPerBatch {
     704            0 :                         flush()
     705            0 :                         curAtlas = q.atlas
     706            0 :                 }
     707            0 :                 sys.emitQuad(&verts, &inds, q, projector.Point)
     708              :         }
     709            0 :         flush()
     710            0 :         sys.verts = verts
     711            0 :         sys.inds = inds
     712              : }
     713              : 
     714              : // maxVertsPerBatch は1回の DrawTriangles へ積む頂点数の上限。インデックスが uint16 なので 65535 まで。
     715              : const maxVertsPerBatch = 65535
     716              : 
     717              : // emitQuad は1クアッドを三角形2枚として頂点バッファへ積む。画面外の頂点があれば捨てる。
     718              : func (sys *Render3DSystem) emitQuad(verts *[]ebiten.Vertex, inds *[]uint16, q *r3quad, project func(render3d.Vec) (consts.Coord[consts.ScreenPixel], bool)) {
     719            0 :         var sp [4]consts.Coord[consts.ScreenPixel]
     720            0 :         for k, p := range q.p {
     721            0 :                 screenPos, ok := project(p)
     722            0 :                 if !ok {
     723            0 :                         return
     724            0 :                 }
     725            0 :                 sp[k] = screenPos
     726              :         }
     727            0 :         b := uint16(len(*verts))
     728            0 :         cr, cg, cb, ca := float32(q.col[0]), float32(q.col[1]), float32(q.col[2]), float32(q.alpha)
     729            0 :         for k := range 4 {
     730            0 :                 *verts = append(*verts, ebiten.Vertex{
     731            0 :                         DstX: float32(sp[k].X), DstY: float32(sp[k].Y),
     732            0 :                         SrcX: float32(q.uv[k][0]), SrcY: float32(q.uv[k][1]),
     733            0 :                         ColorR: cr, ColorG: cg, ColorB: cb, ColorA: ca,
     734            0 :                 })
     735            0 :         }
     736            0 :         *inds = append(*inds, b, b+1, b+2, b, b+2, b+3)
     737              : }
        

Generated by: LCOV version 2.0-1