LCOV - code coverage report
Current view: top level - systems - render_sprite.go Coverage Total Hit
Test: coverage.lcov Lines: 8.6 % 280 24
Test Date: 2026-11-19 00:25:22 Functions: - 0 0

            Line data    Source code
       1              : package systems
       2              : 
       3              : import (
       4              :         "cmp"
       5              :         "fmt"
       6              :         "image/color"
       7              :         "slices"
       8              :         "strconv"
       9              :         "strings"
      10              :         "sync"
      11              : 
      12              :         "github.com/hajimehoshi/ebiten/v2"
      13              :         "github.com/hajimehoshi/ebiten/v2/colorm"
      14              :         "github.com/hajimehoshi/ebiten/v2/ebitenutil"
      15              :         gc "github.com/kijimaD/ruins/internal/components"
      16              :         w "github.com/kijimaD/ruins/internal/world"
      17              : 
      18              :         "github.com/kijimaD/ruins/internal/consts"
      19              :         "github.com/kijimaD/ruins/internal/world/query"
      20              :         "github.com/mlange-42/ark/ecs"
      21              : )
      22              : 
      23              : var (
      24              :         wallShadowImage  *ebiten.Image // 壁が落とす影
      25              :         moverShadowImage *ebiten.Image // 動く物体が落とす影
      26              :         shadowImageOnce  sync.Once     // 影画像の初期化を1度だけにし、並列描画のデータレースを防ぐ
      27              : )
      28              : 
      29              : // 記憶タイルの退色パラメータ。彩度を大きく落として明度を少し下げ、記憶らしい見た目にする
      30              : const (
      31              :         memorySaturation = 0.18 // 記憶タイルの彩度。0で完全グレー
      32              :         memoryValue      = 0.9  // 記憶タイルの明度。わずかに暗くする
      33              : )
      34              : 
      35              : // RenderSpriteSystem はスプライト描画システム。
      36              : // スプライト画像の解決とキャッシュは world.Resources.Sprites が持つ。
      37              : type RenderSpriteSystem struct {
      38              :         // darknessMap は1タイル1テクセルの暗さマップ。FilterNearest でタイルサイズへ拡大し、タイル整列の暗闇を描く
      39              :         darknessMap *ebiten.Image
      40              :         // darknessPix は darknessMap へ書き込む画素バッファ。毎フレームの確保を避けて使い回す
      41              :         darknessPix []byte
      42              : }
      43              : 
      44              : // NewRenderSpriteSystem はRenderSpriteSystemを初期化する
      45              : func NewRenderSpriteSystem() *RenderSpriteSystem {
      46            1 :         return &RenderSpriteSystem{}
      47            1 : }
      48              : 
      49              : // setTranslate は真上から見下ろす2D描画の画像配置オプションをセットする。
      50              : // 取得済みカメラを受け取り、per-sprite/per-shadow のホットループでもカメラ取得を1フレーム1回に抑える
      51              : func setTranslate(world w.World, op *ebiten.DrawImageOptions, camera *gc.Camera) {
      52            0 :         cx, cy := float64(world.Resources.ScreenDimensions.Width/2), float64(world.Resources.ScreenDimensions.Height/2)
      53            0 : 
      54              :         // カメラ位置の設定
      55            0 :         if camera != nil {
      56            0 :                 op.GeoM.Translate(-float64(camera.Pos.X), -float64(camera.Pos.Y))
      57            0 :                 op.GeoM.Scale(camera.Scale, camera.Scale)
      58            0 :         }
      59              :         // 画面の中央
      60            0 :         op.GeoM.Translate(cx, cy)
      61              : }
      62              : 
      63              : // viewportTileBounds はカメラの可視範囲をタイル座標の矩形で返す。margin タイル分だけ外側に広げる。
      64              : // 画面外のタイル/スプライト描画をスキップするための可視カリングに使う。
      65              : func viewportTileBounds(world w.World, margin consts.Tile, camera *gc.Camera) (minX, maxX, minY, maxY int) {
      66            1 :         var cameraX, cameraY float64
      67            1 :         cameraScale := 1.0
      68            1 :         if camera != nil {
      69            1 :                 cameraX, cameraY, cameraScale = float64(camera.Pos.X), float64(camera.Pos.Y), camera.Scale
      70            1 :         }
      71            1 :         if cameraScale <= 0 {
      72            1 :                 cameraScale = 1.0
      73            1 :         }
      74            1 :         ts := int(consts.TileSize)
      75            1 :         m := int(margin)
      76            1 :         halfW := int(float64(world.Resources.ScreenDimensions.Width)/cameraScale) / 2
      77            1 :         halfH := int(float64(world.Resources.ScreenDimensions.Height)/cameraScale) / 2
      78            1 :         minX = (int(cameraX)-halfW)/ts - m
      79            1 :         maxX = (int(cameraX)+halfW)/ts + m
      80            1 :         minY = (int(cameraY)-halfH)/ts - m
      81            1 :         maxY = (int(cameraY)+halfH)/ts + m
      82            1 :         return minX, maxX, minY, maxY
      83              : }
      84              : 
      85              : // inViewport は指定タイルが可視範囲矩形内かを返す
      86              : func inViewport(grid *gc.GridElement, minX, maxX, minY, maxY int) bool {
      87            1 :         x, y := int(grid.X), int(grid.Y)
      88            1 :         return x >= minX && x <= maxX && y >= minY && y <= maxY
      89            1 : }
      90              : 
      91              : // viewportCullMargin は可視カリングの外側マージン。単位はタイル。
      92              : // スプライト/影が画面端を跨いでも欠けないよう余裕を持たせる
      93              : const viewportCullMargin consts.Tile = 2
      94              : 
      95              : // String はシステム名を返す
      96              : // w.Renderer interfaceを実装
      97              : func (sys RenderSpriteSystem) String() string {
      98            1 :         return "RenderSpriteSystem"
      99            1 : }
     100              : 
     101              : // Draw は (下) タイル -> 影 -> スプライト -> 暗闇 (上) の順に表示する。
     102              : // 暗闇を最後に重ねることで、床だけでなく影もスプライトも同じ暗さで減光する。
     103              : // w.Renderer interfaceを実装
     104              : func (sys *RenderSpriteSystem) Draw(world w.World, screen *ebiten.Image) error {
     105              :         // VisionSystemが計算した光源情報を取得する
     106            0 :         tileRenderMap := computeTileRenderMap(world, query.GetVisionState(world).LightSourceCache)
     107            0 : 
     108            0 :         initializeShadowImages()
     109            0 : 
     110              :         // カメラはフレーム内で不変。ここで1回だけ取得し各描画関数へ渡す。
     111              :         // 描画するスプライト/影の数だけフィルタ生成が走るのを防ぐ
     112            0 :         camera := query.GetPlayerCamera(world)
     113            0 : 
     114            0 :         if err := sys.renderFloorLayer(world, screen, tileRenderMap, camera); err != nil {
     115            0 :                 return err
     116            0 :         }
     117            0 :         sys.renderShadows(world, screen, tileRenderMap, camera)
     118            0 :         if err := sys.renderObjectLayer(world, screen, tileRenderMap, camera); err != nil {
     119            0 :                 return err
     120            0 :         }
     121              :         // 暗闇は最後に重ねる。床だけでなく影・スプライトも同じ暗さで沈み、光源から離れた
     122              :         // オブジェクトも暗くなる。per-tile の暗さを重ねるのでオブジェクトもタイル単位で減光する
     123            0 :         sys.renderDarkness(world, screen, tileRenderMap, camera)
     124            0 : 
     125            0 :         return nil
     126              : }
     127              : 
     128              : // initializeShadowImages は影画像を初期化する
     129              : func initializeShadowImages() {
     130            0 :         shadowImageOnce.Do(func() {
     131            0 :                 wallWidth := int(consts.TileSize)
     132            0 :                 wallHeight := int(consts.TileSize / 2)
     133            0 :                 if wallWidth > 0 && wallHeight > 0 {
     134            0 :                         wallShadowImage = ebiten.NewImage(wallWidth, wallHeight)
     135            0 :                         wallShadowImage.Fill(color.RGBA{0, 0, 0, 80})
     136            0 :                 }
     137            0 :                 moverWidth := int(consts.TileSize - 6 - 2)
     138            0 :                 moverHeight := int(consts.TileSize / 2)
     139            0 :                 if moverWidth > 0 && moverHeight > 0 {
     140            0 :                         moverShadowImage = ebiten.NewImage(moverWidth, moverHeight)
     141            0 :                         moverShadowImage.Fill(color.RGBA{0, 0, 0, 120})
     142            0 :                 }
     143              :         })
     144              : }
     145              : 
     146              : // renderFloorLayer は床レイヤー(タイル)を描画する
     147              : func (sys *RenderSpriteSystem) renderFloorLayer(world w.World, screen *ebiten.Image, tileRenderMap map[gc.GridElement]TileRenderInfo, camera *gc.Camera) error {
     148            0 :         iSprite := 0
     149            0 :         minX, maxX, minY, maxY := viewportTileBounds(world, viewportCullMargin, camera)
     150            0 :         // タイル総数を上限に確保する。viewport カリングで実際に詰めるのは一部だけ
     151            0 :         countQuery := query.ActiveFilter3[gc.SpriteRender, gc.GridElement, gc.Tile](world).Query()
     152            0 :         entities := make([]ecs.Entity, countQuery.Count())
     153            0 :         countQuery.Close()
     154            0 :         tileQuery := query.ActiveFilter3[gc.SpriteRender, gc.GridElement, gc.Tile](world).Query()
     155            0 :         for tileQuery.Next() {
     156            0 :                 entity := tileQuery.Entity()
     157            0 :                 // 画面外のタイルはソートも描画もしない
     158            0 :                 if !inViewport(world.Components.GridElement.Get(entity), minX, maxX, minY, maxY) {
     159            0 :                         continue
     160              :                 }
     161            0 :                 entities[iSprite] = entity
     162            0 :                 iSprite++
     163              :         }
     164              : 
     165            0 :         slices.SortStableFunc(entities[:iSprite], func(a, b ecs.Entity) int {
     166            0 :                 return cmp.Compare(world.Components.SpriteRender.Get(a).Depth, world.Components.SpriteRender.Get(b).Depth)
     167            0 :         })
     168              : 
     169            0 :         for i := range iSprite {
     170            0 :                 entity := entities[i]
     171            0 :                 gridElement := world.Components.GridElement.Get(entity)
     172            0 : 
     173            0 :                 info, exists := tileRenderMap[*gridElement]
     174            0 :                 if !exists {
     175            0 :                         continue
     176              :                 }
     177              :                 // 記憶タイルの床は退色させて描く。今見えているタイルと区別して「記憶している」と
     178              :                 // 分かる見た目にする。フルカラーのまま暗くすると平坦な暗い部屋に見えるのを避ける
     179            0 :                 _, remembered := info.(TileRenderRemembered)
     180            0 : 
     181            0 :                 spriteRender := world.Components.SpriteRender.Get(entity)
     182            0 :                 pos := &gc.Position{Coord: consts.TileCenterToWorld(gridElement.Coord)}
     183            0 :                 if err := sys.drawImage(world, screen, spriteRender, pos, 0, camera, remembered); err != nil {
     184              :                         // エンティティ情報を追加してエラーを詳細化
     185            0 :                         var entityInfo string
     186            0 :                         if world.Components.Name.Has(entity) {
     187            0 :                                 name := world.Components.Name.Get(entity)
     188            0 :                                 entityInfo = fmt.Sprintf("Name: %s", name.Name)
     189            0 :                         }
     190            0 :                         return fmt.Errorf("entity %d at (%d,%d), SpriteSheet: '%s', SpriteKey: '%s', %s: %w",
     191            0 :                                 entity, gridElement.X, gridElement.Y, spriteRender.SpriteSheetName, spriteRender.SpriteKey, entityInfo, err)
     192              :                 }
     193              :         }
     194            0 :         return nil
     195              : }
     196              : 
     197              : // renderObjectLayer はタイル以外のオブジェクトレイヤーを描画する
     198              : func (sys *RenderSpriteSystem) renderObjectLayer(world w.World, screen *ebiten.Image, tileRenderMap map[gc.GridElement]TileRenderInfo, camera *gc.Camera) error {
     199            0 :         var entities []ecs.Entity
     200            0 :         minX, maxX, minY, maxY := viewportTileBounds(world, viewportCullMargin, camera)
     201            0 : 
     202              :         // タイル以外のスプライトを収集する。フィールド上のオブジェクトとMoversを含む。
     203            0 :         objectQuery := query.ActiveFilter2[gc.SpriteRender, gc.GridElement](world).Without(ecs.C[gc.Tile]()).Query()
     204            0 :         for objectQuery.Next() {
     205            0 :                 entity := objectQuery.Entity()
     206            0 :                 // 画面外は描画しない
     207            0 :                 if !inViewport(world.Components.GridElement.Get(entity), minX, maxX, minY, maxY) {
     208            0 :                         continue
     209              :                 }
     210            0 :                 entities = append(entities, entity)
     211              :         }
     212              : 
     213            0 :         slices.SortStableFunc(entities, func(a, b ecs.Entity) int {
     214            0 :                 return cmp.Compare(world.Components.SpriteRender.Get(a).Depth, world.Components.SpriteRender.Get(b).Depth)
     215            0 :         })
     216              : 
     217            0 :         for _, entity := range entities {
     218            0 :                 gridElement := world.Components.GridElement.Get(entity)
     219            0 : 
     220            0 :                 if _, ok := tileRenderMap[*gridElement].(TileRenderVisible); !ok {
     221            0 :                         continue
     222              :                 }
     223              : 
     224            0 :                 spriteRender := world.Components.SpriteRender.Get(entity)
     225            0 :                 pos := &gc.Position{Coord: consts.TileCenterToWorld(gridElement.Coord)}
     226            0 :                 if err := sys.drawImage(world, screen, spriteRender, pos, 0, camera, false); err != nil {
     227            0 :                         return err
     228            0 :                 }
     229              :         }
     230            0 :         return nil
     231              : }
     232              : 
     233              : // renderShadows は物体と壁の影を描画する
     234              : func (sys *RenderSpriteSystem) renderShadows(world w.World, screen *ebiten.Image, tileRenderMap map[gc.GridElement]TileRenderInfo, camera *gc.Camera) {
     235            0 :         minX, maxX, minY, maxY := viewportTileBounds(world, viewportCullMargin, camera)
     236            0 : 
     237              :         // 物体の影
     238            0 :         moverShadowQuery := query.ActiveFilter2[gc.SpriteRender, gc.GridElement](world).Query()
     239            0 :         for moverShadowQuery.Next() {
     240            0 :                 entity := moverShadowQuery.Entity()
     241            0 :                 // TurnBased または Prop を持つエンティティのみ
     242            0 :                 if !world.Components.TurnBased.Has(entity) && !world.Components.Prop.Has(entity) {
     243            0 :                         continue
     244              :                 }
     245              : 
     246            0 :                 spriteRender := world.Components.SpriteRender.Get(entity)
     247            0 : 
     248              :                 // 高さのあるものだけが影を落とす
     249            0 :                 if spriteRender.Depth <= gc.DepthNumRug {
     250            0 :                         continue
     251              :                 }
     252              : 
     253            0 :                 gridElement := world.Components.GridElement.Get(entity)
     254            0 : 
     255            0 :                 if !inViewport(gridElement, minX, maxX, minY, maxY) {
     256            0 :                         continue
     257              :                 }
     258            0 :                 if _, ok := tileRenderMap[*gridElement].(TileRenderVisible); !ok {
     259            0 :                         continue
     260              :                 }
     261              : 
     262              :                 // グリッド座標をタイル中心のピクセル座標に変換。X はスプライト幅ぶん左へずらす
     263            0 :                 center := consts.TileCenterToWorld(gridElement.Coord)
     264            0 :                 pixelX := float64(center.X) - 12
     265            0 :                 pixelY := float64(center.Y)
     266            0 : 
     267            0 :                 op := &ebiten.DrawImageOptions{}
     268            0 :                 op.GeoM.Translate(pixelX, pixelY)
     269            0 :                 setTranslate(world, op, camera)
     270            0 :                 if moverShadowImage != nil {
     271            0 :                         screen.DrawImage(moverShadowImage, op)
     272            0 :                 }
     273              :         }
     274              : 
     275              :         // 下タイルが床の場合のみ壁の影。
     276              :         // 下タイル参照用のマップは viewport 内(+margin)だけ構築する。大マップで全タイルを
     277              :         // 毎フレーム map 化するのを避ける
     278            0 :         tileMap := make(map[gc.GridElement]ecs.Entity)
     279            0 :         // 下タイル参照は床タイルのみが対象。gc.Tile で絞りキャラ/固定物を走査から除く
     280            0 :         tileMapQuery := query.ActiveFilter3[gc.GridElement, gc.SpriteRender, gc.Tile](world).Query()
     281            0 :         for tileMapQuery.Next() {
     282            0 :                 e := tileMapQuery.Entity()
     283            0 :                 ge := world.Components.GridElement.Get(e)
     284            0 :                 if !inViewport(ge, minX, maxX, minY, maxY) {
     285            0 :                         continue
     286              :                 }
     287            0 :                 tileMap[*ge] = e
     288              :         }
     289              : 
     290            0 :         wallShadowQuery := query.ActiveFilter4[gc.SpriteRender, gc.GridElement, gc.BlockView, gc.BlockPass](world).Query()
     291            0 :         for wallShadowQuery.Next() {
     292            0 :                 entity := wallShadowQuery.Entity()
     293            0 :                 grid := world.Components.GridElement.Get(entity)
     294            0 : 
     295            0 :                 if !inViewport(grid, minX, maxX, minY, maxY) {
     296            0 :                         continue
     297              :                 }
     298            0 :                 if _, ok := tileRenderMap[*grid].(TileRenderVisible); !ok {
     299            0 :                         continue
     300              :                 }
     301              : 
     302            0 :                 spriteRender := world.Components.SpriteRender.Get(entity)
     303            0 : 
     304              :                 // 高さのあるものだけが影を落とす
     305            0 :                 if spriteRender.Depth <= gc.DepthNumRug {
     306            0 :                         continue
     307              :                 }
     308              : 
     309              :                 // 下のタイルを検索
     310            0 :                 belowPos := gc.GridElement{Coord: consts.Coord[consts.Tile]{X: grid.X, Y: grid.Y + 1}}
     311            0 :                 belowTileEntity, foundBelow := tileMap[belowPos]
     312            0 : 
     313            0 :                 if !foundBelow {
     314            0 :                         continue
     315              :                 }
     316              : 
     317            0 :                 if !world.Components.SpriteRender.Has(belowTileEntity) {
     318            0 :                         continue // 下が床でなければ影を描画しない
     319              :                 }
     320            0 :                 belowSpriteRender := world.Components.SpriteRender.Get(belowTileEntity)
     321            0 :                 if belowSpriteRender.Depth != gc.DepthNumFloor {
     322            0 :                         continue // 下が床でなければ影を描画しない
     323              :                 }
     324              : 
     325              :                 // 下のタイルが壁でないことも確認(壁->床->壁の場合は影を描画しない)
     326            0 :                 if world.Components.BlockView.Has(belowTileEntity) && world.Components.BlockPass.Has(belowTileEntity) {
     327            0 :                         continue
     328              :                 }
     329              : 
     330            0 :                 op := &ebiten.DrawImageOptions{}
     331            0 :                 op.GeoM.Translate(float64(int(grid.X)*int(consts.TileSize)), float64(int(grid.Y)*int(consts.TileSize)+int(consts.TileSize)))
     332            0 :                 setTranslate(world, op, camera)
     333            0 :                 if wallShadowImage != nil {
     334            0 :                         screen.DrawImage(wallShadowImage, op)
     335            0 :                 }
     336              :         }
     337              : }
     338              : 
     339              : func (sys *RenderSpriteSystem) drawImage(world w.World, screen *ebiten.Image, spriteRender *gc.SpriteRender, pos *gc.Position, angle float64, camera *gc.Camera, desaturate bool) error {
     340              :         // Resourcesからスプライトシートを取得
     341            0 :         if world.Resources.SpriteSheets == nil {
     342            0 :                 return fmt.Errorf("sprite sheets are nil")
     343            0 :         }
     344            0 :         spriteSheet, exists := world.Resources.SpriteSheets[spriteRender.SpriteSheetName]
     345            0 :         if !exists {
     346            0 :                 return fmt.Errorf("sprite sheet '%s' not found", spriteRender.SpriteSheetName)
     347            0 :         }
     348              : 
     349            0 :         sprite, exists := spriteSheet.Sprites[spriteRender.SpriteKey]
     350            0 :         if !exists {
     351            0 :                 return fmt.Errorf("sprite key '%s' does not exist in sprite sheet '%s'", spriteRender.SpriteKey, spriteRender.SpriteSheetName)
     352            0 :         }
     353              : 
     354            0 :         op := &spriteRender.Options
     355            0 :         op.GeoM.Reset()                                                       // FIXME: Resetがないと非表示になる。なぜ?
     356            0 :         op.GeoM.Translate(float64(-sprite.Width/2), float64(-sprite.Width/2)) // 回転軸を画像の中心にする
     357            0 :         op.GeoM.Rotate(angle)
     358            0 :         op.GeoM.Translate(float64(pos.X), float64(pos.Y))
     359            0 :         setTranslate(world, op, camera)
     360            0 : 
     361            0 :         img := world.Resources.Sprites.Image(spriteRender)
     362            0 :         if img == nil {
     363            0 :                 return nil
     364            0 :         }
     365            0 :         if desaturate {
     366              :                 // 記憶タイルは彩度を落として退色させる。色行列で彩度を下げ明度を少し落とし、
     367              :                 // 「今見ている」タイルと区別する。減光は後段の暗闇オーバーレイが担う
     368            0 :                 var cm colorm.ColorM
     369            0 :                 cm.ChangeHSV(0, memorySaturation, memoryValue)
     370            0 :                 dop := &colorm.DrawImageOptions{GeoM: op.GeoM, Blend: op.Blend, Filter: op.Filter}
     371            0 :                 colorm.DrawImage(screen, img, cm, dop)
     372            0 :         } else {
     373            0 :                 screen.DrawImage(img, op)
     374            0 :         }
     375              : 
     376            0 :         if world.Resources.Config.ShowMapDebug {
     377              :                 // デバッグ用:オートタイルの添字を表示する。オートタイルの絵は名前の末尾に数の添字を持つ
     378            0 :                 if spriteRender.SpriteSheetName == "tile" {
     379            0 :                         var number string
     380            0 :                         if _, n, ok := strings.CutLast(spriteRender.SpriteKey, "_"); ok {
     381            0 :                                 if _, err := strconv.Atoi(n); err == nil {
     382            0 :                                         number = n
     383            0 :                                 }
     384              :                         }
     385              : 
     386            0 :                         if number != "" {
     387              :                                 // カメラ変換を考慮したテキスト位置を計算
     388            0 :                                 textOp := &ebiten.DrawImageOptions{}
     389            0 :                                 textOp.GeoM.Translate(float64(pos.X-8), float64(pos.Y-8)) // タイルの左上付近に表示
     390            0 :                                 setTranslate(world, textOp, camera)
     391            0 : 
     392              :                                 // テキスト表示位置を逆変換で求める
     393            0 :                                 screenX, screenY := textOp.GeoM.Apply(0, 0)
     394            0 :                                 ebitenutil.DebugPrintAt(screen, number, int(screenX), int(screenY))
     395            0 :                         }
     396              :                 }
     397              :         }
     398              : 
     399            0 :         return nil
     400              : }
     401              : 
     402              : // renderDarkness は per-tile の暗さをタイル整列でそのまま描く暗闇オーバーレイ。
     403              : // vision が壁遮蔽込みで計算した per-tile の暗さを1タイル1テクセルの小画像へ詰め、
     404              : // FilterNearest でタイルサイズへ拡大する。補間しないのでタイル単位の一様な明るさになり、
     405              : // ドット絵と質感が揃う。暗さは連続値なので段差ジャンプ(チカチカ)は出ない。
     406              : func (sys *RenderSpriteSystem) renderDarkness(world w.World, screen *ebiten.Image, tileRenderMap map[gc.GridElement]TileRenderInfo, camera *gc.Camera) {
     407            0 :         var cameraX, cameraY float64
     408            0 :         cameraScale := 1.0
     409            0 :         if camera != nil {
     410            0 :                 cameraX = float64(camera.Pos.X)
     411            0 :                 cameraY = float64(camera.Pos.Y)
     412            0 :                 cameraScale = camera.Scale
     413            0 :         }
     414              : 
     415              :         // 床レイヤのカリング余白に合わせてタイルを拾う。描き漏れを防ぐ
     416            0 :         minX, maxX, minY, maxY := viewportTileBounds(world, viewportCullMargin, camera)
     417            0 :         mw := maxX - minX + 1
     418            0 :         mh := maxY - minY + 1
     419            0 :         if mw <= 0 || mh <= 0 {
     420            0 :                 return
     421            0 :         }
     422            0 :         sys.ensureDarknessMap(mw, mh)
     423            0 : 
     424              :         // 1タイル1テクセル。黒 rgb=0、アルファに暗さを連続値で詰める。バッファは使い回す。
     425              :         // rgb は常に0のままで、各テクセルのアルファは毎フレーム全て上書きするのでクリア不要。
     426              :         // 3状態を tileRenderAt で網羅する。未探索は完全な闇、可視/記憶はそれぞれの暗さ
     427            0 :         pix := sys.darknessPix
     428            0 :         for j := range mh {
     429            0 :                 for i := range mw {
     430            0 :                         grid := gc.GridElement{Coord: consts.Coord[consts.Tile]{X: consts.Tile(minX + i), Y: consts.Tile(minY + j)}}
     431            0 :                         var darkness float64
     432            0 :                         switch v := tileRenderAt(tileRenderMap, grid).(type) {
     433              :                         case TileRenderVisible:
     434            0 :                                 darkness = float64(v.Darkness)
     435              :                         case TileRenderRemembered:
     436            0 :                                 darkness = float64(v.Darkness)
     437              :                         case TileRenderUnexplored:
     438            0 :                                 darkness = 1.0
     439              :                         default:
     440            0 :                                 panic(fmt.Sprintf("unknown TileRenderInfo: %T", v))
     441              :                         }
     442            0 :                         pix[(j*mw+i)*4+3] = byte(max(0.0, min(1.0, darkness)) * 255)
     443              :                 }
     444              :         }
     445            0 :         sys.darknessMap.WritePixels(pix)
     446            0 : 
     447              :         // タイルグリッドへ合わせて拡大する。texel(0,0) の左上をタイル(minX,minY)の左上へ置く。
     448              :         // FilterNearest なので各テクセルは1タイルの一様な四角として描かれる
     449            0 :         ts := float64(consts.TileSize)
     450            0 :         offsetX := (float64(minX)*ts-cameraX)*cameraScale + float64(world.Resources.ScreenDimensions.Width)/2
     451            0 :         offsetY := (float64(minY)*ts-cameraY)*cameraScale + float64(world.Resources.ScreenDimensions.Height)/2
     452            0 : 
     453            0 :         op := &ebiten.DrawImageOptions{}
     454            0 :         op.GeoM.Scale(ts*cameraScale, ts*cameraScale)
     455            0 :         op.GeoM.Translate(offsetX, offsetY)
     456            0 :         op.Filter = ebiten.FilterNearest
     457            0 :         screen.DrawImage(sys.darknessMap, op)
     458              : }
     459              : 
     460              : // ensureDarknessMap は per-tile 暗さマップの小画像を用意する。サイズが変わったら作り直す。
     461              : func (sys *RenderSpriteSystem) ensureDarknessMap(width, height int) {
     462            0 :         if sys.darknessMap != nil {
     463            0 :                 b := sys.darknessMap.Bounds()
     464            0 :                 if b.Dx() == width && b.Dy() == height {
     465            0 :                         return
     466            0 :                 }
     467            0 :                 sys.darknessMap.Deallocate()
     468              :         }
     469            0 :         sys.darknessMap = ebiten.NewImage(width, height)
     470            0 :         sys.darknessPix = make([]byte, width*height*4)
     471              : }
        

Generated by: LCOV version 2.0-1