We have a perspective camera, which is looking onto the ground under some angle (22.5 degrees on x axis worked well for us). FOV is 1.0177028.
I'm pretty sure you can achieve the same effect in love2d without " a lot of work"
True Neutral Aspirant. Why, yes, i do indeed enjoy sarcastically correcting others when they make the most blatant of spelling mistakes. No bullying or trolling the innocent tho.Yes, that's why I didn't say "a lot of work".
That's like saying "all Turing-complete programming languages are equally powerful." It's obviously true in the theoretical sense, but in practice it's totally unhelpful, because there can be major differences in the suitability of different languages for different tasks. Even if you write a custom shader, you'd still (AFAICT) have to rewrite any drawing primitives that you want to use. You can't just magically pass
Code: Select all
local function groundToScreen(x, y)
-- Apply any translation/rotation etc. first.
-- Then do the perspective transform
local z = 1 - cosAngle * y/h
x, y = w/2 + (x - w/2) / z, y * sinAngle / z
return x, y
end
local function screenToGround(x, y)
-- Undo the perspective transform first.
local z = sinAngle / (sinAngle + y/h * cosAngle)
x, y = w/2 + (x - w/2) * z, y / sinAngle * z
-- Then undo any rotation/translation etc.
return x, y
end
function love.load()
angle = 0.2 * math.pi
cosAngle, sinAngle = math.sin(angle), math.cos(angle)
w, h = love.graphics.getDimensions()
groundShader = love.graphics.newShader([[
uniform vec2 size;
uniform float cosAngle, sinAngle;
vec4 position(mat4 m, vec4 p) {
p.z = 1.0 - p.y / size.y * cosAngle;
p.y *= sinAngle / p.z;
p.x = 0.5 * size.x + (p.x - 0.5 * size.x) / p.z;
return m * p;
}
]])
end
local function standingRect(left, bottom, width, height)
local pixelLeft, pixelBottom = groundToScreen(left, bottom)
local pixelRight = groundToScreen(left + width, bottom)
local pixelWidth = pixelRight - pixelLeft
local pixelHeight = height * pixelWidth / width
return pixelLeft, pixelBottom - pixelHeight, pixelWidth, pixelHeight
end
local function pointInRect(x, y, left, top, width, height)
local inHorizontal = x >= left and x < left + width
local inVertical = y >= top and y < top + height
return inHorizontal and inVertical
end
local function mouseInGroundRect(x, y, w, h)
local mx, my = screenToGround(love.mouse.getPosition())
return pointInRect(mx, my, x, y, w, h)
end
function love.draw()
w, h = love.graphics.getDimensions()
cosAngle, sinAngle = math.cos(angle), math.sin(angle)
love.graphics.setShader(groundShader)
groundShader:send("size", {w, h})
groundShader:send("cosAngle", cosAngle)
groundShader:send("sinAngle", sinAngle)
for y = 0, 11 do
for x = 0, 15 do
if (x + y) % 2 == 0 then
if mouseInGroundRect(x * 50, y * 50, 50, 50) then
love.graphics.setColor(0.4, 0.4, 0.3)
else
love.graphics.setColor(0.3, 0.3, 0.25)
end
love.graphics.rectangle('fill', x * 50, y * 50, 50, 50)
end
end
end
love.graphics.setShader()
love.graphics.setColor(0.3, 0.2, 0.5)
love.graphics.rectangle('fill', standingRect(250, 350, 50, 100))
end
Wow this piece of code is something great.Edit: here you go. This doesn't handle scrolling the ground because that was more work and I couldn't be bothered. But it should get you started.
Yeah, that's an actual 3D perspective view. The tops of the upright rectangles are bigger because they're closer to the camera. If you want to do that in a vertex shader, you need the full 3D coordinates of all the corners. Otherwise how do you know which ones are "on the ground" and which ones are up in the air? Any x/y position could be interpreted as some position on the ground, so the shader can't tell.
Users browsing this forum: Bing [Bot] and 3 guests
