Exemplo n.º 1
0
 def __init__(self, file):
     self.file = file
     self.verts = []
     self.faces = []
     self.uv = []
     self.normals = []
     self.__diffusemap = TGAImage()
     self.__load()
Exemplo n.º 2
0
def main():
    model = Model("obj/african_head.obj")
    image = TGAImage(width, height, Format.RGB)

    # model.write("info.txt")
    zbuffer = []

    for i in range(0, image.width * image.height):
        zbuffer.append(-sys.maxint - 1)

    for i in range(0, len(model.faces)):
        screen_coord = [Vector(), Vector(), Vector()]
        world_coords = [Vector(), Vector(), Vector()]
        for j in range(0, 3):
            world_coord_vector = model.get_vert(i, j)
            screen_coord[j].x = int((world_coord_vector.x + 1.) * width / 2)
            screen_coord[j].y = int((world_coord_vector.y + 1.) * height / 2)
            screen_coord[j].z = int((world_coord_vector.z + 1.) * depth / 2)
            world_coords[j] = world_coord_vector
        # n = (world_coords[2] - world_coords[0]) ^ (world_coords[1] - world_coords[0])
        # norm = n.normalize()
        # intensity = norm.mul(light_intensity_vector)
        # if intensity < 0:  # skip invisible triangle
        #     continue

        uv = [Vector(), Vector(), Vector()]
        for k in range(0, 3):
            uv[k] = model.get_uv(i, k)
        norms = [Vector(), Vector(), Vector()]

        for k in range(0, 3):
            norms[k] = model.get_norm(i, k)

        # random_color = Color(randint(0, 255), randint(0, 255), randint(0, 255), 255)
        # color = Color(int(intensity * 255), int(intensity * 255), int(intensity * 255), 255)
        triangle(screen_coord[0], screen_coord[1], screen_coord[2], uv[0], uv[1], uv[2], norms[0], norms[1], norms[2], image, zbuffer, model)

    image.write("output.tga")
Exemplo n.º 3
0
class Model:
    def __init__(self, file):
        self.file = file
        self.verts = []
        self.faces = []
        self.uv = []
        self.normals = []
        self.__diffusemap = TGAImage()
        self.__load()


    def __load(self):
        f = open(self.file, "r")
        for line in f:
            split = line.split()
            if len(split) > 0:
                if split[0] == "v":
                    vector = Vector(float(split[1]), float(split[2]), float(split[3]))
                    self.verts.append(vector)
                elif split[0] == "f":
                    face = [Vector(), Vector(), Vector()]
                    for i in range(0, 3):
                        face[i].x = int(split[i + 1].split("/")[0]) - 1    # 1 - based format
                        face[i].y = int(split[i + 1].split("/")[1]) - 1
                        face[i].z = int(split[i + 1].split("/")[2]) - 1
                    self.faces.append(face)
                elif split[0] == "vt":
                     texture = Vector(float(split[1]), float(split[2]), float(split[3]))
                     self.uv.append(texture)
                elif split[0] == "vn":
                     norm = Vector(float(split[1]), float(split[2]), float(split[3]))
                     self.normals.append(norm)
        print "%s    verts = %s   faces = %s   normals = %s   uv = %s" \
              % (self.file, len(self.verts), len(self.faces), len(self.normals), len(self.uv))
        f.close()
        self.__diffusemap.read(self.file.split(".")[0] + "_diffuse.tga")
        # self.__diffusemap.flip_vertically()
        # self.__diffusemap.write("n***a.tga")

    def write(self, filename):
        f = open(filename, "w")
        for v in self.verts:
            f.write('v ' + str(v.x) + '  ' + str(v.y) + '  ' + str(v.z) + '\n')
        f.write('\n')
        f.write("verts = %s " % (len(self.verts)))
        f.write('\n')
        for ff in self.faces:
            f.write('f ' + str(ff.x) + '  ' + str(ff.y) + '  ' + str(ff.z) + '\n')
        f.write("faces = %s " % (len(self.faces)))
        f.write('\n')
        for vt in self.vtextures:
            f.write('vt ' + str(vt.x) + '  ' + str(vt.y) + '  ' + str(vt.z) + '\n')
        f.write("textures = %s " % (len(self.vtextures)))
        f.close()

    def get_uv(self, iface, nvert):
        face = self.faces[iface]
        idx = face[nvert].get(1)
        return Vector(int(round(self.uv[idx].x * self.__diffusemap.width)), int(round(self.uv[idx].y * self.__diffusemap.height)))

    def get_norm(self, iface, nvert):
        face = self.faces[iface]
        idx = face[nvert].get(2)
        return self.normals[idx]

    def get_vert(self, iface, nvert):
        face = self.faces[iface]
        idx = face[nvert].get(0)
        return self.verts[idx]

    def diffuse(self, vect):
        return self.__diffusemap.get(int(round(vect.x)), int(round(vect.y)))