Light sources are now visible in all layers

Author: luiscastilho

docs/TODO.md

@@ -42,9 +42,9 @@
 - [X] Fix low FPS when panning due to shadows being recalculated
 - [X] Make UI more intuitive (and pretty)
 - [X] Conditions, light sources, etc, applied to a token should remain highlighted in the right click menu
-- [ ] Scenes saved and later loaded should work on any screen resolution
+- [X] Scenes saved and later loaded should work on any screen resolution
+- [X] Light sources should be visible in all layers
 - [ ] Fix token images looking pixelated if zoom in is used
-- [ ] Light sources should be visible in all layers
 - [ ] Set maximum zoom and pan
 - [ ] Keep tokens inside grid when moving - larger tokens being moved to grid borders
 - [ ] Keep right click menu inside canvas - right click in tokens near the grid borders

dungeoneering/dungeoneering.pde

@@ -63,12 +63,12 @@ void setup() {
 
   initiative = new Initiative(initiativeCanvas);
 
-  playersLayer = new Layer(canvas, grid, obstacles, initiative, "Players Layer", Layers.players);
-  dmLayer = new Layer(canvas, grid, obstacles, initiative, "DM Layer", Layers.dm);
-  layerShown = Layers.players;
-
   resources = new Resources(canvas, grid);
 
+  playersLayer = new Layer(canvas, grid, obstacles, resources, initiative, "Players Layer", Layers.players);
+  dmLayer = new Layer(canvas, grid, obstacles, resources, initiative, "DM Layer", Layers.dm);
+  layerShown = Layers.players;
+
   userInterface = new UserInterface(canvas, cp5, map, grid, obstacles, playersLayer, dmLayer, resources, initiative);
 
   backgroundColor = color(0);
@@ -108,19 +108,38 @@ void draw() {
   switch ( layerShown ) {
     case players:
 
-      if ( obstacles.getRecalculateShadows() )
-        playersLayer.recalculateShadows();
+      if ( obstacles.getRecalculateShadows() ) {
+        // Gather light sources from all layers
+        dmLayer.recalculateShadows(ShadowTypes.lightSources);
+        playersLayer.recalculateShadows(ShadowTypes.lightSources);
+        // Gather lines of sight of the layer being shown, to be used as a mask to hide/reveal light sources
+        playersLayer.recalculateShadows(ShadowTypes.linesOfSight);
+        // Gather sight types of the layer being shown
+        playersLayer.recalculateShadows(ShadowTypes.sightTypes);
+        // Compose final shadows with all of the above
+        obstacles.blendShadows();
+      }
 
+      // Draw layer not being shown first
       dmLayer.draw(layerShown);
+      // Draw shadows to hide/reveal areas and tokens depending on the obstacles present
       obstacles.draw();
+      // Draw layer being shown
       playersLayer.draw(layerShown);
 
       break;
     case dm:
 
-      if ( obstacles.getRecalculateShadows() )
-        dmLayer.recalculateShadows();
+      if ( obstacles.getRecalculateShadows() ) {
+        // Same as above, with opposite layer
+        playersLayer.recalculateShadows(ShadowTypes.lightSources);
+        dmLayer.recalculateShadows(ShadowTypes.lightSources);
+        dmLayer.recalculateShadows(ShadowTypes.linesOfSight);
+        dmLayer.recalculateShadows(ShadowTypes.sightTypes);
+        obstacles.blendShadows();
+      }
 
+      // Same as above, with opposite layer
       playersLayer.draw(layerShown);
       obstacles.draw();
       dmLayer.draw(layerShown);
@@ -130,11 +149,22 @@ void draw() {
     default:
 
       if ( obstacles.getRecalculateShadows() ) {
-        playersLayer.recalculateShadows();
-        dmLayer.recalculateShadows();
+        // Gather light sources from all layers
+        playersLayer.recalculateShadows(ShadowTypes.lightSources);
+        dmLayer.recalculateShadows(ShadowTypes.lightSources);
+        // Gather lines of sight from all layers, to be used as a mask to reveal/hide light sources
+        playersLayer.recalculateShadows(ShadowTypes.linesOfSight);
+        dmLayer.recalculateShadows(ShadowTypes.linesOfSight);
+        // Gather sight types from all layers
+        playersLayer.recalculateShadows(ShadowTypes.sightTypes);
+        dmLayer.recalculateShadows(ShadowTypes.sightTypes);
+        // Compose final shadows with all of the above
+        obstacles.blendShadows();
       }
 
+      // Draw shadows first, to hide/reveal areas depending on the obstacles present
       obstacles.draw();
+      // Then draw all layers
       playersLayer.draw(layerShown);
       dmLayer.draw(layerShown);
 

dungeoneering/enums.pde

@@ -20,6 +20,14 @@ enum Layers {
 
 };
 
+enum ShadowTypes {
+
+  lightSources,
+  linesOfSight,
+  sightTypes;
+
+};
+
 enum Illumination {
 
   brightLight(255),

dungeoneering/layer.pde

@@ -8,6 +8,8 @@ class Layer {
 
   Obstacles obstacles;
 
+  Resources resources;
+
   Initiative initiative;
 
   ArrayList<Token> tokens;
@@ -16,14 +18,16 @@ class Layer {
 
   Layers thisLayer;
 
-  Layer(PGraphics _canvas, Grid _grid, Obstacles _obstacles, Initiative _initiative, String _name, Layers _thisLayer) {
+  Layer(PGraphics _canvas, Grid _grid, Obstacles _obstacles, Resources _resources, Initiative _initiative, String _name, Layers _thisLayer) {
 
     canvas = _canvas;
 
     grid = _grid;
 
     obstacles = _obstacles;
 
+    resources = _resources;
+
     initiative = _initiative;
 
     tokens = new ArrayList<Token>();
@@ -64,13 +68,12 @@ class Layer {
 
   }
 
-  void recalculateShadows() {
+  void recalculateShadows(ShadowTypes shadowsToRecalculate) {
 
     logger.debug(name + ": recalculating shadows");
 
     for ( Token token: tokens )
-      token.recalculateShadows();
-    obstacles.blurShadows();
+      token.recalculateShadows(shadowsToRecalculate);
 
   }
 
@@ -85,7 +88,9 @@ class Layer {
       currentCell = grid.getCellAt(0, 0);
 
     Token token = new Token(canvas, grid, obstacles);
-    token.setup(tokenBaseName, tokenImageFile.getAbsolutePath(), grid.getCellWidth(), grid.getCellHeight(), resources.getSize("Medium"));
+    Light lineOfSightTemplate = resources.getSightType("Line of Sight");
+    Light lineOfSight = new Light(lineOfSightTemplate.getName(), lineOfSightTemplate.getBrightLightRadius(), lineOfSightTemplate.getDimLightRadius());
+    token.setup(tokenBaseName, tokenImageFile.getAbsolutePath(), grid.getCellWidth(), grid.getCellHeight(), resources.getSize("Medium"), lineOfSight);
     token.setCell(currentCell);
     token.setBeingMoved(true);
     tokens.add(token);

dungeoneering/obstacles.pde

@@ -13,8 +13,16 @@ class Obstacles {
 
   Illumination illumination;
 
+  // Accumulates all lights and shadows, serves as a mask to be applied over the entire scene
   PGraphics allShadows;
-  PGraphics currentShadows;
+  // Temporary canvas, used to draw shadows before they are blended into other canvases
+  PGraphics temporaryShadows;
+  // Accumulates light sources
+  PGraphics lightSources;
+  // Accumulates lines of sight, used as a mask to be applied over the light sources canvas
+  PGraphics linesOfSight;
+  // Accumulates sight types
+  PGraphics sightTypes;
 
   float currentPanX, currentPanY;
   float currentScale;
@@ -40,16 +48,34 @@ class Obstacles {
     illumination = Illumination.brightLight;
 
     allShadows = createGraphics(canvas.width, canvas.height, P2D);
-    allShadows.smooth();
+    allShadows.noSmooth();
     allShadows.beginDraw();
     allShadows.background(illumination.getColor());
     allShadows.endDraw();
 
-    currentShadows = createGraphics(canvas.width, canvas.height, P2D);
-    currentShadows.smooth();
-    currentShadows.beginDraw();
-    currentShadows.background(illumination.getColor());
-    currentShadows.endDraw();
+    temporaryShadows = createGraphics(canvas.width, canvas.height, P2D);
+    temporaryShadows.noSmooth();
+    temporaryShadows.beginDraw();
+    temporaryShadows.background(illumination.getColor());
+    temporaryShadows.endDraw();
+
+    lightSources = createGraphics(canvas.width, canvas.height, P2D);
+    lightSources.noSmooth();
+    lightSources.beginDraw();
+    lightSources.background(0);
+    lightSources.endDraw();
+
+    linesOfSight = createGraphics(canvas.width, canvas.height, P2D);
+    linesOfSight.noSmooth();
+    linesOfSight.beginDraw();
+    linesOfSight.background(0);
+    linesOfSight.endDraw();
+
+    sightTypes = createGraphics(canvas.width, canvas.height, P2D);
+    sightTypes.noSmooth();
+    sightTypes.beginDraw();
+    sightTypes.background(0);
+    sightTypes.endDraw();
 
     currentPanX = 0;
     currentPanY = 0;
@@ -64,7 +90,9 @@ class Obstacles {
     if (canvas != null && allShadows != null)
       try {
         canvas.mask(allShadows);
-      } catch(Exception e) {}
+      } catch(Exception e) {
+        logger.error("Obstacles: Error applying shadows mask");
+      }
 
     if ( drawObstacles ) {
 
@@ -106,12 +134,73 @@ class Obstacles {
 
   }
 
+  void blendLightSources() {
+
+    lightSources.beginDraw();
+    lightSources.blendMode(LIGHTEST);
+    lightSources.image(temporaryShadows, 0, 0);
+    lightSources.blendMode(BLEND);
+    lightSources.endDraw();
+
+  }
+
+  void blendSightTypes() {
+
+    sightTypes.beginDraw();
+    sightTypes.blendMode(LIGHTEST);
+    sightTypes.image(temporaryShadows, 0, 0);
+    sightTypes.blendMode(BLEND);
+    sightTypes.endDraw();
+
+  }
+
+  void blendLinesOfSight() {
+
+    linesOfSight.beginDraw();
+    linesOfSight.blendMode(LIGHTEST);
+    linesOfSight.image(temporaryShadows, 0, 0);
+    linesOfSight.blendMode(BLEND);
+    linesOfSight.endDraw();
+
+  }
+
   void blendShadows() {
 
-    allShadows.beginDraw();
-    allShadows.blendMode(LIGHTEST);
-    allShadows.image(currentShadows, 0, 0);
-    allShadows.endDraw();
+    if ( illumination == Illumination.brightLight )
+      return;
+
+    lightSources.beginDraw();
+    lightSources.mask(linesOfSight);
+    lightSources.endDraw();
+
+    switch ( illumination ) {
+      case darkness:
+
+        allShadows.beginDraw();
+        allShadows.image(lightSources, 0, 0);
+        allShadows.blendMode(LIGHTEST);
+        allShadows.image(sightTypes, 0, 0);
+        allShadows.blendMode(BLEND);
+        allShadows.endDraw();
+
+        break;
+      case dimLight:
+
+        allShadows.beginDraw();
+        allShadows.image(lightSources, 0, 0);
+        allShadows.blendMode(LIGHTEST);
+        allShadows.noStroke();
+        allShadows.fill(illumination.getColor());
+        allShadows.rect(0, 0, allShadows.width, allShadows.height);
+        allShadows.blendMode(BLEND);
+        allShadows.endDraw();
+
+        break;
+      default:
+        break;
+    }
+
+    blurShadows();
 
   }
 
@@ -129,6 +218,26 @@ class Obstacles {
     allShadows.background(illumination.getColor());
     allShadows.endDraw();
 
+    temporaryShadows.beginDraw();
+    temporaryShadows.background(0);
+    temporaryShadows.endDraw();
+
+    lightSources.beginDraw();
+    lightSources.background(0);
+    lightSources.endDraw();
+
+    linesOfSight.beginDraw();
+    linesOfSight.background(0);
+    linesOfSight.endDraw();
+
+    sightTypes.beginDraw();
+    sightTypes.background(0);
+    sightTypes.endDraw();
+
+    // No need to recalculate shadows if environment lighting is bright light
+    if ( illumination == Illumination.brightLight )
+      recalculateShadows = false;
+
   }
 
   void clear() {
@@ -169,12 +278,8 @@ class Obstacles {
     return doorWidth;
   }
 
-  PGraphics getCurrentShadowsCanvas() {
-    return currentShadows;
-  }
-
-  PGraphics getAllShadowsCanvas() {
-    return allShadows;
+  PGraphics getTemporaryShadowsCanvas() {
+    return temporaryShadows;
   }
 
   void setCurrentPanX(float _currentPanX) {
@@ -209,7 +314,7 @@ class Obstacles {
 
     recalculateShadows = _recalculateShadows;
 
-    if ( _recalculateShadows )
+    if ( recalculateShadows )
       logger.debug("Obstacles: recalculating shadows");
 
   }

dungeoneering/resources.pde

@@ -69,7 +69,7 @@ class Resources {
     commonLightSources.put("Hooded Lantern", createLight("Hooded Lantern", 30, 60));
     commonLightSources.put("Lamp", createLight("Lamp", 15, 45));
     commonLightSources.put("Torch", createLight("Torch", 20, 40));
-    commonLightSources.put("Daylight", createLight("Daylight", 150, 0));
+    commonLightSources.put("Daylight", createLight("Daylight", 1000, 0));
 
   }
 
@@ -85,6 +85,7 @@ class Resources {
 
   void setSightTypes() {
 
+    sightTypes.put("Line of Sight", createLight("Line of Sight", 1000, 0));
     sightTypes.put("Blindsight 30'", createLight("Blindsight 30'", 30, 0));
     sightTypes.put("Blindsight 60'", createLight("Blindsight 60'", 60, 0));
     sightTypes.put("Blindsight 120'", createLight("Blindsight 120'", 120, 0));