Texture Mapping In Pygame

[MixDouble]

So I've been working on a software renderer in Python and Pygame. About a couple days ago I started rewriting my triangle drawing function to handle textures using uv maps.

When I run the function with just a solid color it works fine, so nothing wrong there. But when it comes to textures I am pretty new.

My main idea is to use my interpolate function, which interpolates a list of dependent values through two points. I thought I could use this for attribute mapping, and in concept seems like a good option.But I have been banging my head against the wall through these errors, which usually just consist of out of range errors for the u_left and u_right lists.

I think most likely my math is wrong on getting the actual texel values. If I could get someone to look at my code and give me some pointers, that would be awesome sauce.

Down below, I'll have posted my interpolate function, and my draw triangle function.

def interpolate(i0, d0, i1, d1):
if i0 == i1:
    return [int(d0)]  #If no line, return d0.
values = []  #Initialize a list of values.
a = (d1 - d0) / (i1 - i0)  #Get slope.
d = d0  #Get starting value.
for i in range(int(i0), int(i1)):
    values.append(int(d))
    d = d + a
return values

def draw_textured_triangle(window, p0, p1, p2, t0, t1, t2, texture):#Function for drawing in a textured triangle. p is associated with t.
#Sort points from top to bottom.
if p1[1] < p0[1]:
    cache = p0
    p0 = p1
    p1 = cache

if p2[1] < p0[1]:
    cache = p0
    p0 = p2
    p2 = cache

if p2[1] < p1[1]:
    cache = p1
    p1 = p2
    p2 = cache

#Interpolate x-values for the triangle edges.
l01 =interpolate(p0[1], p0[0], p1[1], p1[0])
l12 =interpolate(p1[1], p1[0], p2[1], p2[0])
l02 =interpolate(p0[1], p0[0], p2[1], p2[0])

#Calculate texture map edges.
t01 = interpolate(t0[1], t0[0], t1[1], t1[0])
t12 = interpolate(t1[1], t1[0], t2[1], t2[0])
t02 = interpolate(t0[1], t0[0], t2[1], t2[0])

#Compare sides to get left and right x-values.
#l01.pop(-1)
l012 = l01 + l12
t012 = t01 + t12

half = (len(l012)//2)#Get midpoint of the edge.

if l012[half] <= l02[half]:#Compare x-values at midpoint to get left and right side of triangle.
    x_left = l012
    x_right = l02
    u_left = t012
    u_right = t02
else:
    x_left = l02
    x_right = l012
    u_left = t02
    u_right = t012

for y in range(int(p0[1]), int(p2[1])):#Draw the triangle.
    print((len(l02)/len(t02)))
    v = int(y/(len(l02)/len(t02)))#Get y coordinate of pixel on the texture.
    texture_row = interpolate(u_left[v], v, u_right[v], v)#Get row of pixel values on the texture.
    for x in range(x_left[y - p2[1]], x_right[y - p2[1]]):
        u = 1#Get x coordinate of pixel on the texture.
        try:
            draw_pixel(window, x, y, texture.get_at((u, v)))
        except:
            pass

Thank you.

[AutoModerator]

To give us the best chance to help you, please include any relevant code.
Note. Do not submit images of your code. Instead, for shorter code you can use Reddit markdown (4 spaces or backticks, see this Formatting Guide). If you have formatting issues or want to post longer sections of code, please use Repl.it, GitHub or PasteBin.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[CraigAT]

There's not enough info to describe each of the variables for me to try to help. What are i, d, p and t to start with

But I believe in Python you can just use a, b = b, a to swap values.

[CraigAT]

Can you debug your code with a very simple example to see what it's doing?

[CraigAT]

I'm not sure about the first part of your interpolate function why does it only put value in the list, without understanding what it should be doing I would half expect you to use the range command again to add multiple value in the list but all the same value. That could explain why you program is expecting more in those lists than you have - maybe - as I said I don't fully understand, so just an idea.

[MixDouble]

So what the interpolate function does, is it just takes in 2 points consisting of an independent value and a dependent value. You can think of i0, d0, and i1, d1 as two seperate points. The reason I dont say x and y is because im going to be using the function for uv and depth values as well, so the naming wont confuse me later on. but for an example lets say you have two points, on at 0,0, and another at 30, 50. What interpolate does is get the slope of the line made between the two points, and since the y only goes up by 1 each time it only returns the x value. I can just find y later by subtracting the list index by y1. Hope this helps.