1 files changed, 243 insertions, 26 deletions

@@ -1,4 +1,5 @@
 #include <SDL.h>
+#include <SDL_image.h>
 #include <stdexcept>
 #include <memory>
 #include <vector>
@@ -19,6 +20,14 @@ public:
   }
 };
 
+class img_error : public std::logic_error {
+public:
+
+  img_error() : std::logic_error(IMG_GetError())
+  {
+  }
+};
+
 class window_deleter {
 public:
 
@@ -41,6 +50,17 @@ public:
 
 using renderer_ptr = std::unique_ptr<SDL_Renderer, renderer_deleter>;
 
+class surface_deleter {
+public:
+
+  void operator()(SDL_Surface* ptr)
+  {
+    SDL_FreeSurface(ptr);
+  }
+};
+
+using surface_ptr = std::unique_ptr<SDL_Surface, surface_deleter>;
+
 class texture_deleter {
 public:
 
@@ -59,6 +79,13 @@ enum class Tile {
   Lamp
 };
 
+enum class Source {
+  None,
+  Dust,
+  Lamp,
+  Player
+};
+
 enum class LoseState {
   None,
   PoppingLamps,
@@ -100,6 +127,9 @@ struct MapData {
   bool wasLit = false;
   double visibility = 0.0;
   size_t dustLife = 0;
+  Source lightType = Source::None;
+  int lightRadius = 0;
+  std::set<coord> litTiles;
 };
 
 class Game {
@@ -142,6 +172,83 @@ void render(
   const Game& game,
   bool drawDark = true)
 {
+  texture_ptr origFade;
+  {
+    surface_ptr pfs(IMG_Load("../res/lighting.png"));
+    if (!pfs)
+    {
+      throw img_error();
+    }
+
+    origFade = texture_ptr(SDL_CreateTextureFromSurface(ren, pfs.get()));
+  }
+
+  SDL_SetTextureBlendMode(origFade.get(), SDL_BLENDMODE_BLEND);
+
+  texture_ptr playerFade(
+    SDL_CreateTexture(
+      ren,
+      SDL_PIXELFORMAT_RGBA4444,
+      SDL_TEXTUREACCESS_TARGET,
+      144,
+      144));
+
+  if (!playerFade)
+  {
+    throw sdl_error();
+  }
+
+  SDL_SetRenderTarget(ren, playerFade.get());
+  SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
+  SDL_RenderClear(ren);
+  SDL_RenderCopy(ren, origFade.get(), nullptr, nullptr);
+
+  texture_ptr lampFade(
+    SDL_CreateTexture(
+      ren,
+      SDL_PIXELFORMAT_RGBA4444,
+      SDL_TEXTUREACCESS_TARGET,
+      144,
+      144));
+
+  if (!lampFade)
+  {
+    throw sdl_error();
+  }
+
+  SDL_SetRenderTarget(ren, lampFade.get());
+
+  SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
+  SDL_RenderClear(ren);
+  SDL_RenderCopy(ren, origFade.get(), nullptr, nullptr);
+
+  SDL_SetRenderDrawBlendMode(ren, SDL_BLENDMODE_MOD);
+  SDL_SetRenderDrawColor(ren, 255, 204, 58, 255);
+  SDL_RenderFillRect(ren, nullptr);
+
+  texture_ptr dustFade(
+    SDL_CreateTexture(
+      ren,
+      SDL_PIXELFORMAT_RGBA4444,
+      SDL_TEXTUREACCESS_TARGET,
+      144,
+      144));
+
+  if (!dustFade)
+  {
+    throw sdl_error();
+  }
+
+  SDL_SetRenderTarget(ren, dustFade.get());
+
+  SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
+  SDL_RenderClear(ren);
+  SDL_RenderCopy(ren, origFade.get(), nullptr, nullptr);
+
+  SDL_SetRenderDrawBlendMode(ren, SDL_BLENDMODE_MOD);
+  SDL_SetRenderDrawColor(ren, 255, 150, 255, 255);
+  SDL_RenderFillRect(ren, nullptr);
+
   texture_ptr canvas(
     SDL_CreateTexture(
       ren,
@@ -156,7 +263,7 @@ void render(
   }
 
   SDL_SetRenderTarget(ren, canvas.get());
-
+  SDL_SetRenderDrawBlendMode(ren, SDL_BLENDMODE_NONE);
   SDL_SetRenderDrawColor(ren, rand() % 255, rand() % 255, rand() % 255, 255);
   SDL_RenderClear(ren);
 
@@ -169,38 +276,40 @@ void render(
       if ((game.player_x == x && game.player_y == y) && game.renderPlayer)
       {
         SDL_SetRenderDrawColor(ren, 255, 255, 0, 255);
-      } else if (!game.map.at(x,y).lit)
+        /*} else if (!game.map.at(x,y).lit)
       {
         if (drawDark)
         {
           SDL_SetRenderDrawColor(ren, 40, 40, 40, 255);
         } else {
           draw = false;
-        }
+        }*/
       } else {
+        int alpha = 255;
+
         switch (game.map.at(x,y).tile)
         {
           case Tile::Floor:
           {
-            SDL_SetRenderDrawColor(ren, 210, 210, 210, 255);
+            SDL_SetRenderDrawColor(ren, 210, 210, 210, alpha);
             break;
           }
 
           case Tile::Wall:
           {
-            SDL_SetRenderDrawColor(ren, 100, 100, 100, 255);
+            SDL_SetRenderDrawColor(ren, 100, 100, 100, alpha);
             break;
           }
 
           case Tile::Dust:
           {
-            SDL_SetRenderDrawColor(ren, 128, 40, 255, 255);
+            SDL_SetRenderDrawColor(ren, 128, 40, 255, alpha);
             break;
           }
 
           case Tile::Lamp:
           {
-            SDL_SetRenderDrawColor(ren, 0, 255, 255, 255);
+            SDL_SetRenderDrawColor(ren, 0, 255, 255, alpha);
             break;
           }
         }
@@ -214,15 +323,97 @@ void render(
           TILE_WIDTH,
           TILE_HEIGHT};
 
-        SDL_RenderFillRect(ren, &rect);
+        //SDL_RenderFillRect(ren, &rect);
 
-        int alpha = (1.0 - game.map.at(x,y).visibility) * 255;
-        SDL_SetRenderDrawColor(ren, 40, 40, 40, alpha);
+        //int alpha = (1.0 - game.map.at(x,y).visibility) * 255;
+        //SDL_SetRenderDrawColor(ren, 40, 40, 40, 255);
         SDL_RenderFillRect(ren, &rect);
       }
     }
   }
 
+  texture_ptr mask(
+    SDL_CreateTexture(
+      ren,
+      SDL_PIXELFORMAT_RGBA8888,
+      SDL_TEXTUREACCESS_TARGET,
+      TILE_WIDTH * game.map.getWidth(),
+      TILE_HEIGHT * game.map.getHeight()));
+
+  if (!mask)
+  {
+    throw sdl_error();
+  }
+
+  SDL_SetRenderTarget(ren, mask.get());
+  SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
+  SDL_RenderClear(ren);
+
+  for (int y = game.map.getTop(); y < game.map.getBottom(); y++)
+  {
+    for (int x = game.map.getLeft(); x < game.map.getRight(); x++)
+    {
+      if (game.map.at(x,y).lightType != Source::None)
+      {
+        texture_ptr sourceMask(
+          SDL_CreateTexture(
+            ren,
+            SDL_PIXELFORMAT_RGBA8888,
+            SDL_TEXTUREACCESS_TARGET,
+            TILE_WIDTH * game.map.getWidth(),
+            TILE_HEIGHT * game.map.getHeight()));
+
+        if (!sourceMask)
+        {
+          throw sdl_error();
+        }
+
+        SDL_SetRenderTarget(ren, sourceMask.get());
+        SDL_SetRenderDrawColor(ren, 0, 0, 0, 255);
+        SDL_RenderClear(ren);
+
+        SDL_SetRenderDrawColor(ren, 255, 255, 255, 255);
+
+        for (const coord& xy : game.map.at(x,y).litTiles)
+        {
+          SDL_Rect rect {
+            game.map.getTrueX(std::get<0>(xy)) * TILE_WIDTH,
+            game.map.getTrueY(std::get<1>(xy)) * TILE_HEIGHT,
+            TILE_WIDTH,
+            TILE_HEIGHT};
+
+          SDL_RenderFillRect(ren, &rect);
+        }
+
+        SDL_Rect fadeRect {
+          (game.map.getTrueX(x) - game.map.at(x,y).lightRadius) * TILE_WIDTH,
+          (game.map.getTrueY(y) - game.map.at(x,y).lightRadius) * TILE_HEIGHT,
+          (game.map.at(x,y).lightRadius * 2 + 1) * TILE_WIDTH,
+          (game.map.at(x,y).lightRadius * 2 + 1) * TILE_HEIGHT};
+
+        if (game.map.at(x,y).lightType == Source::Lamp)
+        {
+          SDL_SetTextureBlendMode(lampFade.get(), SDL_BLENDMODE_MOD);
+          SDL_RenderCopy(ren, lampFade.get(), nullptr, &fadeRect);
+        } else if (game.map.at(x,y).lightType == Source::Player) {
+          SDL_SetTextureBlendMode(playerFade.get(), SDL_BLENDMODE_MOD);
+          SDL_RenderCopy(ren, playerFade.get(), nullptr, &fadeRect);
+        } else if (game.map.at(x,y).lightType == Source::Dust) {
+          SDL_SetTextureBlendMode(dustFade.get(), SDL_BLENDMODE_MOD);
+          SDL_RenderCopy(ren, dustFade.get(), nullptr, &fadeRect);
+        }
+
+        SDL_SetRenderTarget(ren, mask.get());
+        SDL_SetTextureBlendMode(sourceMask.get(), SDL_BLENDMODE_ADD);
+        SDL_RenderCopy(ren, sourceMask.get(), nullptr, nullptr);
+      }
+    }
+  }
+
+  SDL_SetRenderTarget(ren, canvas.get());
+  SDL_SetTextureBlendMode(mask.get(), SDL_BLENDMODE_MOD);
+  SDL_RenderCopy(ren, mask.get(), nullptr, nullptr);
+
   SDL_SetRenderTarget(ren, nullptr);
 
   if (!game.zooming)
@@ -346,6 +537,7 @@ void recalculateLighting(Game& game, fov_settings_type* fov)
     md.wasLit = md.lit;
     md.lit = false;
     md.visibility = 0.0;
+    md.litTiles.clear();
   }
 
   fov_settings_set_opacity_test_function(
@@ -363,7 +555,8 @@ void recalculateLighting(Game& game, fov_settings_type* fov)
 
       if (game.map.inBounds(x, y))
       {
-        double lightRadius = static_cast<double>(*static_cast<int*>(source));
+        MapData& sourceData = *static_cast<MapData*>(source);
+        double lightRadius = static_cast<double>(sourceData.lightRadius);
 
         if (!game.map.at(x,y).lit)
         {
@@ -372,13 +565,21 @@ void recalculateLighting(Game& game, fov_settings_type* fov)
 
         game.map.at(x,y).lit = true;
 
-        game.map.at(x,y).visibility = std::max(
+        /*game.map.at(x,y).visibility = std::max(
           game.map.at(x,y).visibility,
           std::pow(
             std::max(
               0.0,
               1.0 - std::sqrt(dx * dx + dy * dy) / lightRadius),
-            1.0/3.0));
+            1.0/3.0));*/
+
+        sourceData.litTiles.emplace(x,y);
+
+        //Source ls = *static_cast<Source*>(source);
+        //if (static_cast<size_t>(ls) > static_cast<size_t>(m.lightSource[x+VIEW_WIDTH*y]))
+        {
+          //m.lightSource[x+VIEW_WIDTH*y] = ls;
+        }
       }
     });
 
@@ -386,25 +587,35 @@ void recalculateLighting(Game& game, fov_settings_type* fov)
   {
     for (int x = game.map.getLeft(); x < game.map.getRight(); x++)
     {
-      if ((game.player_x == x && game.player_y == y && game.renderPlayer) ||
-          game.map.at(x,y).tile == Tile::Dust ||
-          game.map.at(x,y).tile == Tile::Lamp)
+      Source ls = Source::None;
+      int lightRadius;
+
+      if (game.renderPlayer && game.player_x == x && game.player_y == y)
+      {
+        ls = Source::Player;
+        lightRadius = RADIUS;
+      } else if (game.map.at(x,y).tile == Tile::Dust)
       {
-        int lightRadius;
+        ls = Source::Dust;
+        lightRadius = 2;
+      } else if (game.map.at(x,y).tile == Tile::Lamp)
+      {
+        ls = Source::Lamp;
+        lightRadius = RADIUS;
+      }
 
-        if ((game.player_x == x && game.player_y == y && game.renderPlayer) ||
-             game.map.at(x,y).tile == Tile::Lamp)
-        {
-          lightRadius = RADIUS;
-        } else if (game.map.at(x,y).tile == Tile::Dust)
-        {
-          lightRadius = 2;
-        }
+      game.map.at(x,y).lightType = ls;
+      //game.map.at(x,y).litTiles.clear();
+
+      if (ls != Source::None)
+      {
+        game.map.at(x,y).lightRadius = lightRadius;
+        game.map.at(x,y).litTiles.emplace(x,y);
 
         fov_circle(
           fov,
           static_cast<void*>(&game),
-          static_cast<void*>(&lightRadius),
+          static_cast<void*>(&game.map.at(x,y)),
           x,
           y,
           lightRadius);
@@ -611,6 +822,11 @@ int main(int, char**)
         throw sdl_error();
   }
 
+  if (IMG_Init(IMG_INIT_PNG) != IMG_INIT_PNG)
+  {
+    throw img_error();
+  }
+
   try
   {
     window_ptr win(
@@ -916,6 +1132,7 @@ int main(int, char**)
     std::cout << "SDL error (" << ex.what() << ")" << std::endl;
   }
 
+  IMG_Quit();
   SDL_Quit();
 
   return 0;