262 lines
8.1 KiB
Lua
262 lines
8.1 KiB
Lua
local ffi = require 'ffi'
|
|
local joysticks
|
|
|
|
function init()
|
|
joysticks = love.joystick.getJoysticks()
|
|
for i, joystick in ipairs(joysticks) do
|
|
print(i, joystick:getName())
|
|
end
|
|
|
|
ffi.cdef[[
|
|
void load(const char * source_path);
|
|
void update_window(int width, int height);
|
|
void draw();
|
|
void update_keyboard(int up, int down, int left, int right,
|
|
int w, int s, int a, int d,
|
|
int t, int g, int f, int h,
|
|
int i, int k, int j, int l);
|
|
void update_mouse(int x, int y);
|
|
void update_joystick(int joystick_index,
|
|
float lx, float ly, float rx, float ry, float tl, float tr,
|
|
int up, int down, int left, int right,
|
|
int a, int b, int x, int y,
|
|
int leftshoulder, int rightshoulder,
|
|
int start);
|
|
void update(float time);
|
|
|
|
int draw_font_start();
|
|
int draw_font(int font_ix, char const * text, int x, int y);
|
|
|
|
void draw_line_quad_start();
|
|
void draw_line(int x1, int y1, int x2, int y2);
|
|
void draw_set_color(float r, float g, float b);
|
|
void draw_quad(int x1, int y1, int x2, int y2,
|
|
int x3, int y3, int x4, int y4);
|
|
]]
|
|
local source_path = love.filesystem.getSource()
|
|
local is_zip = source_path:sub(-#".zip") == ".zip"
|
|
local is_love = source_path:sub(-#".love") == ".love"
|
|
|
|
local platform = love.system.getOS()
|
|
|
|
local lib_name
|
|
if platform == "Linux" then
|
|
lib_name = "test.so"
|
|
elseif platform == "Windows" then
|
|
lib_name = "test.dll"
|
|
else
|
|
assert(false, "unsupported platform " .. platform)
|
|
end
|
|
|
|
if is_zip or is_love then
|
|
if love.filesystem.isFused() then
|
|
local archive = love.filesystem.getSourceBaseDirectory()
|
|
end
|
|
|
|
-- there is nothing wrong with the following 5 lines from an API
|
|
-- design/usability perspective
|
|
local identity = love.filesystem.getIdentity()
|
|
local non_existing_identity = "https://github.com/love2d/love/issues/2295"
|
|
love.filesystem.setIdentity(non_existing_identity:gsub("/", "_"))
|
|
local contents, size = love.filesystem.read("data", lib_name)
|
|
love.filesystem.setIdentity(identity)
|
|
|
|
assert(contents ~= nil, size)
|
|
local write_success, message = love.filesystem.write(lib_name, contents, size)
|
|
assert(write_success, lib_name, message)
|
|
local lib_directory = love.filesystem.getRealDirectory(lib_name)
|
|
test = ffi.load(lib_directory .. "/" .. lib_name)
|
|
else
|
|
test = ffi.load("./" .. lib_name)
|
|
end
|
|
test.load(source_path)
|
|
|
|
local bgm = love.audio.newSource("Suite.mp3", "stream")
|
|
bgm:setLooping(true)
|
|
bgm:play()
|
|
end
|
|
|
|
local update = function(time)
|
|
for joystick_index, joystick in ipairs(joysticks) do
|
|
if joystick_index > 8 then
|
|
break
|
|
end
|
|
local lx = joystick:getGamepadAxis("leftx")
|
|
local ly = joystick:getGamepadAxis("lefty")
|
|
local rx = joystick:getGamepadAxis("rightx")
|
|
local ry = joystick:getGamepadAxis("righty")
|
|
local tl = joystick:getGamepadAxis("triggerleft")
|
|
local tr = joystick:getGamepadAxis("triggerright")
|
|
local up = joystick:isGamepadDown("dpup")
|
|
local down = joystick:isGamepadDown("dpdown")
|
|
local left = joystick:isGamepadDown("dpleft")
|
|
local right = joystick:isGamepadDown("dpright")
|
|
local a = joystick:isGamepadDown("a")
|
|
local b = joystick:isGamepadDown("b")
|
|
local x = joystick:isGamepadDown("x")
|
|
local y = joystick:isGamepadDown("y")
|
|
local leftshoulder = joystick:isGamepadDown("leftshoulder")
|
|
local rightshoulder = joystick:isGamepadDown("rightshoulder")
|
|
local start = joystick:isGamepadDown("start")
|
|
--print("start", i, start)
|
|
test.update_joystick(joystick_index - 1,
|
|
lx, ly, rx, ry, tl, tr,
|
|
up, down, left, right,
|
|
a, b, x, y,
|
|
leftshoulder, rightshoulder,
|
|
start)
|
|
end
|
|
|
|
local up = love.keyboard.isDown("up")
|
|
local down = love.keyboard.isDown("down")
|
|
local left = love.keyboard.isDown("left")
|
|
local right = love.keyboard.isDown("right")
|
|
local w = love.keyboard.isDown("w")
|
|
local s = love.keyboard.isDown("s")
|
|
local a = love.keyboard.isDown("a")
|
|
local d = love.keyboard.isDown("d")
|
|
local t = love.keyboard.isDown("t")
|
|
local g = love.keyboard.isDown("g")
|
|
local f = love.keyboard.isDown("f")
|
|
local h = love.keyboard.isDown("h")
|
|
local i = love.keyboard.isDown("i")
|
|
local k = love.keyboard.isDown("k")
|
|
local j = love.keyboard.isDown("j")
|
|
local l = love.keyboard.isDown("l")
|
|
test.update_keyboard(up, down, left, right,
|
|
w, s, a, d,
|
|
t, g, f, h,
|
|
i, k, j, l);
|
|
|
|
test.update(time)
|
|
end
|
|
|
|
local draw = function()
|
|
test.draw()
|
|
end
|
|
|
|
local nico_draw = function()
|
|
----------------------------------------------------------------------
|
|
-- font drawing
|
|
----------------------------------------------------------------------
|
|
|
|
-- call "draw_font_start()" prior each "group" of "draw_font()" calls
|
|
--
|
|
-- a "group" of draw_font() calls are back-to-back/consecutive,
|
|
-- with no non-font drawing between them.
|
|
--
|
|
-- For example:
|
|
|
|
local font_ix = test.draw_font_start()
|
|
local x = 512
|
|
local y = 50
|
|
y = y + test.draw_font(font_ix, "lua test", x, y)
|
|
y = y + test.draw_font(font_ix, "cool", x, y)
|
|
|
|
-- note that "font_ix" is the current "best font" as calculated
|
|
-- from the current window size, and might change next frame if the
|
|
-- window is resized.
|
|
--
|
|
-- Any of this of course could be changed to match your precise
|
|
-- requirements.
|
|
|
|
----------------------------------------------------------------------
|
|
-- line drawing
|
|
----------------------------------------------------------------------
|
|
|
|
-- call "draw_line_quad_start()" prior to each "group" of
|
|
-- "draw_line()" or "draw_quad()" calls
|
|
--
|
|
-- a "group" of draw_line()/draw_quad() calls are
|
|
-- back-to-back/consecutive, with no non-line/quad drawing between
|
|
-- them.
|
|
--
|
|
-- For example:
|
|
|
|
test.draw_line_quad_start()
|
|
test.draw_set_color(1.0, 0.0, 0.0) -- r, g, b (0.0 to 1.0)
|
|
test.draw_line(0, 0, 1024, 1024) -- x1, y1, x2, y2
|
|
test.draw_line(700, 300, 400, 500)
|
|
test.draw_set_color(0.0, 1.0, 0.0)
|
|
test.draw_line(700, 300, 400, 700)
|
|
|
|
-- x1, y1, x2, y2,
|
|
-- x3, y3, x4, y4,
|
|
--
|
|
-- vertices must be specified In "counter clockwise" order, as in:
|
|
--
|
|
-- 2──1
|
|
-- │ │ valid (counter clockwise)
|
|
-- 3──4
|
|
--
|
|
-- these can also be rotated, as in:
|
|
--
|
|
-- 3
|
|
-- ╱ ╲
|
|
-- 4 2 valid (counter clockwise)
|
|
-- ╲ ╱
|
|
-- 1
|
|
--
|
|
-- however "mirroring" is not valid, as in:
|
|
--
|
|
-- 1──2
|
|
-- │ │ not valid (clockwise)
|
|
-- 4──3
|
|
--
|
|
test.draw_set_color(0.0, 0.0, 1.0)
|
|
test.draw_quad(
|
|
600, 600, -- top right
|
|
500, 600, -- top left
|
|
500, 700, -- bottom left
|
|
600, 700 -- bottom right
|
|
)
|
|
test.draw_set_color(0.0, 0.5, 1.0)
|
|
test.draw_quad(
|
|
900, 900, -- bottom
|
|
950, 850, -- right
|
|
900, 800, -- top
|
|
850, 850 -- left
|
|
)
|
|
|
|
-- If you want to draw a large number of lines or quads in bulk
|
|
-- (e.g: 10,000+ lines/quads per frame), this interface might not be good
|
|
-- enough, and we should discuss this in more detail.
|
|
end
|
|
|
|
function love.run()
|
|
init()
|
|
|
|
return function()
|
|
love.event.pump()
|
|
for name, a,b,c,d,e,f,g,h in love.event.poll() do
|
|
if name == "quit" then
|
|
if c or not love.quit or not love.quit() then
|
|
return a or 0, b
|
|
end
|
|
end
|
|
end
|
|
|
|
local width
|
|
local height
|
|
local flags
|
|
width, height, flags = love.window.getMode()
|
|
test.update_window(width, height)
|
|
|
|
local time = love.timer.getTime()
|
|
update(time)
|
|
|
|
draw()
|
|
|
|
local mouse_down = love.mouse.isDown(1)
|
|
if mouse_down then
|
|
local x, y = love.mouse.getPosition()
|
|
test.update_mouse(x, y)
|
|
end
|
|
|
|
--nico_draw()
|
|
|
|
love.graphics.present()
|
|
love.timer.sleep(0.001)
|
|
end
|
|
end
|