Function render

pyrender.py:971–3018

(objects:list, lights:list, cam:Camera)

def render(objects:list, lights:list, cam:Camera):
    def get_luminance(normal, x3d, y3d, z3d) -> list:
        def in_point_light_shadow():
            x_light1, y_light1, z_light1 = (
                x_light * light.rotation1[0][0] + y_light * light.rotation1[0][1] + z_light * light.rotation1[0][2],
                x_light * light.rotation1[1][0] + y_light * light.rotation1[1][1] + z_light * light.rotation1[1][2],
                x_light * light.rotation1[2][0] + y_light * light.rotation1[2][1] + z_light * light.rotation1[2][2],
            )
            if z_light1 > light.shadow_properties[1]:
                x2d = light.shadow_properties[4] + int(x_light1 * light.shadow_properties[3] / z_light1)
                y2d = light.shadow_properties[4] - int(y_light1 * light.shadow_properties[3] / z_light1)
                if 0 <= x2d < light.shadow_properties[0] and 0 <= y2d < light.shadow_properties[0]:
                    bias = (1 - (light.rotation1[2][0] * normal[0] + light.rotation1[2][1] * normal[1] + light.rotation1[2][2] * normal[2])) * (cam.z_far - cam.z_near) * bias_scalar * 0.001
                    if z_light1 > light.shadow_map1[y2d][x2d] + bias:
                        return True
                
            x_light2, y_light2, z_light2 = (
                x_light * light.rotation2[0][0] + y_light * light.rotation2[0][1] + z_light * light.rotation2[0][2],
                x_light * light.rotation2[1][0] + y_light * light.rotation2[1][1] + z_light * light.rotation2[1][2],
                x_light * light.rotation2[2][0] + y_light * light.rotation2[2][1] + z_light * light.rotation2[2][2],
            )
            if z_light2 > light.shadow_properties[1]:
                x2d = light.shadow_properties[4] + int(x_light2 * light.shadow_properties[3] / z_light2)
                y2d = light.shadow_properties[4] - int(y_light2 * light.shadow_properties[3] / z_light2)
                if 0 <= x2d < light.shadow_properties[0] and 0 <= y2d < light.shadow_properties[0]:
                    bias = (1 - (light.rotation2[2][0] * normal[0] + light.rotation2[2][1] * normal[1] + light.rotation2[2][2] * normal[2])) * (cam.z_far - cam.z_near) * bias_scalar * 0.001
                    if z_light2 > light.shadow_map2[y2d][x2d] + bias:
                        return True
                
            x_light3, y_light3, z_light3 = (
                x_light * light.rotation3[0][0] + y_light * light.rotation3[0][1] + z_light * light.rotation3[0][2],
                x_light * light.rotation3[1][0] + y_light * light.rotation3[1][1] + z_light * light.rotation3[1][2],
                x_light * light.rotation3[2][0] + y_light * light.rotation3[2][1] + z_light * light.rotation3[2][2],
            )
            if z_light3 > light.shadow_properties[1]:
                x2d = light.shadow_properties[4] + int(x_light3 * light.shadow_properties[3] / z_light3)
                y2d = light.shadow_properties[4] - int(y_light3 * light.shadow_properties[3] / z_light3)
                if 0 <= x2d < light.shadow_properties[0] and 0 <= y2d < light.shadow_properties[0]:
                    bias = (1 - (light.rotation3[2][0] * normal[0] + light.rotation3[2][1] * normal[1] + light.rotation3[2][2] * normal[2])) * (cam.z_far - cam.z_near) * bias_scalar * 0.001
                    if z_light3 > light.shadow_map3[y2d][x2d] + bias:
                        return True
                
            x_light4, y_light4, z_light4 = (
                x_light * light.rotation4[0][0] + y_light * light.rotation4[0][1] + z_light * light.rotation4[0][2],
                x_light * light.rotation4[1][0] + y_light * light.rotation4[1][1] + z_light * light.rotation4[1][2],
                x_light * light.rotation4[2][0] + y_light * light.rotation4[2][1] + z_light * light.rotation4[2][2],
            )
            if z_light4 > light.shadow_properties[1]:
                x2d = light.shadow_properties[4] + int(x_light4 * light.shadow_properties[3] / z_light4)
                y2d = light.shadow_properties[4] - int(y_light4 * light.shadow_properties[3] / z_light4)
                if 0 <= x2d < light.shadow_properties[0] and 0 <= y2d < light.shadow_properties[0]:
                    bias = (1 - (light.rotation4[2][0] * normal[0] + light.rotation4[2][1] * normal[1] + light.rotation4[2][2] * normal[2])) * (cam.z_far - cam.z_near) * bias_scalar * 0.001
                    if z_light4 > light.shadow_map4[y2d][x2d] + bias:
                        return True
                
            x_light5, y_light5, z_light5 = (
                x_light * light.rotation5[0][0] + y_light * light.rotation5[0][1] + z_light * light.rotation5[0][2],
                x_light * light.rotation5[1][0] + y_light * light.rotation5[1][1] + z_light * light.rotation5[1][2],