Textured Polygons for All!

Showcase your libraries, tools and other projects that help your fellow love users.
grump
Party member
Posts: 678
Joined: Sat Jul 22, 2017 7:43 pm

Re: Textured Polygons for All!

Post by grump » Wed Jun 06, 2018 5:02 pm

molul wrote:
Wed Jun 06, 2018 4:24 pm
1.- I'm using the setRepeat function to make an endless animation (see attached sample), but I'm getting a serious flickering I can't seem to fix even with really high msaa values. Is there anything I else I could try to fix it or at least make it much less annoying?
Increase anisotropy.

Code: Select all

love.graphics.setDefaultFilter("linear", "linear", 2)
Don't put lines at the edges of the texture. Shift the texture by half a tile.
I don't know if love generates mipmaps, if it doesn't, you can't get entirely rid of the flickering.

Edit: there's a flag for mipmapping, try setting that to true.

User avatar
molul
Party member
Posts: 264
Joined: Sun Feb 05, 2012 6:51 pm
Location: Valencia, Spain
Contact:

Re: Textured Polygons for All!

Post by molul » Sun Jul 22, 2018 10:35 am

Oops, I forgot to thank the last post ^^U Thanks, it really helped :)

I have a question about this module: I'm using a grid texture, and if I don't do love.graphics.setColor(1,1,1,0) (I'm on 11.1) it will draw a white solid color instead of the grid. Does it make sense? Should I do it in another way?

EDIT: apparently I can't use this shader on a Rockchip RK3066 because it's not GLSL ES compatible, but I can't seem to find what is needed to make it compatible. Any idea?

User avatar
Xii
Citizen
Posts: 64
Joined: Thu Aug 13, 2020 9:09 pm
Contact:

Re: Textured Polygons for All!

Post by Xii » Sun Dec 20, 2020 12:34 am

Just popping in to say, this shader's great! I combined a color replacement shader with it and re-routed the whole thing through a Mesh for vertex color tinting. Lookin' good!

User avatar
Davidobot
Party member
Posts: 1209
Joined: Sat Mar 31, 2012 5:18 am
Location: Cambridge, UK
Contact:

Re: Textured Polygons for All!

Post by Davidobot » Mon Dec 21, 2020 9:15 pm

Xii wrote:
Sun Dec 20, 2020 12:34 am
Just popping in to say, this shader's great! I combined a color replacement shader with it and re-routed the whole thing through a Mesh for vertex color tinting. Lookin' good!
Super cool, Xii! Do you plan on realising your code as a library?
My projects: Raycaster, love.js v11.3 port
itch page: link
My website: link
My library: LovelyMoon

User avatar
Xii
Citizen
Posts: 64
Joined: Thu Aug 13, 2020 9:09 pm
Contact:

Re: Textured Polygons for All!

Post by Xii » Mon Dec 21, 2020 9:56 pm

Davidobot wrote:
Mon Dec 21, 2020 9:15 pm
Super cool, Xii! Do you plan on realising your code as a library?
Sure, sharing is caring. I'll do a proper release on the forum when my game's more fleshed out. I've included my progress so far, below.

Just added (quad wide) lighting. :awesome:

Code: Select all

local texw,texh = 0,0
--temp tuples to avoid continous allocation of tables
local shaderp1,shaderp2,shaderp3,shaderp4,shaderp5,shaderp6 = {0,0},{0,0},{0,0},{0,0},{0,0},{0,0}

-- tx,ty is top-left corner of quad on texture, in pixels
-- tw,th is width and height of quad on texture, in pixels
-- flip is horizontal flip of quad on texture, true/false
-- x1,y1..x4,y4 are quad corners on screen in pixels, clockwise starting from top left
-- r,g,b,a are vertex fog colors, in same order
function draw_textured_quad(tx,ty,tw,th,flip, x1,y1, x2,y2, x3,y3, x4,y4, r1,g1,b1,a1, r2,g2,b2,a2, r3,g3,b3,a3, r4,g4,b4,a4)
	if flip then
		shaderp1[1],shaderp1[2] = (tx+tw)/texw, ty/texh
		shaderp2[1],shaderp2[2] = -tw/texw, th/texh
	else
		shaderp1[1],shaderp1[2] = tx/texw, ty/texh
		shaderp2[1],shaderp2[2] = tw/texw, th/texh
	end
	shaderp3[1],shaderp3[2] = x1, y1
	shaderp4[1],shaderp4[2] = x2, y2
	shaderp5[1],shaderp5[2] = x3, y3
	shaderp6[1],shaderp6[2] = x4, y4
	
	xii_shader:send("p0", shaderp1)
	xii_shader:send("rep", shaderp2)
	
	xii_shader:send("v1", shaderp3)
	xii_shader:send("v2", shaderp4)
	xii_shader:send("v3", shaderp5)
	xii_shader:send("v4", shaderp6)
	
	-- I don't know why the vertex color indices are shifted by 1...
	quad:setVertex(1, x1,y1, tx/texw,ty/texh, r2,g2,b2,a2)
	quad:setVertex(2, x2,y2, (tx+tw)/texw,ty/texh, r3,g3,b3,a3)
	quad:setVertex(3, x3,y3, (tx+tw)/texw,(ty+th)/texh, r4,g4,b4,a4)
	quad:setVertex(4, x4,y4, tx/texw,(ty+th)/texh, r1,g1,b1,a1)
	
	love.graphics.draw(quad)
end

function set_texture(img)
	quad:setTexture(img)
	texw,texh = img:getWidth(), img:getHeight()
end

-- what this essentially does is redefines the meaning of the red, green, and blue channels in the texture to any arbitrary colors, plus also the anti-channel (the color you get with RGB 0,0,0, i.e. black).
-- this allows you to do 4-color palette swapping, with gradients! usually palette swap mechanisms replace specific pixel values, which doesn't allow for gradients.
-- colors[4] = {b={R,G,B}, R={R,G,B}, G={R,G,B}, B={R,G,B}}
-- for normal colors, use {{0,0,0}, {1,0,0}, {0,1,0}, {0,0,1}} (i.e. black, red, green, and blue - the default channels of RGB!)
function set_palette(colors)
    xii_shader:sendColor("color_0", colors[1])
    xii_shader:sendColor("color_r", colors[2])
    xii_shader:sendColor("color_g", colors[3])
    xii_shader:sendColor("color_b", colors[4])
end

-- alpha channel is intensity. 0 is dark, .5 is fully lit, and 1 is over-lit. so {1,1,1,.5} is normal lighting.
function set_light(color)
	xii_shader:sendColor("light", color)
end

quad = love.graphics.newMesh(4, "fan", "stream")

xii_shader = love.graphics.newShader[[
	// by xXxMoNkEyMaNxXx and Xii

	extern vec2 v1;
	extern vec2 v2;
	extern vec2 v3;
	extern vec2 v4;

	extern vec2 p0;
	extern vec2 rep;

	extern vec3 color_0;
	extern vec3 color_r;
	extern vec3 color_g;
	extern vec3 color_b;
	
	extern vec4 light;

	vec2 one=vec2(1.0,1.0);

	number c(vec2 v1,vec2 v2)
	{
	   return v1.x*v2.y-v2.x*v1.y;
	}
	number intersect(vec2 v1,vec2 d1,vec2 v2,vec2 d2)
	{
	   //v1+d1*
	   return c(v2-v1,d2)/c(d1,d2);
	}
	
	vec4 effect(vec4 color, Image img, vec2 UNUSED2, vec2 inverted)
	{
	   vec2 p=vec2(inverted.x,inverted.y);

	   vec2 A1=normalize(v2-v1);
	   vec2 A2=normalize(v3-v4);

	   vec2 B1=normalize(v2-v3);
	   vec2 B2=normalize(v1-v4);

	   number Adiv=c(A1,A2);
	   number Bdiv=c(B1,B2);

	   vec2 uv;

	   bvec2 eq0=bvec2(abs(Adiv)<=0.0001,abs(Bdiv)<=0.0001);
	   if(eq0.x && eq0.y){
		  //Both edges are parallel, therefore the shape is a parallelogram (Isometric)
		  number dis=dot(p-v1,A1);

		  //cos theta
		  number ct=dot(A1,B1);

		  //Closest point on v1->A1 to p
		  vec2 pA=v1+A1*dis;

		  //uv
		  number r=length(p-pA)/sqrt(1-ct*ct);
		  uv=vec2(1-r/length(v2-v3),(dis+r*ct)/length(v2-v1));
	   }else if(eq0.x){
		  //One Vanishing point occurs in numerically set scenarios in 3D, and is a feature of 2.5D

		  //Horizon is A1 (=A2) from B
		  vec2 Vp=v3+B1*c(v4-v3,B2)/Bdiv;

		  //Some point in the distance that diagonals go to
		  vec2 D=Vp+A1*intersect(Vp,A1,v4,normalize(v2-v4));

		  //uv
		  number u=intersect(v1,A1,Vp,normalize(p-Vp));
		  number v=intersect(v1,A1,D,normalize(p-D))-u;

		  number len=length(v2-v1);
		  uv=vec2(len-v,u)/len;//Reversed components to match up with other one
	   }else if(eq0.y){
		  //If the other edge is the parallel one
		  vec2 Vp=v1+A1*c(v4-v1,A2)/Adiv;
		  vec2 D=Vp+B1*intersect(Vp,B1,v4,normalize(v2-v4));
		  number u=intersect(v3,B1,Vp,normalize(p-Vp));
		  number len=length(v2-v3);
		  uv=vec2(u,len-intersect(v3,B1,D,normalize(p-D))+u)/len;
	   }else{
		  //Else, two vanishing points

		  //*intersect(v1,A1,v4,A2)
		  //*intersect(v3,B1,v4,B2)

		  //Vanishing points
		  vec2 A=v1+A1*c(v4-v1,A2)/Adiv;
		  vec2 B=v3+B1*c(v4-v3,B2)/Bdiv;

		  //Horizon
		  vec2 H=normalize(A-B);

		  //Pixel
		  uv=vec2(intersect(v4,-H,A,normalize(p-A))/intersect(v4,-H,v2,-A1),intersect(v4,H,B,normalize(p-B))/intersect(v4,H,v2,-B1));
	   }

		vec4 pixel = Texel(img, mod(uv*rep+vec2(p0.x-1,p0.y), one));//This is the current pixel color
		
		// palette swap
		vec3 blend_r = mix(color_0, color_r, pixel.r);
		vec3 blend_g = mix(color_0, color_g, pixel.g);
		vec3 blend_b = mix(color_0, color_b, pixel.b);
		vec3 blend = blend_r + blend_g + blend_b;
		
		// light
		blend.rgb = light.rgb * light.a * 2.0 * blend.rgb;
		
		// fog
		return vec4(mix(blend, color.rgb, color.a), pixel.a);
	}
]]

Post Reply

Who is online

Users browsing this forum: jotapapel and 33 guests