add SMODS.ScreenShader (#1174)

Author: real-niacat

lovely/screen_shader_stack.toml

@@ -0,0 +1,74 @@
+[manifest]
+version = "1.0.0"
+dump_lua = true
+priority = -5
+
+# i think prio 0 is correct. idk if this patch builds off of any other patches
+
+[[patches]]
+[patches.pattern]
+target = "game.lua"
+pattern = '''
+if G.AA_CANVAS then 
+    love.graphics.push()
+        love.graphics.scale(1/G.CANV_SCALE)
+        love.graphics.draw(G.AA_CANVAS, 0, 0)
+    love.graphics.pop()
+end
+'''
+position = "before"
+payload = '''
+local last_canvas = self.CANVAS
+G.SHADER_CANVAS_A = G.SHADER_CANVAS_A or SMODS.create_canvas()
+G.SHADER_CANVAS_B = G.SHADER_CANVAS_B or SMODS.create_canvas()
+for index, key in ipairs(SMODS.ScreenShader.obj_buffer) do
+    local shader = SMODS.ScreenShaders[key]
+	if (shader.should_apply and shader:should_apply()) or (not shader.should_apply) then
+        --hypothetically less table accesses
+        local shader_object = G.SHADERS[shader.shader]
+		assert(shader_object, "Shader " .. shader.key .. " not found in G.SHADERS")
+
+        -- effectively swaps between A and B
+        local current_canvas = (last_canvas == G.SHADER_CANVAS_A) and G.SHADER_CANVAS_B or G.SHADER_CANVAS_A
+
+        if shader.send_vars then
+            local vars = shader:send_vars()
+            for k,v in pairs(vars) do
+                shader_object:send(k, v)
+            end
+
+        end
+		
+		love.graphics.setCanvas(current_canvas)
+		love.graphics.setShader(shader_object)
+		love.graphics.draw(last_canvas, 0, 0)
+
+        last_canvas = current_canvas
+	end
+end
+-- I don't like having this out here but id rather not run it when i don't have to
+-- also less setcanvas and setshader means it should run a smidge faster
+love.graphics.setCanvas()
+love.graphics.setShader()
+if last_canvas then
+    love.graphics.draw(last_canvas, 0, 0)
+    -- Draw everything we just did to the main canvas (what the player actually sees)
+end
+'''
+match_indent = true
+
+
+
+[[patches]]
+[patches.pattern]
+target = "main.lua"
+pattern = '''
+G.CANVAS = love.graphics.newCanvas(w*G.CANV_SCALE, h*G.CANV_SCALE, {type = '2d', readable = true})
+G.CANVAS:setFilter('linear', 'linear')
+'''
+position = "after"
+payload = '''
+G.SHADER_CANVAS_A = SMODS.create_canvas()
+G.SHADER_CANVAS_B = SMODS.create_canvas()
+'''
+match_indent = true

lsp_def/classes/screenshader.lua

@@ -0,0 +1,33 @@
+---@meta
+
+---@class SMODS.ScreenShader: SMODS.GameObject
+---@field obj_table? table<string, SMODS.ScreenShader|table> Table of objects registered to this class. 
+---@field super? SMODS.GameObject|table Parent class. 
+---@field key string Unique string to reference this object.
+---@field shader? string Key of the shader to apply to the screen, shader must already exist to use this. Either this or `path` must be used
+---@field order? number Sets the order. `ScreenShader` objects are rendered in order from lowest to highest. Defaults to 0 if not provided. 
+---@field path? string Name of the shader file to use if `shader` is not provided.
+---@field __call? fun(self: SMODS.ScreenShader|table, o: SMODS.ScreenShader|table): nil|table|SMODS.ScreenShader
+---@field extend? fun(self: SMODS.ScreenShader|table, o: SMODS.ScreenShader|table): table Primary method of creating a class. 
+---@field check_duplicate_register? fun(self: SMODS.ScreenShader|table): boolean? Ensures objects already registered will not register. 
+---@field check_duplicate_key? fun(self: SMODS.ScreenShader|table): boolean? Ensures objects with duplicate keys will not register. Checked on `__call` but not `take_ownership`. For take_ownership, the key must exist. 
+---@field register? fun(self: SMODS.ScreenShader|table) Registers the object. 
+---@field check_dependencies? fun(self: SMODS.ScreenShader|table): boolean? Returns `true` if there's no failed dependencies. 
+---@field send_to_subclasses? fun(self: SMODS.ScreenShader|table, func: string, ...: any) Starting from this class, recusively searches for functions with the given key on all subordinate classes and run all found functions with the given arguments. 
+---@field pre_inject_class? fun(self: SMODS.ScreenShader|table) Called before `inject_class`. Injects and manages class information before object injection. 
+---@field post_inject_class? fun(self: SMODS.ScreenShader|table) Called after `inject_class`. Injects and manages class information after object injection. 
+---@field inject_class? fun(self: SMODS.ScreenShader|table) Injects all direct instances of class objects by calling `obj:inject` and `obj:process_loc_text`. Also injects anything necessary for the class itself. Only called if class has defined both `obj_table` and `obj_buffer`. 
+---@field inject? fun(self: SMODS.ScreenShader|table, i?: number) Called during `inject_class`. Injects the object into the game. 
+---@field take_ownership? fun(self: SMODS.ScreenShader|table, key: string, obj: SMODS.ScreenShader|table, silent?: boolean): nil|table|SMODS.ScreenShader Takes control of vanilla objects. Child class must have get_obj for this to function
+---@field get_obj? fun(self: SMODS.ScreenShader|table, key: string): SMODS.ScreenShader|table? Returns an object if one matches the `key`. 
+---@field send_vars? fun(self: SMODS.ScreenShader|table): table? Used to send extra args to the shader via `Shader:send(key, value)`. 
+---@field should_apply? fun(self: SMODS.ScreenShader|table): boolean? Used to control if the ScreenShader should apply on the screen per-frame
+---@overload fun(self: SMODS.ScreenShader): SMODS.ScreenShader
+SMODS.ScreenShader = setmetatable({}, {
+    __call = function(self)
+        return self
+    end
+})
+
+---@type table<string, SMODS.ScreenShader|table>
+SMODS.ScreenShaders = {}

lsp_def/classes/shader.lua

@@ -3,8 +3,8 @@
 ---@class SMODS.Shader: SMODS.GameObject
 ---@field obj_table? table<string, SMODS.Shader|table> Table of objects registered to this class. 
 ---@field super? SMODS.GameObject|table Parent class. 
----@field key? string Unique string to reference this object. This, `path`, and shader name in the GLSL must be the same.
----@field path? string Name of the shader file. This, `key`, and shader name in the GLSL must be the same. 
+---@field key string Unique string to reference this object. This, `path`, and shader name in the GLSL must be the same.
+---@field path string Name of the shader file. This, `key`, and shader name in the GLSL must be the same. 
 ---@field __call? fun(self: SMODS.Shader|table, o: SMODS.Shader|table): nil|table|SMODS.Shader
 ---@field extend? fun(self: SMODS.Shader|table, o: SMODS.Shader|table): table Primary method of creating a class. 
 ---@field check_duplicate_register? fun(self: SMODS.Shader|table): boolean? Ensures objects already registered will not register. 

src/game_object.lua

@@ -3294,6 +3294,56 @@ Set `prefix_config.key = false` on your object instead.]]):format(obj.key), obj.
         process_loc_text = function() end
     }
 
+    -------------------------------------------------------------------------------------------------
+    ----- API CODE GameObject.ScreenShader
+    -------------------------------------------------------------------------------------------------
+
+    SMODS.ScreenShaders = {}
+    SMODS.ScreenShader = SMODS.GameObject:extend {
+        obj_table = SMODS.ScreenShaders,
+        obj_buffer = {},
+        required_params = {
+            "key",
+        },
+        set = "ScreenShader",
+        order = 0,
+        send_vars = nil, -- same as Shader.send_vars
+        should_apply = nil, -- function to determine if the shader should be drawn. defaults to true if not specified
+        inject = function(self)
+            assert(self.shader or self.path, "ScreenShader " .. self.key .. " not given shader key or path")
+            if self.path and (not self.shader) then
+                SMODS.Shader.inject(self)
+                self.shader = self.key
+            end
+        end,
+        post_inject_class = function(self)
+            table.sort(self.obj_buffer, function(_self, _other) return self.obj_table[_self].order < self.obj_table[_other].order end)
+        end,
+    }
+
+    SMODS.ScreenShader {
+        key = "CRT",
+        shader = "CRT",
+        send_vars = function(self)
+            local crt = G.SETTINGS.GRAPHICS.crt * 0.3
+            return {
+                ['distortion_fac'] = {1.0 + 0.07*crt/100, 1.0 + 0.1*crt/100},
+                ['scale_fac'] = {1.0 - 0.008*crt/100, 1.0 - 0.008*crt/100},
+                ['feather_fac'] = 0.01,
+                ['bloom_fac'] = G.SETTINGS.GRAPHICS.bloom - 1,
+                ['time'] = 400 + G.TIMERS.REAL,
+                ['noise_fac'] = 0.001*crt/100,
+                ['crt_intensity'] = 0.16*crt/100,
+                ['glitch_intensity'] = 0,
+                ['scanlines'] = G.CANVAS:getPixelHeight()*0.75/G.CANV_SCALE,
+                ['mouse_screen_pos'] = G.video_control and {love.graphics.getWidth( )/2, love.graphics.getHeight( )/2} or {G.ARGS.eased_cursor_pos.sx, G.ARGS.eased_cursor_pos.sy},
+                ['screen_scale'] = G.TILESCALE*G.TILESIZE,
+                ['hovering'] = 1,
+            }
+        end,
+        order = 0, -- not necessary, but explicitly set in this example for clarity
+    }
+
     -------------------------------------------------------------------------------------------------
     ----- API CODE GameObject.Edition
     -------------------------------------------------------------------------------------------------

src/utils.lua

@@ -3377,6 +3377,14 @@ function SMODS.log_crash_info(info, defined)
     end
 end
 
+
+-- Used for SMODS.ScreenShader, just to save lines re-creating canvases when relevant
+function SMODS.create_canvas()
+    local canvas = love.graphics.newCanvas(love.window.fromPixels(love.graphics.getWidth()) * G.CANV_SCALE, love.window.fromPixels(love.graphics.getHeight()) * G.CANV_SCALE, { type = '2d', readable = true })
+    canvas:setFilter('linear', 'linear')
+    return canvas
+end
+
 function SMODS.get_clean_pool(_type, _rarity, _legendary, _append)
     local pool = get_current_pool(_type, _rarity, _legendary, _append)
     local clean_pool = {}